WindowManager.h

Go to the documentation of this file.

 
#pragma once
 
#include "Geometry/Point.h"
#include "Geometry/Size.h"
#include "Geometry/Rectangle.h"
#include "Containers/Collection.h"
#include "Utils/Assert.h"
#include "Event.h"
#include "Containers/Image.h"
#include "Resource/GID.h"
 
namespace Gorgon {
    
    namespace internal {
        struct windowdata;
    }
    
    class Window;
 
    namespace WindowManager {
        
        namespace internal {
            Gorgon::internal::windowdata *getdata(const Window&);
 
            void switchcontext(Gorgon::internal::windowdata &data);
            void finalizerender(Gorgon::internal::windowdata &data);
 
            struct icondata;
            struct pointerdata;
            struct monitordata;
        }
        
        class Icon {
            friend class Gorgon::Window;
        public:
            explicit Icon(const Containers::Image &image);
            
            Icon(const Icon &) = delete;
            
            Icon(Icon &&icon);
            
            Icon &operator =(const Icon &) = delete;
            
            Icon &operator =(Icon &&icon);
            
            Icon();
            
            void Destroy();
            
            void FromImage(const Containers::Image &image);
            
            ~Icon();
            
        private:
            internal::icondata *data;
        };
        
        class Pointer {
        public:
            Pointer();
            
            ~Pointer();
            
        private:
            internal::pointerdata *data;
        };
        
        /*
         * Represents a monitor.
         */
        class Monitor {
            friend struct internal::monitordata;
            friend void addpadding(const Monitor*, int, int, int, int);
        public:
            Geometry::Size  GetSize() const {
                return area.GetSize();
            }
            
            Geometry::Point GetLocation() const {
                return area.TopLeft();
            }
            
            Geometry::Rectangle GetArea() const {
                return area;
            }
            
            Geometry::Bounds GetUsable() const {
                return usable;
            }
            
            bool IsPrimary() const {
                return isprimary;
            }
            
            std::string GetName() const {
                return name;
            }
            
            ~Monitor();
            
            static Monitor &Primary() {
#ifndef NDEBUG
                ASSERT(primary, "WindowManager module is not initialized or there are no connected monitors.");
#endif
                
                return *primary;
            }
            
            static const Containers::Collection<Monitor> &Monitors() {
                return monitors;
            }
            
            
            static const Monitor *FromLocation(Geometry::Point location) {
                for(auto &monitor : monitors) {
                    if(IsInside(monitor.GetArea(), location)) {
                        return &monitor;
                    }
                }
                
                return nullptr;
            }
            
            static void Refresh(bool force=false);
            
            static bool IsChangeEventSupported();
            
            static Event<> ChangedEvent;
            
        private:
            Monitor();
            internal::monitordata *data;
            
            Geometry::Rectangle area        = {0,0,0,0};
            Geometry::Bounds    usable      = {0,0,0,0};
            bool                isprimary   = false;
            
            std::string name;
            
            static Containers::Collection<Monitor> monitors;
            static Monitor *primary;
        };
        
        void Initialize();
 
        intptr_t CurrentContext();
 
        std::vector<Resource::GID::Type> GetClipboardFormats();
 
        std::string GetClipboardText(Resource::GID::Type type = Resource::GID::Text);
        
        void SetClipboardText(const std::string &text, Resource::GID::Type type = Resource::GID::Text, 
                              bool unicode = true, bool append = false);
        
        std::vector<std::string> GetClipboardList(Resource::GID::Type type = Resource::GID::FileList);
 
        void SetClipboardList(std::vector<std::string> list, Resource::GID::Type type = Resource::GID::FileList, bool append = false);
 
        Containers::Image GetClipboardBitmap();
 
        void SetClipboardBitmap(Containers::Image img, bool append = false);
    }
}