Use typed settings storage for windows

Group window settings into structs. Include rect sizes in regular and maximized
state and maximized flag. Use them instead of manipulations with string names.

apps/openmw/CMakeLists.txt

@@ -44,7 +44,7 @@ add_openmw_dir (mwgui
     tradeitemmodel companionitemmodel pickpocketitemmodel controllers savegamedialog
     recharge mode videowidget backgroundimage itemwidget screenfader debugwindow spellmodel spellview
     draganddrop timeadvancer jailscreen itemchargeview keyboardnavigation textcolours statswatcher
-    postprocessorhud
+    postprocessorhud settings
     )
 
 add_openmw_dir (mwdialogue

apps/openmw/mwgui/inventorywindow.cpp

@@ -16,7 +16,7 @@
 
 #include <components/myguiplatform/myguitexture.hpp>
 
-#include <components/settings/settings.hpp>
+#include <components/settings/values.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/mechanicsmanager.hpp"
@@ -34,6 +34,7 @@
 #include "draganddrop.hpp"
 #include "inventoryitemmodel.hpp"
 #include "itemview.hpp"
+#include "settings.hpp"
 #include "sortfilteritemmodel.hpp"
 #include "tooltips.hpp"
 #include "tradeitemmodel.hpp"
@@ -54,6 +55,23 @@ namespace
 
 namespace MWGui
 {
+    namespace
+    {
+        WindowSettingValues getModeSettings(GuiMode mode)
+        {
+            switch (mode)
+            {
+                case GM_Container:
+                    return makeInventoryContainerWindowSettingValues();
+                case GM_Companion:
+                    return makeInventoryCompanionWindowSettingValues();
+                case GM_Barter:
+                    return makeInventoryBarterWindowSettingValues();
+                default:
+                    return makeInventoryWindowSettingValues();
+            }
+        }
+    }
 
     InventoryWindow::InventoryWindow(
         DragAndDrop* dragAndDrop, osg::Group* parent, Resource::ResourceSystem* resourceSystem)
@@ -166,24 +184,18 @@ namespace MWGui
 
     void InventoryWindow::toggleMaximized()
     {
-        std::string setting = getModeSetting();
+        const WindowSettingValues settings = getModeSettings(mGuiMode);
-
+        const WindowRectSettingValues& rect = settings.mIsMaximized ? settings.mRegular : settings.mMaximized;
-        bool maximized = !Settings::Manager::getBool(setting + " maximized", "Windows");
-        if (maximized)
-            setting += " maximized";
 
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        float x = Settings::Manager::getFloat(setting + " x", "Windows") * float(viewSize.width);
+        const float x = rect.mX * viewSize.width;
-        float y = Settings::Manager::getFloat(setting + " y", "Windows") * float(viewSize.height);
+        const float y = rect.mY * viewSize.height;
-        float w = Settings::Manager::getFloat(setting + " w", "Windows") * float(viewSize.width);
+        const float w = rect.mW * viewSize.width;
-        float h = Settings::Manager::getFloat(setting + " h", "Windows") * float(viewSize.height);
+        const float h = rect.mH * viewSize.height;
         MyGUI::Window* window = mMainWidget->castType<MyGUI::Window>();
         window->setCoord(x, y, w, h);
 
-        if (maximized)
+        settings.mIsMaximized.set(!settings.mIsMaximized);
-            Settings::Manager::setBool(setting, "Windows", maximized);
-        else
-            Settings::Manager::setBool(setting + " maximized", "Windows", maximized);
 
         adjustPanes();
         updatePreviewSize();
@@ -192,17 +204,14 @@ namespace MWGui
     void InventoryWindow::setGuiMode(GuiMode mode)
     {
         mGuiMode = mode;
-        std::string setting = getModeSetting();
+        const WindowSettingValues settings = getModeSettings(mGuiMode);
         setPinButtonVisible(mode == GM_Inventory);
 
-        if (Settings::Manager::getBool(setting + " maximized", "Windows"))
+        const WindowRectSettingValues& rect = settings.mIsMaximized ? settings.mMaximized : settings.mRegular;
-            setting += " maximized";
 
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        MyGUI::IntPoint pos(static_cast<int>(Settings::Manager::getFloat(setting + " x", "Windows") * viewSize.width),
+        MyGUI::IntPoint pos(static_cast<int>(rect.mX * viewSize.width), static_cast<int>(rect.mY * viewSize.height));
-            static_cast<int>(Settings::Manager::getFloat(setting + " y", "Windows") * viewSize.height));
+        MyGUI::IntSize size(static_cast<int>(rect.mW * viewSize.width), static_cast<int>(rect.mH * viewSize.height));
-        MyGUI::IntSize size(static_cast<int>(Settings::Manager::getFloat(setting + " w", "Windows") * viewSize.width),
-            static_cast<int>(Settings::Manager::getFloat(setting + " h", "Windows") * viewSize.height));
 
         bool needUpdate = (size.width != mMainWidget->getWidth() || size.height != mMainWidget->getHeight());
 
@@ -405,44 +414,18 @@ namespace MWGui
         adjustPanes();
     }
 
-    std::string InventoryWindow::getModeSetting() const
-    {
-        std::string setting = "inventory";
-        switch (mGuiMode)
-        {
-            case GM_Container:
-                setting += " container";
-                break;
-            case GM_Companion:
-                setting += " companion";
-                break;
-            case GM_Barter:
-                setting += " barter";
-                break;
-            default:
-                break;
-        }
-
-        return setting;
-    }
-
     void InventoryWindow::onWindowResize(MyGUI::Window* _sender)
     {
         adjustPanes();
-        std::string setting = getModeSetting();
+        const WindowSettingValues settings = getModeSettings(mGuiMode);
 
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        float x = _sender->getPosition().left / float(viewSize.width);
+
-        float y = _sender->getPosition().top / float(viewSize.height);
+        settings.mRegular.mX.set(_sender->getPosition().left / static_cast<float>(viewSize.width));
-        float w = _sender->getSize().width / float(viewSize.width);
+        settings.mRegular.mY.set(_sender->getPosition().top / static_cast<float>(viewSize.height));
-        float h = _sender->getSize().height / float(viewSize.height);
+        settings.mRegular.mW.set(_sender->getSize().width / static_cast<float>(viewSize.width));
-        Settings::Manager::setFloat(setting + " x", "Windows", x);
+        settings.mRegular.mH.set(_sender->getSize().height / static_cast<float>(viewSize.height));
-        Settings::Manager::setFloat(setting + " y", "Windows", y);
+        settings.mIsMaximized.set(false);
-        Settings::Manager::setFloat(setting + " w", "Windows", w);
-        Settings::Manager::setFloat(setting + " h", "Windows", h);
-        bool maximized = Settings::Manager::getBool(setting + " maximized", "Windows");
-        if (maximized)
-            Settings::Manager::setBool(setting + " maximized", "Windows", false);
 
         if (mMainWidget->getSize().width != mLastXSize || mMainWidget->getSize().height != mLastYSize)
         {
@@ -503,7 +486,7 @@ namespace MWGui
 
     void InventoryWindow::onPinToggled()
     {
-        Settings::Manager::setBool("inventory pin", "Windows", mPinned);
+        Settings::windows().mInventoryPin.set(mPinned);
 
         MWBase::Environment::get().getWindowManager()->setWeaponVisibility(!mPinned);
     }

apps/openmw/mwgui/inventorywindow.hpp

@@ -113,8 +113,6 @@ namespace MWGui
 
         void onBackgroundSelected();
 
-        std::string getModeSetting() const;
-
         void sellItem(MyGUI::Widget* sender, int count);
         void dragItem(MyGUI::Widget* sender, int count);
 

apps/openmw/mwgui/mapwindow.cpp

@@ -16,7 +16,7 @@
 #include <components/esm3/esmwriter.hpp>
 #include <components/esm3/globalmap.hpp>
 #include <components/myguiplatform/myguitexture.hpp>
-#include <components/settings/settings.hpp>
+#include <components/settings/values.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/windowmanager.hpp"
@@ -1198,7 +1198,7 @@ namespace MWGui
 
     void MapWindow::onPinToggled()
     {
-        Settings::Manager::setBool("map pin", "Windows", mPinned);
+        Settings::windows().mMapPin.set(mPinned);
 
         MWBase::Environment::get().getWindowManager()->setMinimapVisibility(!mPinned);
     }

apps/openmw/mwgui/settings.cpp

@@ -0,0 +1,292 @@
+#include "settings.hpp"
+
+#include "components/settings/values.hpp"
+
+namespace MWGui
+{
+    WindowSettingValues makeAlchemyWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mAlchemyX,
+                .mY = Settings::windows().mAlchemyY,
+                .mW = Settings::windows().mAlchemyW,
+                .mH = Settings::windows().mAlchemyH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mAlchemyMaximizedX,
+                .mY = Settings::windows().mAlchemyMaximizedY,
+                .mW = Settings::windows().mAlchemyMaximizedW,
+                .mH = Settings::windows().mAlchemyMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mAlchemyMaximized,
+        };
+    }
+
+    WindowSettingValues makeBarterWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mBarterX,
+                .mY = Settings::windows().mBarterY,
+                .mW = Settings::windows().mBarterW,
+                .mH = Settings::windows().mBarterH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mBarterMaximizedX,
+                .mY = Settings::windows().mBarterMaximizedY,
+                .mW = Settings::windows().mBarterMaximizedW,
+                .mH = Settings::windows().mBarterMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mBarterMaximized,
+        };
+    }
+
+    WindowSettingValues makeCompanionWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mCompanionX,
+                .mY = Settings::windows().mCompanionY,
+                .mW = Settings::windows().mCompanionW,
+                .mH = Settings::windows().mCompanionH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mCompanionMaximizedX,
+                .mY = Settings::windows().mCompanionMaximizedY,
+                .mW = Settings::windows().mCompanionMaximizedW,
+                .mH = Settings::windows().mCompanionMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mCompanionMaximized,
+        };
+    }
+
+    WindowSettingValues makeConsoleWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mConsoleX,
+                .mY = Settings::windows().mConsoleY,
+                .mW = Settings::windows().mConsoleW,
+                .mH = Settings::windows().mConsoleH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mConsoleMaximizedX,
+                .mY = Settings::windows().mConsoleMaximizedY,
+                .mW = Settings::windows().mConsoleMaximizedW,
+                .mH = Settings::windows().mConsoleMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mConsoleMaximized,
+        };
+    }
+
+    WindowSettingValues makeContainerWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mContainerX,
+                .mY = Settings::windows().mContainerY,
+                .mW = Settings::windows().mContainerW,
+                .mH = Settings::windows().mContainerH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mContainerMaximizedX,
+                .mY = Settings::windows().mContainerMaximizedY,
+                .mW = Settings::windows().mContainerMaximizedW,
+                .mH = Settings::windows().mContainerMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mContainerMaximized,
+        };
+    }
+
+    WindowSettingValues makeDialogueWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mDialogueX,
+                .mY = Settings::windows().mDialogueY,
+                .mW = Settings::windows().mDialogueW,
+                .mH = Settings::windows().mDialogueH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mDialogueMaximizedX,
+                .mY = Settings::windows().mDialogueMaximizedY,
+                .mW = Settings::windows().mDialogueMaximizedW,
+                .mH = Settings::windows().mDialogueMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mDialogueMaximized,
+        };
+    }
+
+    WindowSettingValues makeInventoryWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryX,
+                .mY = Settings::windows().mInventoryY,
+                .mW = Settings::windows().mInventoryW,
+                .mH = Settings::windows().mInventoryH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryMaximizedX,
+                .mY = Settings::windows().mInventoryMaximizedY,
+                .mW = Settings::windows().mInventoryMaximizedW,
+                .mH = Settings::windows().mInventoryMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mInventoryMaximized,
+        };
+    }
+
+    WindowSettingValues makeInventoryBarterWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryBarterX,
+                .mY = Settings::windows().mInventoryBarterY,
+                .mW = Settings::windows().mInventoryBarterW,
+                .mH = Settings::windows().mInventoryBarterH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryBarterMaximizedX,
+                .mY = Settings::windows().mInventoryBarterMaximizedY,
+                .mW = Settings::windows().mInventoryBarterMaximizedW,
+                .mH = Settings::windows().mInventoryBarterMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mInventoryBarterMaximized,
+        };
+    }
+
+    WindowSettingValues makeInventoryCompanionWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryCompanionX,
+                .mY = Settings::windows().mInventoryCompanionY,
+                .mW = Settings::windows().mInventoryCompanionW,
+                .mH = Settings::windows().mInventoryCompanionH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryCompanionMaximizedX,
+                .mY = Settings::windows().mInventoryCompanionMaximizedY,
+                .mW = Settings::windows().mInventoryCompanionMaximizedW,
+                .mH = Settings::windows().mInventoryCompanionMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mInventoryCompanionMaximized,
+        };
+    }
+
+    WindowSettingValues makeInventoryContainerWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryContainerX,
+                .mY = Settings::windows().mInventoryContainerY,
+                .mW = Settings::windows().mInventoryContainerW,
+                .mH = Settings::windows().mInventoryContainerH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mInventoryContainerMaximizedX,
+                .mY = Settings::windows().mInventoryContainerMaximizedY,
+                .mW = Settings::windows().mInventoryContainerMaximizedW,
+                .mH = Settings::windows().mInventoryContainerMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mInventoryContainerMaximized,
+        };
+    }
+
+    WindowSettingValues makeMapWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mMapX,
+                .mY = Settings::windows().mMapY,
+                .mW = Settings::windows().mMapW,
+                .mH = Settings::windows().mMapH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mMapMaximizedX,
+                .mY = Settings::windows().mMapMaximizedY,
+                .mW = Settings::windows().mMapMaximizedW,
+                .mH = Settings::windows().mMapMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mMapMaximized,
+        };
+    }
+
+    WindowSettingValues makePostprocessorWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mPostprocessorX,
+                .mY = Settings::windows().mPostprocessorY,
+                .mW = Settings::windows().mPostprocessorW,
+                .mH = Settings::windows().mPostprocessorH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mPostprocessorMaximizedX,
+                .mY = Settings::windows().mPostprocessorMaximizedY,
+                .mW = Settings::windows().mPostprocessorMaximizedW,
+                .mH = Settings::windows().mPostprocessorMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mPostprocessorMaximized,
+        };
+    }
+
+    WindowSettingValues makeSettingsWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mSettingsX,
+                .mY = Settings::windows().mSettingsY,
+                .mW = Settings::windows().mSettingsW,
+                .mH = Settings::windows().mSettingsH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mSettingsMaximizedX,
+                .mY = Settings::windows().mSettingsMaximizedY,
+                .mW = Settings::windows().mSettingsMaximizedW,
+                .mH = Settings::windows().mSettingsMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mSettingsMaximized,
+        };
+    }
+
+    WindowSettingValues makeSpellsWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mSpellsX,
+                .mY = Settings::windows().mSpellsY,
+                .mW = Settings::windows().mSpellsW,
+                .mH = Settings::windows().mSpellsH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mSpellsMaximizedX,
+                .mY = Settings::windows().mSpellsMaximizedY,
+                .mW = Settings::windows().mSpellsMaximizedW,
+                .mH = Settings::windows().mSpellsMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mSpellsMaximized,
+        };
+    }
+
+    WindowSettingValues makeStatsWindowSettingValues()
+    {
+        return WindowSettingValues{
+            .mRegular = WindowRectSettingValues {
+                .mX = Settings::windows().mStatsX,
+                .mY = Settings::windows().mStatsY,
+                .mW = Settings::windows().mStatsW,
+                .mH = Settings::windows().mStatsH,
+            },
+            .mMaximized = WindowRectSettingValues {
+                .mX = Settings::windows().mStatsMaximizedX,
+                .mY = Settings::windows().mStatsMaximizedY,
+                .mW = Settings::windows().mStatsMaximizedW,
+                .mH = Settings::windows().mStatsMaximizedH,
+            },
+            .mIsMaximized = Settings::windows().mStatsMaximized,
+        };
+    }
+
+}

apps/openmw/mwgui/settings.hpp

@@ -0,0 +1,40 @@
+#ifndef OPENMW_APPS_OPENMW_MWGUI_SETTINGS_H
+#define OPENMW_APPS_OPENMW_MWGUI_SETTINGS_H
+
+#include "components/settings/settingvalue.hpp"
+
+namespace MWGui
+{
+    struct WindowRectSettingValues
+    {
+        Settings::SettingValue<float>& mX;
+        Settings::SettingValue<float>& mY;
+        Settings::SettingValue<float>& mW;
+        Settings::SettingValue<float>& mH;
+    };
+
+    struct WindowSettingValues
+    {
+        WindowRectSettingValues mRegular;
+        WindowRectSettingValues mMaximized;
+        Settings::SettingValue<bool>& mIsMaximized;
+    };
+
+    WindowSettingValues makeAlchemyWindowSettingValues();
+    WindowSettingValues makeBarterWindowSettingValues();
+    WindowSettingValues makeCompanionWindowSettingValues();
+    WindowSettingValues makeConsoleWindowSettingValues();
+    WindowSettingValues makeContainerWindowSettingValues();
+    WindowSettingValues makeDialogueWindowSettingValues();
+    WindowSettingValues makeInventoryWindowSettingValues();
+    WindowSettingValues makeInventoryBarterWindowSettingValues();
+    WindowSettingValues makeInventoryCompanionWindowSettingValues();
+    WindowSettingValues makeInventoryContainerWindowSettingValues();
+    WindowSettingValues makeMapWindowSettingValues();
+    WindowSettingValues makePostprocessorWindowSettingValues();
+    WindowSettingValues makeSettingsWindowSettingValues();
+    WindowSettingValues makeSpellsWindowSettingValues();
+    WindowSettingValues makeStatsWindowSettingValues();
+}
+
+#endif

apps/openmw/mwgui/spellwindow.cpp

@@ -6,7 +6,7 @@
 #include <components/esm3/loadbsgn.hpp>
 #include <components/esm3/loadrace.hpp>
 #include <components/misc/strings/format.hpp>
-#include <components/settings/settings.hpp>
+#include <components/settings/values.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/mechanicsmanager.hpp"
@@ -58,7 +58,7 @@ namespace MWGui
 
     void SpellWindow::onPinToggled()
     {
-        Settings::Manager::setBool("spells pin", "Windows", mPinned);
+        Settings::windows().mSpellsPin.set(mPinned);
 
         MWBase::Environment::get().getWindowManager()->setSpellVisibility(!mPinned);
     }

apps/openmw/mwgui/statswindow.cpp

@@ -15,7 +15,7 @@
 #include <components/esm3/loadgmst.hpp>
 #include <components/esm3/loadrace.hpp>
 
-#include <components/settings/settings.hpp>
+#include <components/settings/values.hpp>
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/windowmanager.hpp"
@@ -717,7 +717,7 @@ namespace MWGui
 
     void StatsWindow::onPinToggled()
     {
-        Settings::Manager::setBool("stats pin", "Windows", mPinned);
+        Settings::windows().mStatsPin.set(mPinned);
 
         MWBase::Environment::get().getWindowManager()->setHMSVisibility(!mPinned);
     }

apps/openmw/mwgui/windowmanagerimp.cpp

@@ -52,6 +52,8 @@
 
 #include <components/lua_ui/util.hpp>
 
+#include <components/settings/values.hpp>
+
 #include "../mwbase/inputmanager.hpp"
 #include "../mwbase/luamanager.hpp"
 #include "../mwbase/soundmanager.hpp"
@@ -120,6 +122,26 @@
 
 namespace MWGui
 {
+    namespace
+    {
+        Settings::SettingValue<bool>* findHiddenSetting(GuiWindow window)
+        {
+            switch (window)
+            {
+                case GW_Inventory:
+                    return &Settings::windows().mInventoryHidden;
+                case GW_Map:
+                    return &Settings::windows().mMapHidden;
+                case GW_Magic:
+                    return &Settings::windows().mSpellsHidden;
+                case GW_Stats:
+                    return &Settings::windows().mStatsHidden;
+                default:
+                    return nullptr;
+            }
+        }
+    }
+
     WindowManager::WindowManager(SDL_Window* window, osgViewer::Viewer* viewer, osg::Group* guiRoot,
         Resource::ResourceSystem* resourceSystem, SceneUtil::WorkQueue* workQueue, const std::filesystem::path& logpath,
         bool consoleOnlyScripts, Translation::Storage& translationDataStorage, ToUTF8::FromType encoding,
@@ -310,12 +332,12 @@ namespace MWGui
         mMap = map.get();
         mWindows.push_back(std::move(map));
         mMap->renderGlobalMap();
-        trackWindow(mMap, "map");
+        trackWindow(mMap, makeMapWindowSettingValues());
 
         auto statsWindow = std::make_unique<StatsWindow>(mDragAndDrop.get());
         mStatsWindow = statsWindow.get();
         mWindows.push_back(std::move(statsWindow));
-        trackWindow(mStatsWindow, "stats");
+        trackWindow(mStatsWindow, makeStatsWindowSettingValues());
 
         auto inventoryWindow = std::make_unique<InventoryWindow>(
             mDragAndDrop.get(), mViewer->getSceneData()->asGroup(), mResourceSystem);
@@ -325,7 +347,7 @@ namespace MWGui
         auto spellWindow = std::make_unique<SpellWindow>(mDragAndDrop.get());
         mSpellWindow = spellWindow.get();
         mWindows.push_back(std::move(spellWindow));
-        trackWindow(mSpellWindow, "spells");
+        trackWindow(mSpellWindow, makeSpellsWindowSettingValues());
 
         mGuiModeStates[GM_Inventory] = GuiModeState({ mMap, mInventoryWindow, mSpellWindow, mStatsWindow });
         mGuiModeStates[GM_None] = GuiModeState({ mMap, mInventoryWindow, mSpellWindow, mStatsWindow });
@@ -333,13 +355,13 @@ namespace MWGui
         auto tradeWindow = std::make_unique<TradeWindow>();
         mTradeWindow = tradeWindow.get();
         mWindows.push_back(std::move(tradeWindow));
-        trackWindow(mTradeWindow, "barter");
+        trackWindow(mTradeWindow, makeBarterWindowSettingValues());
         mGuiModeStates[GM_Barter] = GuiModeState({ mInventoryWindow, mTradeWindow });
 
         auto console = std::make_unique<Console>(w, h, mConsoleOnlyScripts, mCfgMgr);
         mConsole = console.get();
         mWindows.push_back(std::move(console));
-        trackWindow(mConsole, "console");
+        trackWindow(mConsole, makeConsoleWindowSettingValues());
 
         bool questList = mResourceSystem->getVFS()->exists("textures/tx_menubook_options_over.dds");
         auto journal = JournalWindow::create(JournalViewModel::create(), questList, mEncoding);
@@ -362,14 +384,14 @@ namespace MWGui
         auto dialogueWindow = std::make_unique<DialogueWindow>();
         mDialogueWindow = dialogueWindow.get();
         mWindows.push_back(std::move(dialogueWindow));
-        trackWindow(mDialogueWindow, "dialogue");
+        trackWindow(mDialogueWindow, makeDialogueWindowSettingValues());
         mGuiModeStates[GM_Dialogue] = GuiModeState(mDialogueWindow);
         mTradeWindow->eventTradeDone += MyGUI::newDelegate(mDialogueWindow, &DialogueWindow::onTradeComplete);
 
         auto containerWindow = std::make_unique<ContainerWindow>(mDragAndDrop.get());
         mContainerWindow = containerWindow.get();
         mWindows.push_back(std::move(containerWindow));
-        trackWindow(mContainerWindow, "container");
+        trackWindow(mContainerWindow, makeContainerWindowSettingValues());
         mGuiModeStates[GM_Container] = GuiModeState({ mContainerWindow, mInventoryWindow });
 
         auto hud = std::make_unique<HUD>(mCustomMarkers, mDragAndDrop.get(), mLocalMapRender.get());
@@ -399,7 +421,7 @@ namespace MWGui
         auto settingsWindow = std::make_unique<SettingsWindow>();
         mSettingsWindow = settingsWindow.get();
         mWindows.push_back(std::move(settingsWindow));
-        trackWindow(mSettingsWindow, "settings");
+        trackWindow(mSettingsWindow, makeSettingsWindowSettingValues());
         mGuiModeStates[GM_Settings] = GuiModeState(mSettingsWindow);
 
         auto confirmationDialog = std::make_unique<ConfirmationDialog>();
@@ -407,7 +429,7 @@ namespace MWGui
         mWindows.push_back(std::move(confirmationDialog));
 
         auto alchemyWindow = std::make_unique<AlchemyWindow>();
-        trackWindow(alchemyWindow.get(), "alchemy");
+        trackWindow(alchemyWindow.get(), makeAlchemyWindowSettingValues());
         mGuiModeStates[GM_Alchemy] = GuiModeState(alchemyWindow.get());
         mWindows.push_back(std::move(alchemyWindow));
 
@@ -448,7 +470,7 @@ namespace MWGui
         mSoulgemDialog = std::make_unique<SoulgemDialog>(mMessageBoxManager.get());
 
         auto companionWindow = std::make_unique<CompanionWindow>(mDragAndDrop.get(), mMessageBoxManager.get());
-        trackWindow(companionWindow.get(), "companion");
+        trackWindow(companionWindow.get(), makeCompanionWindowSettingValues());
         mGuiModeStates[GM_Companion] = GuiModeState({ mInventoryWindow, companionWindow.get() });
         mWindows.push_back(std::move(companionWindow));
 
@@ -492,7 +514,7 @@ namespace MWGui
         auto postProcessorHud = std::make_unique<PostProcessorHud>();
         mPostProcessorHud = postProcessorHud.get();
         mWindows.push_back(std::move(postProcessorHud));
-        trackWindow(mPostProcessorHud, "postprocessor");
+        trackWindow(mPostProcessorHud, makePostprocessorWindowSettingValues());
 
         mInputBlocker = MyGUI::Gui::getInstance().createWidget<MyGUI::Widget>(
             "", 0, 0, w, h, MyGUI::Align::Stretch, "InputBlocker");
@@ -1192,19 +1214,11 @@ namespace MWGui
         if (!mHud)
             return; // UI not initialized yet
 
-        for (std::map<MyGUI::Window*, std::string>::iterator it = mTrackedWindows.begin(); it != mTrackedWindows.end();
+        for (const auto& [window, settings] : mTrackedWindows)
-             ++it)
         {
-            std::string settingName = it->second;
+            const WindowRectSettingValues& rect = settings.mIsMaximized ? settings.mMaximized : settings.mRegular;
-            if (Settings::Manager::getBool(settingName + " maximized", "Windows"))
+            window->setPosition(MyGUI::IntPoint(static_cast<int>(rect.mX * x), static_cast<int>(rect.mY * y)));
-                settingName += " maximized";
+            window->setSize(MyGUI::IntSize(static_cast<int>(rect.mW * x), static_cast<int>(rect.mH * y)));
-
-            MyGUI::IntPoint pos(static_cast<int>(Settings::Manager::getFloat(settingName + " x", "Windows") * x),
-                static_cast<int>(Settings::Manager::getFloat(settingName + " y", "Windows") * y));
-            MyGUI::IntSize size(static_cast<int>(Settings::Manager::getFloat(settingName + " w", "Windows") * x),
-                static_cast<int>(Settings::Manager::getFloat(settingName + " h", "Windows") * y));
-            it->first->setPosition(pos);
-            it->first->setSize(size);
         }
 
         for (const auto& window : mWindows)
@@ -1511,31 +1525,8 @@ namespace MWGui
         if (getMode() != GM_Inventory)
             return;
 
-        std::string settingName;
+        if (Settings::SettingValue<bool>* const hidden = findHiddenSetting(wnd))
-        switch (wnd)
+            hidden->set(!hidden->get());
-        {
-            case GW_Inventory:
-                settingName = "inventory";
-                break;
-            case GW_Map:
-                settingName = "map";
-                break;
-            case GW_Magic:
-                settingName = "spells";
-                break;
-            case GW_Stats:
-                settingName = "stats";
-                break;
-            default:
-                break;
-        }
-
-        if (!settingName.empty())
-        {
-            settingName += " hidden";
-            bool hidden = Settings::Manager::getBool(settingName, "Windows");
-            Settings::Manager::setBool(settingName, "Windows", !hidden);
-        }
 
         mShown = (GuiWindow)(mShown ^ wnd);
         updateVisible();
@@ -1721,63 +1712,57 @@ namespace MWGui
         return mCursorVisible && mCursorActive;
     }
 
-    void WindowManager::trackWindow(Layout* layout, const std::string& name)
+    void WindowManager::trackWindow(Layout* layout, const WindowSettingValues& settings)
     {
-        std::string settingName = name;
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        bool isMaximized = Settings::Manager::getBool(name + " maximized", "Windows");
-        if (isMaximized)
-            settingName += " maximized";
 
-        MyGUI::IntPoint pos(
+        const WindowRectSettingValues& rect = settings.mIsMaximized ? settings.mMaximized : settings.mRegular;
-            static_cast<int>(Settings::Manager::getFloat(settingName + " x", "Windows") * viewSize.width),
+
-            static_cast<int>(Settings::Manager::getFloat(settingName + " y", "Windows") * viewSize.height));
+        layout->mMainWidget->setPosition(
-        MyGUI::IntSize size(
+            MyGUI::IntPoint(static_cast<int>(rect.mX * viewSize.width), static_cast<int>(rect.mY * viewSize.height)));
-            static_cast<int>(Settings::Manager::getFloat(settingName + " w", "Windows") * viewSize.width),
+        layout->mMainWidget->setSize(
-            static_cast<int>(Settings::Manager::getFloat(settingName + " h", "Windows") * viewSize.height));
+            MyGUI::IntSize(static_cast<int>(rect.mW * viewSize.width), static_cast<int>(rect.mH * viewSize.height)));
-        layout->mMainWidget->setPosition(pos);
-        layout->mMainWidget->setSize(size);
 
         MyGUI::Window* window = layout->mMainWidget->castType<MyGUI::Window>();
         window->eventWindowChangeCoord += MyGUI::newDelegate(this, &WindowManager::onWindowChangeCoord);
-        mTrackedWindows[window] = name;
+        mTrackedWindows.emplace(window, settings);
     }
 
     void WindowManager::toggleMaximized(Layout* layout)
     {
         MyGUI::Window* window = layout->mMainWidget->castType<MyGUI::Window>();
-        std::string setting = mTrackedWindows[window];
+        const auto it = mTrackedWindows.find(window);
-        if (setting.empty())
+        if (it == mTrackedWindows.end())
             return;
 
-        bool maximized = !Settings::Manager::getBool(setting + " maximized", "Windows");
+        const WindowSettingValues& settings = it->second;
-        if (maximized)
+        const WindowRectSettingValues& rect = settings.mIsMaximized ? settings.mRegular : settings.mMaximized;
-            setting += " maximized";
 
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        float x = Settings::Manager::getFloat(setting + " x", "Windows") * float(viewSize.width);
+        const float x = rect.mX * viewSize.width;
-        float y = Settings::Manager::getFloat(setting + " y", "Windows") * float(viewSize.height);
+        const float y = rect.mY * viewSize.height;
-        float w = Settings::Manager::getFloat(setting + " w", "Windows") * float(viewSize.width);
+        const float w = rect.mW * viewSize.width;
-        float h = Settings::Manager::getFloat(setting + " h", "Windows") * float(viewSize.height);
+        const float h = rect.mH * viewSize.height;
         window->setCoord(x, y, w, h);
-        Settings::Manager::setBool(mTrackedWindows[window] + " maximized", "Windows", maximized);
+
+        settings.mIsMaximized.set(!settings.mIsMaximized.get());
     }
 
-    void WindowManager::onWindowChangeCoord(MyGUI::Window* _sender)
+    void WindowManager::onWindowChangeCoord(MyGUI::Window* window)
     {
-        std::string setting = mTrackedWindows[_sender];
+        const auto it = mTrackedWindows.find(window);
+        if (it == mTrackedWindows.end())
+            return;
+
+        const WindowSettingValues& settings = it->second;
+
         MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
-        float x = _sender->getPosition().left / float(viewSize.width);
+        settings.mRegular.mX.set(window->getPosition().left / static_cast<float>(viewSize.width));
-        float y = _sender->getPosition().top / float(viewSize.height);
+        settings.mRegular.mY.set(window->getPosition().top / static_cast<float>(viewSize.height));
-        float w = _sender->getSize().width / float(viewSize.width);
+        settings.mRegular.mW.set(window->getSize().width / static_cast<float>(viewSize.width));
-        float h = _sender->getSize().height / float(viewSize.height);
+        settings.mRegular.mH.set(window->getSize().height / static_cast<float>(viewSize.height));
-        Settings::Manager::setFloat(setting + " x", "Windows", x);
+
-        Settings::Manager::setFloat(setting + " y", "Windows", y);
+        settings.mIsMaximized.set(false);
-        Settings::Manager::setFloat(setting + " w", "Windows", w);
-        Settings::Manager::setFloat(setting + " h", "Windows", h);
-        bool maximized = Settings::Manager::getBool(setting + " maximized", "Windows");
-        if (maximized)
-            Settings::Manager::setBool(setting + " maximized", "Windows", false);
     }
 
     void WindowManager::clear()
@@ -2004,20 +1989,20 @@ namespace MWGui
 
     void WindowManager::updatePinnedWindows()
     {
-        mInventoryWindow->setPinned(Settings::Manager::getBool("inventory pin", "Windows"));
+        mInventoryWindow->setPinned(Settings::windows().mInventoryPin);
-        if (Settings::Manager::getBool("inventory hidden", "Windows"))
+        if (Settings::windows().mInventoryHidden)
             mShown = (GuiWindow)(mShown ^ GW_Inventory);
 
-        mMap->setPinned(Settings::Manager::getBool("map pin", "Windows"));
+        mMap->setPinned(Settings::windows().mMapPin);
-        if (Settings::Manager::getBool("map hidden", "Windows"))
+        if (Settings::windows().mMapHidden)
             mShown = (GuiWindow)(mShown ^ GW_Map);
 
-        mSpellWindow->setPinned(Settings::Manager::getBool("spells pin", "Windows"));
+        mSpellWindow->setPinned(Settings::windows().mSpellsPin);
-        if (Settings::Manager::getBool("spells hidden", "Windows"))
+        if (Settings::windows().mSpellsHidden)
             mShown = (GuiWindow)(mShown ^ GW_Magic);
 
-        mStatsWindow->setPinned(Settings::Manager::getBool("stats pin", "Windows"));
+        mStatsWindow->setPinned(Settings::windows().mStatsPin);
-        if (Settings::Manager::getBool("stats hidden", "Windows"))
+        if (Settings::windows().mStatsHidden)
             mShown = (GuiWindow)(mShown ^ GW_Stats);
     }
 

apps/openmw/mwgui/windowmanagerimp.hpp

@@ -28,6 +28,7 @@
 #include "draganddrop.hpp"
 #include "mapwindow.hpp"
 #include "messagebox.hpp"
+#include "settings.hpp"
 #include "soulgemdialog.hpp"
 #include "statswatcher.hpp"
 #include "textcolours.hpp"
@@ -404,8 +405,8 @@ namespace MWGui
 
         bool mConsoleOnlyScripts;
 
-        std::map<MyGUI::Window*, std::string> mTrackedWindows;
+        std::map<MyGUI::Window*, WindowSettingValues> mTrackedWindows;
-        void trackWindow(Layout* layout, const std::string& name);
+        void trackWindow(Layout* layout, const WindowSettingValues& settings);
         void onWindowChangeCoord(MyGUI::Window* _sender);
 
         ESM::RefId mSelectedSpell;