display_window.h

/*
**  UICore
**  Copyright (c) 1997-2015 The UICore Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries UICore may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
**    Kenneth Gangstoe
*/

#pragma once

#include "../../Core/Signals/signal.h"
#include "../display_target.h"
#include <memory>

#if !defined(WIN32) && !defined(__ANDROID__) && !defined(__APPLE__)
// We prefer not to include Xlib.h in uicorelib (to prevent namespace issues when "using namespace uicore")
struct _XDisplay;
typedef struct _XDisplay Display;
typedef unsigned long Window;
#endif

#if defined(__ANDROID__)
struct ANativeWindow;
#endif

namespace uicore
{
    class Sizef;
    class Rectf;
    class Display;
    class GraphicContext;
    typedef std::shared_ptr<GraphicContext> GraphicContextPtr;
    class DisplayWindowMode;
    class DisplayWindowDescription;
    struct DisplayWindowHandle;
    class InputDevice;
    typedef std::shared_ptr<InputDevice> InputDevicePtr;
    class Pointf;
    class Cursor;
    typedef std::shared_ptr<Cursor> CursorPtr;
    class DisplayWindowProvider;
    class DisplayWindow_Impl;
    class PixelBuffer;
    typedef std::shared_ptr<PixelBuffer> PixelBufferPtr;

    enum class StandardCursor
    {
        arrow,
        appstarting,
        cross,
        hand,
        ibeam,
        no,
        size_all,
        size_nesw,
        size_ns,
        size_nwse,
        size_we,
        uparrow,
        wait
    };

    struct DisplayWindowHandle
    {
#ifdef WIN32
        HWND hwnd = 0;
#elif defined(__ANDROID__)
        ANativeWindow *window = 0;
#elif defined(__APPLE__)
#else
        ::Display *display = 0;
        ::Window window = 0;
        int screen = -1;
#endif
    };

    class DisplayWindow
    {
    public:
        static std::shared_ptr<DisplayWindow> create(const std::string &title, float width, float height, bool start_fullscreen = false, bool allow_resize = true, int flipping_buffers = 2);
        static std::shared_ptr<DisplayWindow> create(const DisplayWindowDescription &description);

        virtual Rectf geometry() const = 0;

        virtual Rectf viewport() const = 0;

        virtual bool is_fullscreen() const = 0;

        virtual bool has_focus() const = 0;

        virtual const GraphicContextPtr &gc() const = 0;

        virtual const InputDevicePtr &keyboard() const = 0;

        virtual const InputDevicePtr &mouse() const = 0;

        virtual const std::vector<InputDevicePtr> &game_controllers() const = 0;

        const InputDevicePtr &input_device(const std::string &device_name) const;

        virtual Signal<void()> &sig_lost_focus() = 0;

        virtual Signal<void()> &sig_got_focus() = 0;

        virtual Signal<void(float, float)> &sig_resize() = 0;

        virtual Signal<void()> &sig_paint() = 0;

        virtual Signal<void()> &sig_window_close() = 0;

        virtual Signal<void()> &sig_window_destroy() = 0;

        virtual Signal<void()> &sig_window_minimized() = 0;

        virtual Signal<void()> &sig_window_maximized() = 0;

        virtual Signal<void()> &sig_window_restored() = 0;

        virtual Signal<void()> &sig_window_moved() = 0;

        virtual Signal<void()> &sig_window_flip() = 0;

        virtual std::function<void(Rectf &)> &func_window_resize() = 0;

        virtual std::function<bool()> &func_minimize_clicked() = 0;

#ifdef WIN32
        virtual std::function<bool(HWND, UINT, WPARAM, LPARAM)> &func_window_message() = 0;

        virtual Signal<void(HWND, UINT, WPARAM, LPARAM)> &sig_window_message() = 0;
#endif

        virtual bool is_visible() const = 0;

        virtual bool is_minimized() const = 0;

        virtual bool is_maximized() const = 0;

        virtual bool is_clipboard_text_available() const = 0;

        virtual bool is_clipboard_image_available() const = 0;

        virtual std::string clipboard_text() const = 0;

        virtual PixelBufferPtr clipboard_image() const = 0;

        virtual Sizef minimum_size(bool client_area = false) = 0;

        virtual Sizef maximum_size(bool client_area = false) = 0;

        virtual std::string title() const = 0;

        virtual DisplayWindowHandle handle() const = 0;

        virtual Pointf client_to_screen(const Pointf &client) = 0;

        virtual Pointf screen_to_client(const Pointf &screen) = 0;

        virtual void capture_mouse(bool capture) = 0;

        virtual void request_repaint() = 0;

        virtual void set_title(const std::string &title) = 0;

        virtual void set_position(const Rectf &pos, bool client_area) = 0;

        virtual void set_position(float x, float y) = 0;

        virtual void set_enabled(bool enable) = 0;

        void set_visible(bool visible, bool activate);

        virtual void set_size(float width, float height, bool client_area) = 0;

        virtual void set_minimum_size(float width, float height, bool client_area) = 0;

        virtual void set_maximum_size(float width, float height, bool client_area) = 0;

        virtual void minimize() = 0;

        virtual void restore() = 0;

        virtual void maximize() = 0;

        virtual void toggle_fullscreen() = 0;

        virtual void show(bool activate = true) = 0;

        virtual void hide() = 0;

        virtual void bring_to_front() = 0;

        virtual void flip(int interval = -1) = 0;

        virtual void show_cursor() = 0;

        virtual void set_cursor(const CursorPtr &cursor) = 0;

        virtual void set_cursor(StandardCursor type) = 0;

#ifdef WIN32
        virtual void set_cursor_handle(HCURSOR cursor) = 0;
#endif

        virtual void hide_cursor() = 0;

        virtual void set_clipboard_text(const std::string &text) = 0;

        virtual void set_clipboard_image(const PixelBufferPtr &buf) = 0;

        virtual void set_large_icon(const PixelBufferPtr &image) = 0;

        virtual void set_small_icon(const PixelBufferPtr &image) = 0;

        virtual void enable_alpha_channel(const Rectf &blur_rect) = 0;

        virtual void extend_frame_into_client_area(float left, float top, float right, float bottom) = 0;
    };

    typedef std::shared_ptr<DisplayWindow> DisplayWindowPtr;
}