gui_component.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
*/


#pragma once

#include "api_gui.h"
#include "../Core/System/sharedptr.h"
#include "../Core/Signals/callback_0.h"
#include "../Core/Signals/callback_1.h"
#include "../Core/Signals/callback_v0.h"
#include "../Core/Signals/callback_v1.h"
#include "../Core/Signals/callback_v2.h"
#include "../Core/Signals/callback_v3.h"
#include "../Core/Signals/callback_2.h"
#include "../Core/IOData/virtual_directory.h"
#include "../Display/Window/display_window_description.h"
#include "../Display/Window/display_window.h"
#include "../Display/Render/graphic_context.h"
#include "../Display/Window/input_context.h"
#include "gui_layout.h"
#include <vector>

class CL_DomDocument;
class CL_GraphicContext;
class CL_InputContext;
class CL_InputEvent;
class CL_Cursor;
class CL_GUIMessage;
class CL_GUIManager;
class CL_GUITheme;
class CL_ResourceManager;
class CL_GUIConsumedKeys;
class CL_GUIComponent_Impl;

typedef CL_DisplayWindowDescription CL_GUITopLevelDescription;

class CL_API_GUI CL_GUIComponent
{
public:
        CL_GUIComponent(CL_GUIComponent *parent);

        CL_GUIComponent(CL_GUIManager *manager, CL_GUITopLevelDescription description);

        CL_GUIComponent(CL_GUIComponent *owner, CL_GUITopLevelDescription description);

        virtual ~CL_GUIComponent();

public:
        CL_Rect get_geometry() const;

        int get_width() const;

        int get_height() const;

        CL_Size get_size() const;

        CL_Rect get_window_geometry() const;

        CL_StringRef get_type_name() const;

        CL_StringRef get_class_name() const;

        CL_StringRef get_id_name() const;

        CL_StringRef get_element_name() const;

        bool has_focus() const;

        bool get_allow_resize() const;

        bool get_clip_children() const;

        enum FocusPolicy
        {
                focus_refuse,
                focus_local,
                focus_group,
                focus_parent
        };

        FocusPolicy get_focus_policy() const;

        CL_StringRef get_component_group_name() const;

        bool is_selected_in_group() const;

        bool get_blocks_default_action() const;

        CL_ResourceManager get_resources() const;

        CL_GUIManager get_gui_manager() const;

        CL_GUITheme get_theme() const;


        const CL_GUIComponent *get_parent_component() const;

        CL_GUIComponent *get_parent_component();


        const CL_GUIComponent *get_owner_component() const;

        CL_GUIComponent *get_owner_component();

        std::vector<CL_GUIComponent*> get_child_components() const;

        const CL_GUIComponent *get_first_child() const;

        CL_GUIComponent *get_first_child();

        const CL_GUIComponent *get_last_child() const;

        CL_GUIComponent *get_next_component_in_tree();

        CL_GUIComponent *get_previous_component_in_tree();

        CL_GUIComponent *get_last_child();

        std::vector<CL_GUIComponent*> get_child_component_group(const CL_String &group_name) const;

        CL_GUIComponent *get_group_selected_component();

        CL_GUIComponent *get_named_item(const CL_StringRef &id);

        bool has_child_components() const;

        const CL_GUIComponent *get_previous_sibling() const;

        CL_GUIComponent *get_previous_sibling();

        const CL_GUIComponent *get_next_sibling() const;

        CL_GUIComponent *get_next_sibling();

        bool is_descendant_of(CL_GUIComponent *component);

        bool is_ancestor_of(CL_GUIComponent *component);

        const CL_GUIComponent *get_top_level_component() const;

        CL_GUIComponent *get_top_level_component();

        CL_GraphicContext& get_gc();

        CL_InputContext& get_ic();

        bool is_enabled() const;

        bool is_visible() const;

        bool is_active() const;

        CL_GUIComponent *get_component_at(const CL_Point &point);

        virtual CL_Size get_preferred_size() const;

        int get_preferred_width() const;

        int get_preferred_height() const;

        CL_Point window_to_component_coords(const CL_Point &window_point) const;

        CL_Rect window_to_component_coords(const CL_Rect &window_rect) const;

        CL_Point component_to_window_coords(const CL_Point &component_point) const;

        CL_Rect component_to_window_coords(const CL_Rect &component_rect) const;

        CL_Point screen_to_component_coords(const CL_Point &screen_point) const;

        CL_Point component_to_screen_coords(const CL_Point &component_point) const;

        CL_GUILayout get_layout() const;

        CL_DisplayWindow get_display_window() const;

        bool is_default();

        bool is_cancel();

        bool get_constant_repaint() const;

public:
        CL_Callback_v2<CL_GraphicContext &, const CL_Rect &> &func_render();

        CL_Callback_v1<CL_GUIMessage &> &func_process_message();

        CL_Callback_0<bool> &func_close();

        CL_Callback_0<bool> &func_activated();

        CL_Callback_0<bool> &func_deactivated();

        CL_Callback_0<bool> &func_focus_lost();

        CL_Callback_0<bool> &func_focus_gained();

        CL_Callback_0<bool> &func_pointer_enter();

        CL_Callback_0<bool> &func_pointer_exit();

        CL_Callback_v1<CL_GUIMessage&> &func_filter_message();

        CL_Callback_1<bool, const CL_InputEvent &> &func_input();

        CL_Callback_1<bool, const CL_InputEvent &> &func_input_pressed();

        CL_Callback_1<bool, const CL_InputEvent &> &func_input_released();

        CL_Callback_1<bool, const CL_InputEvent &> &func_input_doubleclick();

        CL_Callback_1<bool, const CL_InputEvent &> &func_input_pointer_moved();

        CL_Callback_v1<bool> &func_visibility_change();

        CL_Callback_v0 &func_style_changed();

        CL_Callback_v0 &func_enablemode_changed();

        CL_Callback_v0 &func_resized();

        CL_Callback_v1<CL_Rect &> &func_constrain_resize();


        virtual CL_Callback_2<CL_GUIComponent*, CL_GUIComponent*, CL_String> &func_create_custom_component();

public:
        void render(CL_GraphicContext &gc, const CL_Rect &clip_rect, bool include_children = true);


        void paint();

        void paint(const CL_Rect &clip_rect);

        int exec();


        void exit_with_code(int exit_code);

        void set_geometry(CL_Rect geometry);

        void set_window_geometry(CL_Rect geometry);

        void set_type_name(const CL_StringRef &name); 

        void set_class_name(const CL_StringRef &name);

        void set_id_name(const CL_StringRef &name);

        void set_enabled(bool enable = true);

        void set_clip_children(bool clip = true);

        void set_visible(bool visible = true, bool activate_root_win=true);

        void set_focus(bool enable = true);

        void capture_mouse(bool capture);

        void capture_proximity(bool capture);

        void set_focus_policy(FocusPolicy policy);

        void set_component_group_name(const CL_StringRef &str);

        void set_selected_in_component_group(bool selected);

        void create_components(const CL_DomDocument &gui_xml);

        void create_components(const CL_StringRef &fullname);

        void create_components(CL_IODevice &file);

        void create_components(const CL_StringRef &filename, const CL_VirtualDirectory &dir);

        // Request an asynchronous redraw of the specified area.
        void request_repaint();

        void request_repaint(CL_Rect rect);

        void set_cliprect(CL_GraphicContext &gc, const CL_Rect &rect);

        void reset_cliprect(CL_GraphicContext &gc);

        void push_cliprect(CL_GraphicContext &gc, const CL_Rect &rect);

        void pop_cliprect(CL_GraphicContext &gc);

        void delete_child_components();

        void set_parent_component(CL_GUIComponent *new_parent);

        void set_layout(CL_GUILayout &layout);

        void set_cursor(const CL_Cursor &cursor);

        void set_cursor(enum CL_StandardCursor type);

        void focus_next();

        void focus_previous();


        void set_default(bool value);


        void set_cancel(bool value);

        void set_blocks_default_action(bool block);

        void set_constant_repaint(bool enable);

private:
        CL_SharedPtr<CL_GUIComponent_Impl> impl;

        CL_GUIComponent(CL_GUIComponent &other);

        CL_GUIComponent &operator =(const CL_GUIComponent &other);

        CL_GraphicContext dummy_gc;
        CL_InputContext dummy_ic;

        friend class CL_GUIManager_Impl;

        friend class CL_GUIComponent_Impl;

        friend class CL_Window;

        friend class CL_Window_Impl;
};

---