Window.hpp

#ifndef AETHER_WINDOW_HPP
#define AETHER_WINDOW_HPP

#include <queue>
#include <stack>

// Forward declare the typedef
namespace {
    typedef std::function<void(const std::string, const bool)> LogHandler;
};

// Forward declare pointers
namespace Aether {
    class Overlay;
    class Screen;
    class Timer;
}

namespace Aether {
    class Window {
        public:
            enum class ScreenOperation {
                Push,       
                Pop,        
                Set         
            };

        private:
            enum class FadeAction {
                None,       
                In,         
                Out         
            };

            struct FadeVars {
                FadeAction action;                                              
                short alpha;                                                    
                bool in;                                                        
                bool out;                                                       
            } fade;

            double lastMillis;                                                  
            bool shouldLoop;                                                    
            bool showDebug;                                                     
            Timer * timer;                                                      
            Colour bgColour;                                                    
            Drawable * bgDrawable;                                              
            Button heldButton;                                                  
            int heldTime;                                                       
            int holdDelay_;                                                     
            std::function<Colour(uint32_t)> highlight;                          
            std::vector<Overlay *> overlays;                                    
            std::queue< std::pair<ScreenOperation, Screen *> > screenOps;       
            std::stack<Screen *> screenStack;                                   
            Screen * screen;                                                    
            void performScreenOps();

            void processEvents();

            void renderDebug(const double delta);

            void renderFade(const double delta);

            void updateHeldButton(const double delta);

            void updateOverlays(const double delta);

        public:
            Window(const std::string & name, const unsigned int width, const unsigned int height, const LogHandler & log);

            void showDebugInfo(const bool show);

            void setFadeIn(const bool fade);

            void setFadeOut(const bool fade);

            void setBackgroundColour(const Colour & col);

            bool setBackgroundImage(const std::string & path);

            void setFont(const std::string & path);

            void setFontSpacing(const double spacing);

            void setHighlightAnimation(const std::function<Colour(const uint32_t)> & func);

            void setHighlightBackground(const Colour & col);

            void setHighlightOverlay(const Colour & col);

            int holdDelay();

            void setHoldDelay(const int ms);

            void addOverlay(Overlay * ovl);

            void pushScreen();

            void popScreen();

            void removeScreen();

            void showScreen(Screen * screen);

            bool loop();

            void exit();

            ~Window();
    };
};

#endif