Window.h

Go to the documentation of this file.

#pragma once
 
#include "../Utils/Assert.h"
#include "../Event.h"
#include "../Main.h"
#include "../Layer.h"
#include "../Input/Layer.h"
#include "../Input/Keyboard.h"
#include "../Graphics/Layer.h"
#include "../Window.h"
#include "LayerAdapter.h"
 
#include "WidgetContainer.h"
 
#include <stdexcept>
 
 
namespace Gorgon { namespace UI {
 
    class Window : public Gorgon::Window, public Runner, public WidgetContainer {
    public:
        using Gorgon::Window::Window;
 
        Window() : Gorgon::Window() {
        }
        
        ~Window() {
            KeyEvent.Unregister(inputtoken);
            CharacterEvent.Unregister(chartoken);
            delete extenderlayer;
        }
        
        Window(Window &&other) : Gorgon::Window(std::move(other)), WidgetContainer(std::move(other)) {
            KeyEvent.Unregister(inputtoken);
            CharacterEvent.Unregister(chartoken);
            
            inputtoken = keyinit();
            chartoken  = charinit();
            
            delete extenderlayer;
            extenderlayer = other.extenderlayer;
            Add(extenderlayer);
            other.extenderlayer = other.layerinit();
        }
        
        Window &operator=(Window &&other) {
            other.KeyEvent.Unregister(other.inputtoken);
            other.CharacterEvent.Unregister(other.chartoken);
            
            KeyEvent.Unregister(inputtoken);
            CharacterEvent.Unregister(chartoken);
            
            Gorgon::Window::operator =(std::move(other));
            WidgetContainer::operator =(std::move(other));
            
            
            inputtoken = keyinit();
            chartoken  = charinit();
            
            delete extenderlayer;
            extenderlayer = other.extenderlayer;
            Add(extenderlayer);
            adapter.SetLayer(*extenderlayer);
            other.extenderlayer = other.layerinit();
            other.Add(other.extenderlayer);
            other.adapter.SetLayer(*other.extenderlayer);
            
            return *this;
        }
        
        virtual Geometry::Size GetInteriorSize() const override {
            return Gorgon::Window::GetSize();
        }
        
        virtual bool IsVisible() const override {
            return Gorgon::Window::IsVisible();
        }
        
        virtual void Quit() override {
            quiting = true;
        }
 
        virtual void Run() override {
            while(!quiting) {
                Gorgon::NextFrame();
            }
 
            Gorgon::Window::Close();
        }
 
        virtual void Step() override {
            Gorgon::NextFrame();
        }
        
        bool EnsureVisible(const UI::Widget &) override {
            return true;
        }
        
        virtual ExtenderRequestResponse RequestExtender(const Gorgon::Layer &self) override {
            return {true, &adapter, self.TranslateToTopLevel(), GetSize()};
        }
        
        using WidgetContainer::Add;
        using Gorgon::Window::Add;
        using Gorgon::Window::KeyEvent;
        using Gorgon::Window::CharacterEvent;
 
    protected:
        virtual Gorgon::Layer &getlayer() override {
            return *this;
        }
        
        virtual bool ResizeInterior(Geometry::Size size) override {
            Gorgon::Window::Resize(size);
            
            return GetSize() == size;
        }
 
        decltype(KeyEvent)::Token keyinit() {
            inputtoken = KeyEvent.Register([this](Input::Key key, float amount) {
                return WidgetContainer::KeyEvent(key, amount);
            });
            
            KeyEvent.NewHandler = [this]{
                RegisterOnce([this] {
                    this->KeyEvent.MoveToTop(this->inputtoken);
                });
            };
 
            return inputtoken;
        }
 
        decltype(CharacterEvent)::Token charinit() {
            chartoken = CharacterEvent.Register([this](Char c) {
                return WidgetContainer::CharacterEvent(c);
            });
            
            CharacterEvent.NewHandler = [this]{
                RegisterOnce([this] {
                    this->CharacterEvent.MoveToTop(this->chartoken);
                });
            };
 
            return chartoken;
        }
        
        Graphics::Layer *layerinit() {
            auto l = new Graphics::Layer;
            Add(l);
            adapter.SetLayer(*l);
            return l;
        }
 
        void added(Layer &l) override {
            long ind = children.FindLocation(extenderlayer);
            if(ind != -1) {
                children.MoveBefore(ind, children.GetSize());
            }
            
            Gorgon::Window::added(l);
        }
 
    private:
        bool quiting = false;
        LayerAdapter adapter;
        Graphics::Layer *extenderlayer = layerinit();
 
        decltype(KeyEvent)::Token inputtoken = keyinit(); //to initialize token after window got constructed
        decltype(CharacterEvent)::Token chartoken = charinit(); //to initialize token after window got constructed
    };
    
} }