Screen.h

#ifndef SCREEN_H
#define SCREEN_H
 
#include "Etterna/Actor/Base/ActorFrame.h"
#include "Etterna/Models/Misc/CodeSet.h"
#include "Etterna/Models/Misc/EnumHelper.h"
#include "ScreenMessage.h"
#include "Etterna/Models/Misc/ThemeMetric.h"
 
#include <functional>
#include <list>
 
class InputEventPlus;
class Screen;
using CreateScreenFn = Screen* (*)(const std::string&);
 
struct RegisterScreenClass
{
    RegisterScreenClass(const std::string& sClassName, CreateScreenFn pfn);
};
 
#define REGISTER_SCREEN_CLASS(className)                                       \
    static Screen* Create##className(const std::string& sName)                 \
    {                                                                          \
        LuaThreadVariable var("LoadingScreen", sName);                         \
        Screen* pRet = new className;                                          \
        pRet->SetName(sName);                                                  \
        Screen::InitScreen(pRet);                                              \
        return pRet;                                                           \
    }                                                                          \
    static RegisterScreenClass register_##className(#className,                \
                                                    Create##className)
 
enum ScreenType
{
    attract,
    game_menu,
    gameplay,
    evaluation,
    system_menu,
    NUM_ScreenType,
    ScreenType_Invalid
};
 
const std::string&
ScreenTypeToString(ScreenType st);
LuaDeclareType(ScreenType);
 
class Screen : public ActorFrame
{
  public:
    static void InitScreen(Screen* pScreen);
 
    ~Screen() override;
 
    virtual void Init();
 
    virtual void BeginScreen();
 
    virtual void EndScreen();
 
    void Update(float fDeltaTime) override;
    virtual void UpdateTimedFunctions(float fDeltaTime);
    virtual bool Input(const InputEventPlus& input);
    virtual void HandleScreenMessage(const ScreenMessage& SM);
    void SetLockInputSecs(const float f) { m_fLockInputSecs = f; }
 
    void PostScreenMessage(const ScreenMessage& SM, float fDelay);
    void ClearMessageQueue();
    void ClearMessageQueue(const ScreenMessage& SM);
 
    virtual ScreenType GetScreenType() const
    {
        return ALLOW_OPERATOR_MENU_BUTTON ? game_menu : system_menu;
    }
 
    bool AllowOperatorMenuButton() const { return ALLOW_OPERATOR_MENU_BUTTON; }
 
    virtual bool AllowLateJoin() const { return false; }
 
    // Lua
    void PushSelf(lua_State* L) override;
 
    std::vector<std::pair<std::function<void()>, float>> delayedFunctions;
    void SetTimeout(const std::function<void()>& f, float ms);
    std::list<std::tuple<std::function<void()>, float, float, int>>
      delayedPeriodicFunctions; // This is a list to allow safe iterators
    std::vector<int> delayedPeriodicFunctionIdsToDelete;
    void SetInterval(const std::function<void()>& f, float ms, int fRemove);
 
    bool b_PreviewNoteFieldIsActive = false;
 
  protected:
    struct QueuedScreenMessage
    {
        ScreenMessage SM;
        float fDelayRemaining;
    };
 
    std::vector<QueuedScreenMessage> m_QueuedMessages;
    static bool SortMessagesByDelayRemaining(const QueuedScreenMessage& m1,
                                             const QueuedScreenMessage& m2);
 
    InputQueueCodeSet m_Codes;
 
    ThemeMetric<bool> ALLOW_OPERATOR_MENU_BUTTON;
    ThemeMetric<bool> HANDLE_BACK_BUTTON;
    ThemeMetric<float> REPEAT_RATE;
    ThemeMetric<float> REPEAT_DELAY;
 
    std::string m_sNextScreen;
    std::string m_sPrevScreen;
    ScreenMessage m_smSendOnPop;
 
    float m_fLockInputSecs = 0.F;
 
    // If currently between BeginScreen/EndScreen calls:
    bool m_bRunning = false;
 
  public:
    std::string GetNextScreenName() const;
    std::string GetPrevScreen() const;
    void SetNextScreenName(std::string const& name);
    void SetPrevScreenName(std::string const& name);
 
    bool PassInputToLua(const InputEventPlus& input);
    void AddInputCallbackFromStack(lua_State* L);
    void RemoveInputCallback(lua_State* L);
    virtual bool AllowCallbackInput() { return true; }
 
    // let subclass override if they want
    virtual bool MenuUp(const InputEventPlus&) { return false; }
    virtual bool MenuDown(const InputEventPlus&) { return false; }
    virtual bool MenuLeft(const InputEventPlus&) { return false; }
    virtual bool MenuRight(const InputEventPlus&) { return false; }
    virtual bool MenuStart(const InputEventPlus&) { return false; }
    virtual bool MenuSelect(const InputEventPlus&) { return false; }
    virtual bool MenuBack(const InputEventPlus&) { return false; }
    virtual bool MenuCoin(const InputEventPlus&) { return false; }
 
  private:
    // void* is the key so that we can use lua_topointer to find the callback
    // to remove when removing a callback.
    using callback_key_t = const void*;
    std::map<callback_key_t, LuaReference> m_InputCallbacks;
    std::vector<callback_key_t> orderedcallbacks;
    std::vector<callback_key_t> m_DelayedCallbackRemovals;
    bool m_CallingInputCallbacks = false;
    void InternalRemoveCallback(callback_key_t key);
};
 
#endif