display_window.h

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2009 The ClanLib 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 ClanLib may link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
**    Harry Storbacka
**    Kenneth Gangstoe
*/


#pragma once

#include "../api_display.h"
#include "../../Core/System/sharedptr.h"
#include "../../Core/System/weakptr.h"
#include "../../Core/Signals/signal_v0.h"
#include "../../Core/Signals/signal_v1.h"
#include "../../Core/Signals/signal_v2.h"
#include "../../Core/Signals/callback_v1.h"
#include "../../Core/Text/string_types.h"
#include "../display_target.h"

class CL_Size;
class CL_Rect;
class CL_Display;
class CL_GraphicContext;
class CL_DisplayWindowMode;
class CL_DisplayWindowDescription;
class CL_InputContext;
class CL_Point;
class CL_Cursor;
class CL_DisplayWindowProvider;
class CL_DisplayWindow_Impl;
class CL_PixelBuffer;

enum CL_StandardCursor
{
        cl_cursor_arrow,
        cl_cursor_appstarting,
        cl_cursor_cross,
        cl_cursor_hand,
        cl_cursor_ibeam,
        cl_cursor_no,
        cl_cursor_size_all,
        cl_cursor_size_nesw,
        cl_cursor_size_ns,
        cl_cursor_size_nwse,
        cl_cursor_size_we,
        cl_cursor_uparrow,
        cl_cursor_wait
};

class CL_API_DISPLAY CL_DisplayWindow
{
public:
        CL_DisplayWindow();

        CL_DisplayWindow(
                const CL_StringRef &title,
                int width,
                int height,
                bool start_fullscreen = false,
                bool allow_resize = false,
                int flipping_buffers = 2,
                CL_DisplayTarget target = CL_DisplayTarget());

        CL_DisplayWindow(
                const CL_DisplayWindowDescription &description,
                CL_DisplayTarget target = CL_DisplayTarget());

        CL_DisplayWindow(CL_DisplayWindowProvider *provider);

        ~CL_DisplayWindow();

public:
        CL_Rect get_geometry() const;

        CL_Rect get_viewport() const;

        bool is_fullscreen() const;

        bool has_focus() const;

        CL_GraphicContext& get_gc() const;

        CL_InputContext& get_ic() const;

        CL_Signal_v0 &sig_lost_focus();

        CL_Signal_v0 &sig_got_focus();

        CL_Signal_v2<int, int> &sig_resize();

        CL_Signal_v1<const CL_Rect &> &sig_paint();

        CL_Signal_v0 &sig_window_close();

        CL_Signal_v0 &sig_window_minimized();

        CL_Signal_v0 &sig_window_maximized();

        CL_Callback_v1<CL_Rect &> &func_window_resize();

        bool is_null() const;

        bool is_visible() const;

        bool is_minimized() const;

        bool is_maximized() const;

        CL_DisplayWindowProvider *get_provider() const;

        bool is_clipboard_text_available() const;

        bool is_clipboard_image_available() const;

        CL_String get_clipboard_text() const;

        CL_PixelBuffer get_clipboard_image() const;

#ifdef WIN32

        HWND get_hwnd() const;
#endif

public:
        CL_Point client_to_screen(const CL_Point &client);

        CL_Point screen_to_client(const CL_Point &screen);

        void capture_mouse(bool capture);

        void request_repaint(const CL_Rect &rect);

        void set_title(const CL_StringRef &title);

        void set_position(const CL_Rect &pos, bool client_area);

        void set_position(int x, int y);

        void set_enabled(bool enable);

        void set_visible(bool visible, bool activate);

        void set_size(int width, int height, bool client_area);

        void set_minimum_size(int width, int height, bool client_area);

        void set_maximum_size(int width, int height, bool client_area);

        void minimize();

        void restore();

        void maximize();

        void show(bool activate = true);

        void hide();

        void bring_to_front();

        void update(const CL_Rect &rect);

        void flip(int interval = -1);

        void show_cursor();

        void set_cursor(const CL_Cursor &cursor);

        void set_cursor(CL_StandardCursor type);

        void hide_cursor();

        void set_clipboard_text(const CL_StringRef &text);

        void set_clipboard_image(const CL_PixelBuffer &buf);

        void set_large_icon(const CL_PixelBuffer &image);

        void set_small_icon(const CL_PixelBuffer &image);

private:
        CL_SharedPtr<CL_DisplayWindow_Impl> impl;

};

---