windowmanagerimp.hpp

Go to the documentation of this file.

#ifndef MWGUI_WINDOWMANAGERIMP_H
#define MWGUI_WINDOWMANAGERIMP_H

#include <stack>

#include <osg/ref_ptr>

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

#include "../mwworld/ptr.hpp"

#include <components/settings/settings.hpp>
#include <components/to_utf8/to_utf8.hpp>

#include "mapwindow.hpp"
#include "textcolours.hpp"

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

namespace MyGUI
{
    class Gui;
    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 SDLUtil
{
    class SDLCursorManager;
}

namespace osgMyGUI
{
    class Platform;
}

namespace Gui
{
    class FontLoader;
}

namespace MWRender
{
    class LocalMap;
}

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

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

    WindowManager(osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ResourceSystem* resourceSystem, SceneUtil::WorkQueue* workQueue,
                  const std::string& logpath, const std::string& cacheDir, bool consoleOnlyScripts, Translation::Storage& translationDataStorage,
                  ToUTF8::FromType encoding, bool exportFonts, const std::map<std::string,std::string>& fallbackMap, const std::string& versionDescription, const std::string& localPath);
    virtual ~WindowManager();

    void setStore (const MWWorld::ESMStore& store);

    void initUI();
    virtual void loadUserFonts();

    virtual Loading::Listener* getLoadingScreen();

    virtual void playVideo(const std::string& name, bool allowSkipping);

    virtual void setKeyFocusWidget (MyGUI::Widget* widget);

    virtual void setNewGame(bool newgame);

    virtual void pushGuiMode(GuiMode mode, const MWWorld::Ptr& arg);
    virtual void pushGuiMode (GuiMode mode);
    virtual void popGuiMode(bool noSound=false);
    virtual void removeGuiMode(GuiMode mode, bool noSound=false); 

    virtual void goToJail(int days);

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

    virtual bool isGuiMode() const;

    virtual bool isConsoleMode() const;

    virtual void toggleVisible(GuiWindow wnd);

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

    virtual void disallowAll();

    virtual void allow(GuiWindow wnd);

    virtual bool isAllowed(GuiWindow wnd) const;

    virtual MWGui::InventoryWindow* getInventoryWindow();
    virtual MWGui::CountDialog* getCountDialog();
    virtual MWGui::ConfirmationDialog* getConfirmationDialog();
    virtual MWGui::TradeWindow* getTradeWindow();

    virtual void useItem(const MWWorld::Ptr& item, bool bypassBeastRestrictions=false);

    virtual void updateSpellWindow();

    virtual void setConsoleSelectedObject(const MWWorld::Ptr& object);

    virtual void setValue (const std::string& id, const MWMechanics::AttributeValue& value);
    virtual void setValue (int parSkill, const MWMechanics::SkillValue& value);
    virtual void setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value);
    virtual void setValue (const std::string& id, const std::string& value);
    virtual void setValue (const std::string& id, int value);

    virtual void setDrowningTimeLeft (float time, float maxTime);

    virtual void setPlayerClass (const ESM::Class &class_);                        
    virtual void configureSkills (const SkillList& major, const SkillList& minor); 
    virtual void updateSkillArea();                                                

    virtual void changeCell(const MWWorld::CellStore* cell); 

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

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

    virtual bool toggleFogOfWar();
    virtual bool toggleFullHelp(); 
    virtual bool getFullHelp() const;

    virtual void setActiveMap(int x, int y, bool interior);

    virtual void setDrowningBarVisibility(bool visible);

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

    virtual void activateQuickKey (int index);
    virtual void updateActivatedQuickKey ();

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

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

    virtual bool toggleHud();

    virtual void disallowMouse();
    virtual void allowMouse();
    virtual void notifyInputActionBound();

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

    virtual void removeDialog(Layout* dialog);

    virtual void exitCurrentGuiMode();

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

    virtual int readPressedButton (); 

    virtual void onFrame (float frameDuration);

    virtual std::map<int, MWMechanics::SkillValue > getPlayerSkillValues();
    virtual std::map<int, MWMechanics::AttributeValue > getPlayerAttributeValues();
    virtual SkillList getPlayerMinorSkills();
    virtual SkillList getPlayerMajorSkills();

    virtual std::string getGameSettingString(const std::string &id, const std::string &default_);

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

    virtual void windowResized(int x, int y);

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

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

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

    virtual bool getPlayerSleeping();
    virtual void wakeUpPlayer();

    virtual void updatePlayer();

    virtual void showSoulgemDialog (MWWorld::Ptr item);

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

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

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

    void onSoulgemDialogButtonPressed (int button);

    virtual bool getCursorVisible();

    virtual void setCursorActive(bool active);

    virtual void clear();

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

    virtual bool isSavingAllowed() const;

    virtual void exitCurrentModal();


    virtual void addCurrentModal(WindowModal* input);


    virtual void removeCurrentModal(WindowModal* input);

    virtual void pinWindow (MWGui::GuiWindow window);

    virtual void fadeScreenIn(const float time, bool clearQueue, float delay);
    virtual void fadeScreenOut(const float time, bool clearQueue, float delay);
    virtual void fadeScreenTo(const int percent, const float time, bool clearQueue, float delay);
    virtual void setBlindness(const int percent);

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

    virtual void toggleDebugWindow();

    virtual void cycleSpell(bool next);
    virtual void cycleWeapon(bool next);

    virtual void playSound(const std::string& soundId, float volume = 1.f, float pitch = 1.f);

    // In WindowManager for now since there isn't a VFS singleton
    virtual std::string correctIconPath(const std::string& path);
    virtual std::string correctBookartPath(const std::string& path, int width, int height, bool* exists = nullptr);
    virtual std::string correctTexturePath(const std::string& path);
    virtual bool textureExists(const std::string& path);

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

    virtual const MWGui::TextColours& getTextColours();

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

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

    osgMyGUI::Platform* mGuiPlatform;
    osgViewer::Viewer* mViewer;

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

    bool mConsoleOnlyScripts;

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

    std::string mSelectedSpell;
    MWWorld::Ptr mSelectedEnchantItem;
    MWWorld::Ptr mSelectedWeapon;

    void loadFontDelegate(MyGUI::xml::ElementPtr _node, const std::string& _file, MyGUI::Version _version);

    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;
    MWRender::LocalMap* mLocalMapRender;
    ToolTips *mToolTips;
    StatsWindow *mStatsWindow;
    MessageBoxManager *mMessageBoxManager;
    Console *mConsole;
    DialogueWindow *mDialogueWindow;
    DragAndDrop* mDragAndDrop;
    InventoryWindow *mInventoryWindow;
    ScrollWindow* mScrollWindow;
    BookWindow* mBookWindow;
    CountDialog* mCountDialog;
    TradeWindow* mTradeWindow;
    SettingsWindow* mSettingsWindow;
    ConfirmationDialog* mConfirmationDialog;
    SpellWindow* mSpellWindow;
    QuickKeysMenu* mQuickKeysMenu;
    LoadingScreen* mLoadingScreen;
    WaitDialog* mWaitDialog;
    SoulgemDialog* mSoulgemDialog;
    MyGUI::ImageBox* mVideoBackground;
    VideoWidget* mVideoWidget;
    ScreenFader* mWerewolfFader;
    ScreenFader* mBlindnessFader;
    ScreenFader* mHitFader;
    ScreenFader* mScreenFader;
    DebugWindow* mDebugWindow;
    JailScreen* mJailScreen;

    std::vector<WindowBase*> mWindows;

    Translation::Storage& mTranslationDataStorage;

    CharacterCreation* mCharGen;

    MyGUI::Widget* mInputBlocker;

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

    void setCursorVisible(bool visible);

    // Various stats about player as needed by window manager
    std::string mPlayerName;
    std::string mPlayerRaceId;
    std::map<int, MWMechanics::AttributeValue > mPlayerAttributes;
    SkillList mPlayerMajorSkills, mPlayerMinorSkills;
    std::map<int, MWMechanics::SkillValue > mPlayerSkillValues;

    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;

        std::string mCloseSound;
        std::string 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;

    SDLUtil::SDLCursorManager* mCursorManager;

    std::vector<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();

    std::map<std::string, std::string> mFallbackMap;
    
    int mShowOwned;

    ToUTF8::FromType mEncoding;

    int mFontHeight;

    std::string mVersionDescription;

    MWGui::TextColours mTextColours;

    std::unique_ptr<KeyboardNavigation> mKeyboardNavigation;

    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();
  };
}

#endif