---

component.cpp

Go to the documentation of this file.

/*
        ClanGUI, copyrights by various people. Have a look in the CREDITS file.
        
        This sourcecode is distributed using the Library GNU Public Licence,
        version 2 or (at your option) any later version. Please read LICENSE
        for details.
*/

#include "precomp.h"
#include "API/Core/System/cl_assert.h"
#include "API/GUI/gui_manager.h"
#include "API/GUI/component_options.h"
#include "component_generic.h"
#include "component_manager_generic.h"
#include <vector>

CL_Component::CL_Component(
        const CL_ComponentOptions &options,
        CL_Component *parent,
        CL_StyleManager *style)
:
        impl(NULL)
{
        impl = new CL_Component_Generic(this, CL_Rect(0,0,0,0), parent, style);

        int x = 0, y = 0, width = 0, height = 0;

        if (options.exists("x"))      x = options.get_value_as_int("x");
        if (options.exists("y"))      y = options.get_value_as_int("y");
        if (options.exists("width"))  width = options.get_value_as_int("width");
        if (options.exists("height")) height = options.get_value_as_int("height");

        set_position(CL_Rect(x, y, x + width, y + height));

        if (options.exists("visible")) show(options.get_value_as_bool("visible"));
        if (options.exists("enabled")) enable(options.get_value_as_bool("enabled"));

//      cl_assert(parent != NULL);

        if (get_style_manager() != NULL)
                get_style_manager()->connect_styles("component", options, this);

        if (parent != NULL) parent->add_child(this);
}

CL_Component::CL_Component(CL_Component *parent, CL_StyleManager *style)
: impl(NULL)
{
        impl = new CL_Component_Generic(this, CL_Rect(0,0,0,0), parent, style);

        CL_ComponentOptions options;
        options.add_option_as_int("x", 0);
        options.add_option_as_int("y", 0);
        options.add_option_as_int("width", 0);
        options.add_option_as_int("height", 0);

        if (style != NULL) style->connect_styles("component", options, this);
        if (parent != NULL) parent->add_child(this);
}

CL_Component::CL_Component(const CL_Rect &pos, CL_Component *parent, CL_StyleManager *style)
: impl(NULL)
{
        impl = new CL_Component_Generic(this, pos, parent, style);

        CL_ComponentOptions options;
        options.add_option_as_int("x", pos.x1);
        options.add_option_as_int("y", pos.y1);
        options.add_option_as_int("width", pos.x2 - pos.x1);
        options.add_option_as_int("height", pos.y2 - pos.y1);

        if (style != NULL) style->connect_styles("component", options, this);
        if (parent != NULL) parent->add_child(this);
}

CL_Component::~CL_Component()
{
//      if (impl->parent != NULL) impl->parent->remove_child(this);
        delete impl;
}

CL_Component *CL_Component::get_parent() const
{
        return impl->parent;
}

bool CL_Component::has_child(CL_Component *component) const
{
        for (
                std::list<CL_Component *>::iterator it = impl->children.begin();
                it != impl->children.end();
                it++)
        {
                        if (*it == component || (*it)->has_child(component)) return true;
        }

        return false;
}

void CL_Component::add_components(CL_ComponentManager *component_manager)
{
        std::vector<CL_Component *> components;
        ((CL_ComponentManager_Generic *) component_manager)->get_root_component_list(components);

        for (
                std::vector<CL_Component *>::iterator it = components.begin();
                it != components.end();
                it++)
        {
                add_child(*it);
        }
}

void CL_Component::add_child(CL_Component *child, bool delete_child)
{
        if(has_child(child))
                return;

        impl->children.push_back(child);
        child->set_parent(this);

        if (delete_child) impl->delete_children.push_back(child);

        impl->sig_child_add(child);
}

void CL_Component::remove_child(CL_Component *child)
{
        child->set_parent(NULL);
        impl->children.remove(child);

        impl->sig_child_remove(child);
}

CL_Rect CL_Component::get_children_rect()
{
        CL_Rect rect(0, 0, 0, 0);
        
        for (
                std::list<CL_Component *>::iterator it = impl->children.begin();
                it != impl->children.end();
                it++)
        {
                CL_Component *comp = (*it);
                CL_Rect childrect = comp->get_position();

                if(childrect.x1 < rect.x1)
                        rect.x1 = childrect.x1;
                if(childrect.y1 < rect.y1)
                        rect.y1 = childrect.y1;
                if(childrect.x2 > rect.x2)
                        rect.x2 = childrect.x2;
                if(childrect.y2 > rect.y2)
                        rect.y2 = childrect.y2;
        }

        return rect;
}

void CL_Component::update()
{
        impl->sig_begin_paint();
        impl->sig_paint();

        for (
                std::list<CL_Component *>::iterator it = impl->children.begin();
                it != impl->children.end();
                it++)
        {
                if((*it)->is_visible()) (*it)->update();
        }

        impl->sig_end_paint();
}

CL_GUIManager *CL_Component::get_gui_manager() const
{
        if (impl->gui != NULL) return impl->gui;
        if (impl->parent != NULL) return impl->parent->get_gui_manager();
        return NULL;
}

CL_StyleManager *CL_Component::get_style_manager() const
{
        return impl->style_manager;
}

void CL_Component::set_gui_manager(CL_GUIManager *gui)
{
        impl->gui = gui;
}

CL_Component *CL_Component::get_root_parent()
{
        if(impl->parent)
                return impl->parent->get_root_parent();
        else
                return this;
}

bool CL_Component::is_visible() const
{
        return impl->visible;
}

void CL_Component::show(bool show)
{
        impl->visible = show;
}

bool CL_Component::is_enabled() const
{
        return impl->enabled;
}

void CL_Component::enable(bool enable)
{
        impl->enabled = enable;
}

void CL_Component::set_focus()
{
        get_gui_manager()->set_focus(this);
}

bool CL_Component::has_focus() const
{
        return get_gui_manager()->get_focus() == this;
}

CL_Rect CL_Component::get_screen_rect() const
{
        if (impl->parent == NULL)
        {
                return impl->position;
        }
        else
        {
                CL_Rect r = impl->parent->get_screen_rect();

                return CL_Rect(
                        r.x1 + impl->position.x1, 
                        r.y1 + impl->position.y1,
                        r.x1 + impl->position.x2, 
                        r.y1 + impl->position.y2);
        }
}

bool CL_Component::is_mouse_captured() const
{
        return impl->captured;
}

void CL_Component::capture_mouse()
{
        CL_GUIManager *gui = get_gui_manager();
        if (gui != NULL)
        {
                gui->gui_capture_mouse(this);
                impl->captured = true;
        }
}

void CL_Component::release_mouse()
{
        CL_GUIManager *gui = get_gui_manager();
        if (gui != NULL)
        {
                gui->gui_release_mouse();
                impl->captured = false;
        }
}

void CL_Component::run(CL_GUIManager *parent)
{
        CL_GUIManager modal_gui(parent, get_style_manager());
        modal_gui.add_child(this);
        modal_gui.run();
}

int CL_Component::get_width() const
{
        return impl->position.x2 - impl->position.x1;
}

int CL_Component::get_height() const
{
        return impl->position.y2 - impl->position.y1;
}

bool CL_Component::is_popup() const
{
        return impl->popup;
}

void CL_Component::popup(bool popup)
{
        impl->popup = popup;
}

bool CL_Component::is_removeflag_set() const
{
        return impl->removeflag;
}

const CL_Rect &CL_Component::get_position() const
{
        return impl->position;
}

void CL_Component::set_position(const CL_Rect &new_pos)
{
        impl->position = new_pos;
}

void CL_Component::set_position(int new_x, int new_y)
{
        impl->position.x2 = get_width() + new_x;
        impl->position.y2 = get_height() + new_y;
        impl->position.x1 = new_x;
        impl->position.y1 = new_y;
}

void CL_Component::set_size(int new_width, int new_height)
{
        int old_width = get_width();
        int old_height = get_height();
        impl->position.x2 = impl->position.x1 + new_width;
        impl->position.y2 = impl->position.y1 + new_height;
        impl->sig_resized(old_width, old_height);
}

void CL_Component::set_parent(CL_Component *parent)
{
        impl->parent = parent;
}

void CL_Component::set_width(int width)
{
        int old_width = get_width();
        impl->position.x2 = impl->position.x1 + width;
        impl->sig_resized(old_width, get_height());
}

void CL_Component::set_height(int height)
{
        int old_height = get_height();
        impl->position.y2 = impl->position.y1 + height;
        impl->sig_resized(get_width(), old_height);
}

void CL_Component::quit()
{
        get_gui_manager()->quit();
}

void CL_Component::clear_removeflag()
{
        impl->removeflag = false;
}

void CL_Component::close()
{
        show(false);
        impl->removeflag = true;
        set_gui_manager(NULL);
}

CL_Component *CL_Component::get_component_at(int pos_x, int pos_y)
{
        std::list<CL_Component *>::reverse_iterator it;
        for (it = impl->children.rbegin(); it != impl->children.rend(); it++)
        {
                CL_Component *cur_component = (*it);
                const CL_Rect &r = cur_component->get_position();

                if (pos_x >= r.x1 && pos_x < r.x2 &&
                        pos_y >= r.y1 && pos_y < r.y2)
                {
                        return cur_component->get_component_at(pos_x - r.x1, pos_y - r.y1);
                }
        }

        return this;
}

std::list<CL_Component *> &CL_Component::get_children()
{
        return impl->children;
}

const std::list<CL_Component *> &CL_Component::get_children() const
{
        return impl->children;
}

void CL_Component::attach_style(CL_ComponentStyle *style)
{
        impl->styles.push_back(style);
}

void CL_Component::detach_style(CL_ComponentStyle *style)
{
        impl->styles.remove(style);
}

// API level signals:

CL_Signal_v0 &CL_Component::sig_paint()
{
        return impl->sig_paint;
}

CL_Signal_v0 &CL_Component::sig_begin_paint()
{
        return impl->sig_begin_paint;
}

CL_Signal_v0 &CL_Component::sig_end_paint()
{
        return impl->sig_end_paint;
}

CL_Signal_v3<CL_Component *, CL_InputDevice *, CL_Key> &CL_Component::sig_key_down()
{
        return impl->sig_key_down;
}

CL_Signal_v3<CL_Component *, CL_InputDevice *, CL_Key> &CL_Component::sig_key_up()
{
        return impl->sig_key_up;
}

CL_Signal_v4<CL_Component *, CL_InputDevice *, int, int> &CL_Component::sig_mouse_moved()
{
        return impl->sig_mouse_moved;
}

CL_Signal_v0 &CL_Component::sig_got_focus()
{
        return impl->sig_got_focus;
}

CL_Signal_v0 &CL_Component::sig_lost_focus()
{
        return impl->sig_lost_focus;
}

CL_Signal_v2<int, int> &CL_Component::sig_resized()
{
        return impl->sig_resized;
}

CL_Signal_v0 &CL_Component::sig_mouse_entered()
{
        return impl->sig_mouse_entered;
}

CL_Signal_v0 &CL_Component::sig_mouse_left()
{
        return impl->sig_mouse_left;
}

CL_Signal_v2<int &, int &> &CL_Component::sig_transform_coords()
{
        return impl->sig_transform_coords;
}

CL_Signal_v1<CL_Component *> &CL_Component::sig_child_add()
{
        return impl->sig_child_add;
}

CL_Signal_v1<CL_Component *> &CL_Component::sig_child_remove()
{
        return impl->sig_child_remove;
}

---