Window.h

Go to the documentation of this file.

 
#pragma once
 
#include "Geometry/Point.h"
#include "ConsumableEvent.h"
#include "Geometry/Rectangle.h"
#include "Containers/Collection.h"
#include "WindowManager.h"
#include "Event.h"
#include "Layer.h"
#include "Input.h"
#include "Input/Keyboard.h"
#include "Graphics/Pointer.h"
 
namespace Gorgon {
    namespace internal {
        struct windowdata;
    }
    
    namespace Graphics {
        class Layer;
    }
        
 
    class Window : public Layer {
        friend internal::windowdata *WindowManager::internal::getdata(const Window&);
        friend struct internal::windowdata;
        friend class Layer;
        friend class windaccess;
    public:
        static const struct FullscreenTag {
            
        }Fullscreen;
        
        Window() { }
 
        Window(Geometry::Rectangle rect, const std::string &name, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), rect, name, name, allowresize, visible) {}
 
        Window(Geometry::Rectangle rect, const char *name, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), rect, name, name, allowresize, visible) {}
 
        Window(const Geometry::Size &size, const std::string &name, const std::string &title, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), {automaticplacement, size}, name, title, allowresize, visible) { }
 
        Window(const Geometry::Size &size, const char *name, const char *title, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), {automaticplacement, size}, name, title, allowresize, visible) { }
 
        Window(const Geometry::Size &size, const std::string &name, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), {automaticplacement, size}, name, name, allowresize, visible) { }
 
        Window(const Geometry::Size &size, const char *name, bool allowresize=false, bool visible=true) :
            Window(WindowManager::Monitor::Primary(), {automaticplacement, size}, name, name, allowresize, visible) { }
 
        Window(const WindowManager::Monitor &monitor, const Geometry::Size &size, const std::string &name, bool allowresize=false, bool visible=true) :
            Window(monitor, {automaticplacement, size}, name, name, allowresize, visible) { }
 
        Window(const WindowManager::Monitor &monitor, const Geometry::Size &size, const char *name, bool allowresize=false, bool visible=true) :
            Window(monitor, {automaticplacement, size}, name, name, allowresize, visible) { }
 
        Window(const FullscreenTag &, const WindowManager::Monitor &monitor, const std::string &name, const std::string &title="");
 
        Window(const FullscreenTag &tag, const std::string &name, const std::string &title="") :
            Window(tag, WindowManager::Monitor::Primary(), name, title) { }
 
        Window(const Window &) = delete;
        
        Window(Window &&other) {
            Swap(other);
        }
            
        ~Window() { Destroy(); }
        
        void Destroy();
        
        Window &operator =(Window &&other) {
            Swap(other);
            
            other.Destroy();
            
            return *this;
        }
        
        void Swap(Window &other);
 
        void processmessages();
 
        void activatecontext();
 
        virtual void Move(const Geometry::Point &position) override;
 
        virtual void Move(int x, int y) override {
            Move({x, y});
        }
 
        virtual void Resize(const Geometry::Size &size) override;
 
        virtual void Resize(int width, int height) override {
            Resize({width, height});
        }
 
        Geometry::Bounds GetExteriorBounds() const;
 
        Geometry::Point GetPosition() const {
            return GetExteriorBounds().TopLeft();
        }
 
        void Minimize();
 
        bool IsMinimized() const;
 
        void Maximize();
 
        bool IsMaximized() const;
 
        void Restore();
 
        const WindowManager::Monitor &GetMonitor() const;
 
        virtual void Show() override;
 
        virtual void Hide() override;
        
        virtual bool IsVisible() const override { return isvisible; }
 
        void Focus();
 
        bool IsFocused() const;
 
        void Close();
 
        void SetTitle(const std::string &title);
 
        std::string GetTitle() const;
 
        std::string GetName() const {
            return name;
        }
 
        bool IsClosed() const;
 
        void ShowPointer();
 
        void HidePointer();
 
        bool IsPointerVisible() const {
            return showptr;
        }
 
        void SwitchToLocalPointers();
 
        void SwitchToWMPointers();
 
        bool IsLocalPointer() const {
            return !iswmpointer;
        }
 
        void Center() {
            Center(WindowManager::Monitor::Primary());
        }
        
        void Center(const WindowManager::Monitor &monitor) {
            Move((monitor.GetUsable()-GetExteriorBounds().GetSize()).Center());
        }
 
        void SetIcon(const WindowManager::Icon &icon);
 
        virtual void Render() override;
        
        Geometry::Point GetMouseLocation() const {
            return mouselocation;
        }
        
        Input::Mouse::Button PressedButtons() const {
            return pressed;
        }
        
        bool IsLeftButtonPressed() const {
            return pressed&&Input::Mouse::Button::Left;
        }
        
        bool IsRightButtonPressed() const {
            return pressed&&Input::Mouse::Button::Right;
        }
        
        bool IsMiddleButtonPressed() const {
            return pressed&&Input::Mouse::Button::Middle;
        }
        
        bool IsX1ButtonPressed() const {
            return pressed&&Input::Mouse::Button::X1;
        }
        
        bool IsX2ButtonPressed() const {
            return pressed&&Input::Mouse::Button::X2;
        }
 
        void AllowResize();
 
        void PreventResize();
        
        static Geometry::Size GetMinimumRequiredSize();
        
        Graphics::PointerStack Pointers; 
 
        
        Event<Window> FocusedEvent{*this};
 
        Event<Window> LostFocusEvent{*this};
 
        Event<Window> DestroyedEvent{*this};
 
        Event<Window, bool&> ClosingEvent{*this};
 
        Event<Window> MovedEvent{*this};
 
        Event<Window> ResizedEvent{*this};
 
        Event<Window> MinimizedEvent{*this};
 
        Event<Window> RestoredEvent{*this};
        
        ConsumableEvent<Window, Input::Key, float> KeyEvent{*this};
 
        ConsumableEvent<Window, Input::Keyboard::Char> CharacterEvent{*this};
 
        static const Containers::Collection<Window> &Windows;
        
        void mouse_down(Geometry::Point location, Input::Mouse::Button button);
 
        void mouse_up(Geometry::Point location, Input::Mouse::Button button);
 
        void mouse_event(Input::Mouse::EventType event, Geometry::Point location, Input::Mouse::Button button, float amount);
 
        void mouse_location();
 
    protected:
        Window(const WindowManager::Monitor &monitor, Geometry::Rectangle rect, const std::string &name, const std::string &title, bool allowresize, bool visible);
 
        virtual void located(Layer *) override { Utils::ASSERT_FALSE("A window cannot be placed in another layer"); }
        
        virtual void added(Layer &layer) override;
        
        
        void deleting(Layer *layer) { if(layer==down) down = MouseHandler{}; }
 
    private:
        void createglcontext();
 
        void updatedataowner();
 
        std::string name;
        
        internal::windowdata *data = nullptr;
 
        static Containers::Collection<Window> windows;
 
        static const Geometry::Point automaticplacement;
        
        Input::Mouse::Button pressed = Input::Mouse::Button::None;
        
        MouseHandler down;
        MouseHandler over;
        
        bool allowresize = false;
        
        bool cursorover = true;
 
 
        Geometry::Point mousedownlocation = {-1, -1};
        Geometry::Point mouselocation = {-1, -1};
        
        Graphics::Layer *pointerlayer = nullptr;
        bool iswmpointer = true;
        bool showptr = true;
        bool switchbacktolocalptr = false;
 
        Geometry::Size glsize = {0, 0};
    };
}