OpenMW/apps/openmw/mwgui/windowmanagerimp.hpp

#ifndef MWGUI_WINDOWMANAGERIMP_H
#define MWGUI_WINDOWMANAGERIMP_H

/**
   This class owns and controls all the MW specific windows in the
   GUI. It can enable/disable Gui mode, and is responsible for sending
   and retrieving information from the Gui.
**/

#include <memory>
#include <stack>
#include <vector>

#include <osg/ref_ptr>

#include "../mwbase/windowmanager.hpp"
#include "../mwrender/localmap.hpp"

#include <components/misc/guarded.hpp>
#include <components/myguiplatform/myguiplatform.hpp>
#include <components/sdlutil/events.hpp>
#include <components/sdlutil/sdlcursormanager.hpp>
#include <components/sdlutil/sdlvideowrapper.hpp>
#include <components/settings/settings.hpp>
#include <components/to_utf8/to_utf8.hpp>

#include "charactercreation.hpp"
#include "draganddrop.hpp"
#include "mapwindow.hpp"
#include "messagebox.hpp"
#include "settings.hpp"
#include "soulgemdialog.hpp"
#include "statswatcher.hpp"
#include "textcolours.hpp"
#include "tooltips.hpp"
#include "windowbase.hpp"

#include <MyGUI_Gui.h>
#include <MyGUI_KeyCode.h>
#include <MyGUI_Types.h>
#include <filesystem>

namespace MyGUI
{
    class Widget;
    class Window;
    class UString;
    class ImageBox;
}

namespace MWWorld
{
    class ESMStore;
}

namespace Compiler
{
    class Extensions;
}

namespace Translation
{
    class Storage;
}

namespace osg
{
    class Group;
}
namespace osgViewer
{
    class Viewer;
}

namespace Resource
{
    class ResourceSystem;
}

namespace SceneUtil
{
    class WorkQueue;
}

namespace Gui
{
    class FontLoader;
}

namespace MWGui
{
    class HUD;
    class MapWindow;
    class MainMenu;
    class StatsWindow;
    class InventoryWindow;
    struct JournalWindow;
    class TextInputDialog;
    class InfoBoxDialog;
    class SettingsWindow;
    class AlchemyWindow;
    class QuickKeysMenu;
    class LoadingScreen;
    class LevelupDialog;
    class WaitDialog;
    class SpellCreationDialog;
    class EnchantingDialog;
    class TrainingWindow;
    class SpellIcons;
    class MerchantRepair;
    class Recharge;
    class CompanionWindow;
    class VideoWidget;
    class WindowModal;
    class ScreenFader;
    class DebugWindow;
    class PostProcessorHud;
    class JailScreen;
    class KeyboardNavigation;

    class WindowManager : public MWBase::WindowManager
    {
    public:
        typedef std::pair<std::string, int> Faction;
        typedef std::vector<Faction> FactionList;

        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, const std::string& versionDescription, bool useShaders,
            Files::ConfigurationManager& cfgMgr);
        virtual ~WindowManager();

        /// Set the ESMStore to use for retrieving of GUI-related strings.
        void setStore(const MWWorld::ESMStore& store);

        void initUI();

        Loading::Listener* getLoadingScreen() override;

        /// @note This method will block until the video finishes playing
        /// (and will continually update the window while doing so)
        void playVideo(std::string_view name, bool allowSkipping, bool overrideSounds = true) override;

        /// Warning: do not use MyGUI::InputManager::setKeyFocusWidget directly. Instead use this.
        void setKeyFocusWidget(MyGUI::Widget* widget) override;

        void setNewGame(bool newgame) override;

        void pushGuiMode(GuiMode mode, const MWWorld::Ptr& arg) override;
        void pushGuiMode(GuiMode mode) override;
        void popGuiMode(bool noSound = false) override;
        void removeGuiMode(GuiMode mode, bool noSound = false) override; ///< can be anywhere in the stack

        void goToJail(int days) override;

        GuiMode getMode() const override;
        bool containsMode(GuiMode mode) const override;

        bool isGuiMode() const override;

        bool isConsoleMode() const override;

        bool isPostProcessorHudVisible() const override;

        void toggleVisible(GuiWindow wnd) override;

        void forceHide(MWGui::GuiWindow wnd) override;
        void unsetForceHide(MWGui::GuiWindow wnd) override;

        /// Disallow all inventory mode windows
        void disallowAll() override;

        /// Allow one or more windows
        void allow(GuiWindow wnd) override;

        bool isAllowed(GuiWindow wnd) const override;

        /// \todo investigate, if we really need to expose every single lousy UI element to the outside world
        MWGui::InventoryWindow* getInventoryWindow() override;
        MWGui::CountDialog* getCountDialog() override;
        MWGui::ConfirmationDialog* getConfirmationDialog() override;
        MWGui::TradeWindow* getTradeWindow() override;
        MWGui::PostProcessorHud* getPostProcessorHud() override;

        /// Make the player use an item, while updating GUI state accordingly
        void useItem(const MWWorld::Ptr& item, bool bypassBeastRestrictions = false) override;

        void updateSpellWindow() override;

        void setConsoleSelectedObject(const MWWorld::Ptr& object) override;
        MWWorld::Ptr getConsoleSelectedObject() const override;
        void printToConsole(const std::string& msg, std::string_view color) override;
        void setConsoleMode(const std::string& mode) override;

        /// Set time left for the player to start drowning (update the drowning bar)
        /// @param time time left to start drowning
        /// @param maxTime how long we can be underwater (in total) until drowning starts
        void setDrowningTimeLeft(float time, float maxTime) override;

        void changeCell(const MWWorld::CellStore* cell) override; ///< change the active cell

        void setFocusObject(const MWWorld::Ptr& focus) override;
        void setFocusObjectScreenCoords(float min_x, float min_y, float max_x, float max_y) override;

        void getMousePosition(int& x, int& y) override;
        void getMousePosition(float& x, float& y) override;
        void setDragDrop(bool dragDrop) override;
        bool getWorldMouseOver() override;

        float getScalingFactor() const override;

        bool toggleFogOfWar() override;
        bool toggleFullHelp() override; ///< show extra info in item tooltips (owner, script)
        bool getFullHelp() const override;

        void setActiveMap(int x, int y, bool interior) override;
        ///< set the indices of the map texture that should be used

        /// sets the visibility of the drowning bar
        void setDrowningBarVisibility(bool visible) override;

        // sets the visibility of the hud health/magicka/stamina bars
        void setHMSVisibility(bool visible) override;
        // sets the visibility of the hud minimap
        void setMinimapVisibility(bool visible) override;
        void setWeaponVisibility(bool visible) override;
        void setSpellVisibility(bool visible) override;
        void setSneakVisibility(bool visible) override;

        /// activate selected quick key
        void activateQuickKey(int index) override;
        /// update activated quick key state (if action executing was delayed for some reason)
        void updateActivatedQuickKey() override;

        const ESM::RefId& getSelectedSpell() override { return mSelectedSpell; }
        void setSelectedSpell(const ESM::RefId& spellId, int successChancePercent) override;
        void setSelectedEnchantItem(const MWWorld::Ptr& item) override;
        const MWWorld::Ptr& getSelectedEnchantItem() const override;
        void setSelectedWeapon(const MWWorld::Ptr& item) override;
        const MWWorld::Ptr& getSelectedWeapon() const override;
        int getFontHeight() const override;
        void unsetSelectedSpell() override;
        void unsetSelectedWeapon() override;

        void updateConsoleObjectPtr(const MWWorld::Ptr& currentPtr, const MWWorld::Ptr& newPtr) override;

        void showCrosshair(bool show) override;
        bool getSubtitlesEnabled() override;

        /// Turn visibility of HUD on or off
        bool toggleHud() override;

        void disallowMouse() override;
        void allowMouse() override;
        void notifyInputActionBound() override;

        void addVisitedLocation(const std::string& name, int x, int y) override;

        /// Hides dialog and schedules dialog to be deleted.
        void removeDialog(std::unique_ptr<Layout>&& dialog) override;

        /// Gracefully attempts to exit the topmost GUI mode
        void exitCurrentGuiMode() override;

        void messageBox(std::string_view message,
            enum MWGui::ShowInDialogueMode showInDialogueMode = MWGui::ShowInDialogueMode_IfPossible) override;
        void scheduleMessageBox(std::string message,
            enum MWGui::ShowInDialogueMode showInDialogueMode = MWGui::ShowInDialogueMode_IfPossible) override;
        void staticMessageBox(std::string_view message) override;
        void removeStaticMessageBox() override;
        void interactiveMessageBox(
            std::string_view message, const std::vector<std::string>& buttons = {}, bool block = false) override;

        int readPressedButton() override; ///< returns the index of the pressed button or -1 if no button was pressed
                                          ///< (->MessageBoxmanager->InteractiveMessageBox)

        void update(float duration);

        /**
         * Fetches a GMST string from the store, if there is no setting with the given
         * ID or it is not a string the default string is returned.
         *
         * @param id Identifier for the GMST setting, e.g. "aName"
         * @param default Default value if the GMST setting cannot be used.
         */
        std::string_view getGameSettingString(std::string_view id, std::string_view default_) override;

        void processChangedSettings(const Settings::CategorySettingVector& changed) override;

        void windowVisibilityChange(bool visible) override;
        void windowResized(int x, int y) override;
        void windowClosed() override;
        bool isWindowVisible() override;

        void watchActor(const MWWorld::Ptr& ptr) override;
        MWWorld::Ptr getWatchedActor() const override;

        void executeInConsole(const std::string& path) override;

        void enableRest() override { mRestAllowed = true; }
        bool getRestEnabled() override;

        bool getJournalAllowed() override { return (mAllowed & GW_Magic) != 0; }

        bool getPlayerSleeping() override;
        void wakeUpPlayer() override;

        void updatePlayer() override;

        void showSoulgemDialog(MWWorld::Ptr item) override;

        void changePointer(const std::string& name) override;

        void setEnemy(const MWWorld::Ptr& enemy) override;

        int getMessagesCount() const override;

        const Translation::Storage& getTranslationDataStorage() const override;

        void onSoulgemDialogButtonPressed(int button);

        bool getCursorVisible() override;

        /// Call when mouse cursor or buttons are used.
        void setCursorActive(bool active) override;

        /// Clear all savegame-specific data
        void clear() override;

        void write(ESM::ESMWriter& writer, Loading::Listener& progress) override;
        void readRecord(ESM::ESMReader& reader, uint32_t type) override;
        int countSavedGameRecords() const override;

        /// Does the current stack of GUI-windows permit saving?
        bool isSavingAllowed() const override;

        /// Send exit command to active Modal window **/
        void exitCurrentModal() override;

        /// Sets the current Modal
        /** Used to send exit command to active Modal when Esc is pressed **/
        void addCurrentModal(WindowModal* input) override;

        /// Removes the top Modal
        /** Used when one Modal adds another Modal
            \param input Pointer to the current modal, to ensure proper modal is removed **/
        void removeCurrentModal(WindowModal* input) override;

        void pinWindow(MWGui::GuiWindow window) override;
        void toggleMaximized(Layout* layout) override;

        /// Fade the screen in, over \a time seconds
        void fadeScreenIn(const float time, bool clearQueue, float delay) override;
        /// Fade the screen out to black, over \a time seconds
        void fadeScreenOut(const float time, bool clearQueue, float delay) override;
        /// Fade the screen to a specified percentage of black, over \a time seconds
        void fadeScreenTo(const int percent, const float time, bool clearQueue, float delay) override;
        /// Darken the screen to a specified percentage
        void setBlindness(const int percent) override;

        void activateHitOverlay(bool interrupt) override;
        void setWerewolfOverlay(bool set) override;

        void toggleConsole() override;
        void toggleDebugWindow() override;
        void togglePostProcessorHud() override;

        /// Cycle to next or previous spell
        void cycleSpell(bool next) override;
        /// Cycle to next or previous weapon
        void cycleWeapon(bool next) override;

        void playSound(const ESM::RefId& soundId, float volume = 1.f, float pitch = 1.f) override;

        void addCell(MWWorld::CellStore* cell) override;
        void removeCell(MWWorld::CellStore* cell) override;
        void writeFog(MWWorld::CellStore* cell) override;

        const MWGui::TextColours& getTextColours() override;

        bool injectKeyPress(MyGUI::KeyCode key, unsigned int text, bool repeat = false) override;
        bool injectKeyRelease(MyGUI::KeyCode key) override;

        const std::string& getVersionDescription() const override;

        void onDeleteCustomData(const MWWorld::Ptr& ptr) override;
        void forceLootMode(const MWWorld::Ptr& ptr) override;

        void asyncPrepareSaveMap() override;

    private:
        unsigned int mOldUpdateMask;
        unsigned int mOldCullMask;

        const MWWorld::ESMStore* mStore;
        Resource::ResourceSystem* mResourceSystem;
        osg::ref_ptr<SceneUtil::WorkQueue> mWorkQueue;

        std::unique_ptr<osgMyGUI::Platform> mGuiPlatform;
        osgViewer::Viewer* mViewer;

        std::unique_ptr<Gui::FontLoader> mFontLoader;
        std::unique_ptr<StatsWatcher> mStatsWatcher;

        bool mConsoleOnlyScripts;

        std::map<MyGUI::Window*, WindowSettingValues> mTrackedWindows;
        void trackWindow(Layout* layout, const WindowSettingValues& settings);
        void onWindowChangeCoord(MyGUI::Window* _sender);

        ESM::RefId mSelectedSpell;
        MWWorld::Ptr mSelectedEnchantItem;
        MWWorld::Ptr mSelectedWeapon;

        std::vector<WindowModal*> mCurrentModals;

        // Markers placed manually by the player. Must be shared between both map views (the HUD map and the map
        // window).
        CustomMarkerCollection mCustomMarkers;

        HUD* mHud;
        MapWindow* mMap;
        std::unique_ptr<MWRender::LocalMap> mLocalMapRender;
        std::unique_ptr<ToolTips> mToolTips;
        StatsWindow* mStatsWindow;
        std::unique_ptr<MessageBoxManager> mMessageBoxManager;
        Console* mConsole;
        DialogueWindow* mDialogueWindow;
        std::unique_ptr<DragAndDrop> mDragAndDrop;
        InventoryWindow* mInventoryWindow;
        ScrollWindow* mScrollWindow;
        BookWindow* mBookWindow;
        CountDialog* mCountDialog;
        TradeWindow* mTradeWindow;
        SettingsWindow* mSettingsWindow;
        ConfirmationDialog* mConfirmationDialog;
        SpellWindow* mSpellWindow;
        QuickKeysMenu* mQuickKeysMenu;
        LoadingScreen* mLoadingScreen;
        WaitDialog* mWaitDialog;
        std::unique_ptr<SoulgemDialog> mSoulgemDialog;
        MyGUI::ImageBox* mVideoBackground;
        VideoWidget* mVideoWidget;
        ScreenFader* mWerewolfFader;
        ScreenFader* mBlindnessFader;
        ScreenFader* mHitFader;
        ScreenFader* mScreenFader;
        DebugWindow* mDebugWindow;
        PostProcessorHud* mPostProcessorHud;
        JailScreen* mJailScreen;
        ContainerWindow* mContainerWindow;

        std::vector<std::unique_ptr<WindowBase>> mWindows;

        Translation::Storage& mTranslationDataStorage;

        std::unique_ptr<CharacterCreation> mCharGen;

        MyGUI::Widget* mInputBlocker;

        bool mCrosshairEnabled;
        bool mSubtitlesEnabled;
        bool mHitFaderEnabled;
        bool mWerewolfOverlayEnabled;
        bool mHudEnabled;
        bool mCursorVisible;
        bool mCursorActive;

        int mPlayerBounty;

        void setCursorVisible(bool visible) override;

        std::unique_ptr<MyGUI::Gui> mGui; // Gui

        struct GuiModeState
        {
            GuiModeState(WindowBase* window) { mWindows.push_back(window); }
            GuiModeState(const std::vector<WindowBase*>& windows)
                : mWindows(windows)
            {
            }
            GuiModeState() {}

            void update(bool visible);

            std::vector<WindowBase*> mWindows;

            ESM::RefId mCloseSound;
            ESM::RefId mOpenSound;
        };
        // Defines the windows that should be shown in a particular GUI mode.
        std::map<GuiMode, GuiModeState> mGuiModeStates;
        // The currently active stack of GUI modes (top mode is the one we are in).
        std::vector<GuiMode> mGuiModes;

        std::unique_ptr<SDLUtil::SDLCursorManager> mCursorManager;

        std::vector<std::unique_ptr<Layout>> mGarbageDialogs;
        void cleanupGarbage();

        GuiWindow mShown; // Currently shown windows in inventory mode
        GuiWindow mForceHidden; // Hidden windows (overrides mShown)

        /* Currently ALLOWED windows in inventory mode. This is used at
           the start of the game, when windows are enabled one by one
           through script commands. You can manipulate this through using
           allow() and disableAll().
         */
        GuiWindow mAllowed;
        // is the rest window allowed?
        bool mRestAllowed;

        void updateVisible(); // Update visibility of all windows based on mode, shown and allowed settings

        void updateMap();

        int mShowOwned;

        ToUTF8::FromType mEncoding;

        std::string mVersionDescription;

        bool mWindowVisible;

        MWGui::TextColours mTextColours;

        std::unique_ptr<KeyboardNavigation> mKeyboardNavigation;

        std::unique_ptr<SDLUtil::VideoWrapper> mVideoWrapper;

        float mScalingFactor;

        struct ScheduledMessageBox
        {
            std::string mMessage;
            MWGui::ShowInDialogueMode mShowInDialogueMode;

            ScheduledMessageBox(std::string&& message, MWGui::ShowInDialogueMode showInDialogueMode)
                : mMessage(std::move(message))
                , mShowInDialogueMode(showInDialogueMode)
            {
            }
        };

        Misc::ScopeGuarded<std::vector<ScheduledMessageBox>> mScheduledMessageBoxes;

        /**
         * Called when MyGUI tries to retrieve a tag's value. Tags must be denoted in #{tag} notation and will be
         * replaced upon setting a user visible text/property. Supported syntax:
         * #{GMSTName}: retrieves String value of the GMST called GMSTName
         * #{setting=CATEGORY_NAME,SETTING_NAME}: retrieves String value of SETTING_NAME under category CATEGORY_NAME
         * from settings.cfg
         * #{sCell=CellID}: retrieves translated name of the given CellID (used only by some Morrowind localisations, in
         * others cell ID is == cell name)
         * #{fontcolour=FontColourName}: retrieves the value of the fallback setting "FontColor_color_<FontColourName>"
         * from openmw.cfg, in the format "r g b a", float values in range 0-1. Useful for "Colour" and "TextColour"
         * properties in skins.
         * #{fontcolourhtml=FontColourName}: retrieves the value of the fallback setting
         * "FontColor_color_<FontColourName>" from openmw.cfg, in the format "#xxxxxx" where x are hexadecimal numbers.
         * Useful in an EditBox's caption to change the color of following text.
         */
        void onRetrieveTag(const MyGUI::UString& _tag, MyGUI::UString& _result);

        void onCursorChange(const std::string& name);
        void onKeyFocusChanged(MyGUI::Widget* widget);

        // Key pressed while playing a video
        void onVideoKeyPressed(MyGUI::Widget* _sender, MyGUI::KeyCode _key, MyGUI::Char _char);

        void sizeVideo(int screenWidth, int screenHeight);

        void onClipboardChanged(const std::string& _type, const std::string& _data);
        void onClipboardRequested(const std::string& _type, std::string& _data);

        void createTextures();
        void createCursors();
        void setMenuTransparency(float value);

        void updatePinnedWindows();

        void enableScene(bool enable);

        void handleScheduledMessageBoxes();

        void pushGuiMode(GuiMode mode, const MWWorld::Ptr& arg, bool force);

        void setCullMask(uint32_t mask) override;
        uint32_t getCullMask() override;

        Files::ConfigurationManager& mCfgMgr;
    };
}

#endif