---

gui_manager_generic.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/Display/Display/display.h"
#include "API/Display/Input/input.h"
#include "API/Display/Input/inputdevice.h"
#include "API/Display/Input/inputcursor.h"
#include "API/Core/System/system.h"
#include "API/GUI/component.h"
#include "gui_manager_generic.h"
#include "component_manager_generic.h"

// CL_GUIManager_Generic construction:

CL_GUIManager_Generic::CL_GUIManager_Generic(CL_GUIManager *_owner, CL_Component *parent_component)
:
        owner(_owner),
        parent(NULL),
        input_enabled(true),
        comp_focus(_owner),
        comp_capture_mouse(NULL),
        comp_mouse_over(NULL)
{
        owner->set_gui_manager(owner);

        if(parent_component)
        {
                parent = parent_component->get_gui_manager();
                if(parent)
                        parent->disable_input();
        }

        slot_button_press = CL_Input::sig_button_press.connect(
                CL_CreateSlot(
                        this,
                        &CL_GUIManager_Generic::on_button_press));

        slot_button_release = CL_Input::sig_button_release.connect(
                CL_CreateSlot(
                        this,
                        &CL_GUIManager_Generic::on_button_release));

        slot_mouse_move = CL_Input::sig_mouse_move.connect(
                CL_CreateSlot(
                        this,
                        &CL_GUIManager_Generic::on_mouse_move));
}

CL_GUIManager_Generic::~CL_GUIManager_Generic()
{
        if (parent)
                parent->enable_input();

        disable_input();
}

// CL_GUIManager_Generic attributes:

CL_Component *CL_GUIManager_Generic::get_focus()
{
        return comp_focus;
}

// CL_GUIManager_Generic operations:

void CL_GUIManager_Generic::set_focus(CL_Component *component)
{
        if (comp_focus == component) return;

        comp_focus->sig_lost_focus()();
        comp_focus = component;
        comp_focus->sig_got_focus()();
}

void CL_GUIManager_Generic::quit()
{
        quit_run = true;
}

void CL_GUIManager_Generic::run()
{
        quit_run = false;
        while (!quit_run)
        {
                if (parent)
                        parent->show();
                show();
                        
                CL_Display::flip_display();
                CL_System::keep_alive();
        }
}

void CL_GUIManager_Generic::show()
{
        if (parent)
                parent->show();

        owner->update();

/*
        // Remove all closed components
        bool new_focus = false;
        std::list<COMP_PAIR>::iterator it;
        for (it = components.begin(); it != components.end();)
        {
                CL_Component *cur_component = (*it).first;
                if(cur_component->is_removeflag_set())
                {
                        it = components.erase(it);
                        new_focus = true;
                }
                else
                        it++;
        }
*/
}

void CL_GUIManager_Generic::enable_input()
{
        input_enabled = true;
}

void CL_GUIManager_Generic::disable_input()
{
        input_enabled = false;
}

void CL_GUIManager_Generic::gui_capture_mouse(CL_Component *component)
{
        comp_capture_mouse = component;
}

void CL_GUIManager_Generic::gui_release_mouse()
{
        comp_capture_mouse = NULL;
}

void CL_GUIManager_Generic::on_button_press(
        CL_InputDevice *device,
        const CL_Key &key)
{
        if (!input_enabled) return;

        CL_Key k = key;
        int _x = k.x;
        int _y = k.y;
        
        owner->sig_transform_coords()(_x, _y);

        k.x = _x;
        k.y = _y;
        k.x -= owner->get_position().x1;
        k.y -= owner->get_position().y1;

        // if in capture mode:
        if (comp_capture_mouse)
                owner->sig_key_down()(comp_capture_mouse, device, k);

        // if it is the mouse pointer:
        else if (device == CL_Input::pointers[0])
                owner->sig_key_down()(NULL, device, k);

        // keyboard, route using focused component.
        else
                owner->sig_key_down()(comp_focus, device, k);
}

void CL_GUIManager_Generic::on_button_release(
        CL_InputDevice *device,
        const CL_Key &key)
{
        if (!input_enabled) return;

        CL_Key k = key;
        int _x = k.x;
        int _y = k.y;
        
        owner->sig_transform_coords()(_x, _y);

        k.x = _x;
        k.y = _y;
        k.x -= owner->get_position().x1;
        k.y -= owner->get_position().y1;

        // if in capture mode:
        if (comp_capture_mouse)
                owner->sig_key_up()(comp_capture_mouse, device, k);

        // if it is the mouse pointer:
        else if (device == CL_Input::pointers[0])
                owner->sig_key_up()(NULL, device, k);

        // keyboard, route using focused component.
        else
                owner->sig_key_up()(comp_focus, device, k);
}

void CL_GUIManager_Generic::on_mouse_move(
        CL_InputDevice *device, 
        int x,
        int y)
{
        if (!input_enabled) return;

        owner->sig_transform_coords()(x, y);

        // if in capture mode:
        if (comp_capture_mouse)
                owner->sig_mouse_moved()(comp_capture_mouse, device, x, y);

        // if it is the mouse pointer:
        else if (device == CL_Input::pointers[0])
                owner->sig_mouse_moved()(NULL, device, x, y);

        // keyboard, route using focused component.
        else
                owner->sig_mouse_moved()(comp_focus, device, x, y);

/*
        // Mouse enter/leave
        CL_Component *new_comp_mouse_over = NULL;
        std::list<COMP_PAIR>::iterator it;
        for (it = components.begin(); it != components.end(); it++)
        {
                CL_Component *cur_component = (*it).first;
                const CL_Rect &r = cur_component->get_position();

                int pos_x = (int) x;
                int pos_y = (int) y;
                (*it).first->sig_transform_coords()(pos_x, pos_y);

                if (pos_x >= r.x1 && pos_x < r.x2 &&
                        pos_y >= r.y1 && pos_y < r.y2)
                {
                        int x = pos_x - r.x1;
                        int y = pos_y - r.y1;
                        new_comp_mouse_over = cur_component->get_component_at(x, y);
                        break;
                }
        }

        if(new_comp_mouse_over != comp_mouse_over)
        {
                if(comp_mouse_over)
                {
                        comp_mouse_over->sig_mouse_left()();
                        comp_mouse_over = new_comp_mouse_over;
                }
                if(new_comp_mouse_over)
                {
                        comp_mouse_over = new_comp_mouse_over;
                        comp_mouse_over->sig_mouse_entered()();
                }
        }

        if(components.front().first->is_visible() == false ||
           components.front().first->is_enabled() == false)
                return;

        int pos_x = (int) x;
        int pos_y = (int) y;
        components.front().first->sig_transform_coords()(pos_x, pos_y);

        if (comp_capture_mouse == NULL && device == CL_Input::pointers[0])
        {
                const CL_Rect &r = components.front().first->get_position();
                if (pos_x < r.x1 || pos_x >= r.x2 ||
                        pos_y < r.y1 || pos_y >= r.y2)
                {
                        return;
                }
        }

        pos_x -= components.front().first->get_position().x1;
        pos_y -= components.front().first->get_position().y1;

        if (comp_capture_mouse) std::cout << "mouse is captured!" << std::endl;
        components.front().first->sig_mouse_moved()(comp_capture_mouse, device, pos_x, pos_y);
*/
}

---