---

listbox_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 "listbox_generic.h"
#include "API/GUI/listbox.h"
#include "API/GUI/scrollbar.h"
#include "API/GUI/component.h"
#include "API/GUI/component_options.h"
#include "API/GUI/stylemanager.h"
#include "API/Display/Input/input.h"

// Construction:

CL_ComponentOptions CL_ListBox_Generic::create_options(
        const CL_Rect &pos)
{
        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.get_width());
        options.add_option_as_int("height", pos.get_height());

        return options;
}

CL_ListBox_Generic::CL_ListBox_Generic(CL_ListBox *self, const CL_ComponentOptions &options, CL_StyleManager *style)
:
        listbox(self)
{
        highlighted_item = -1;
        item_height = 16;
        max_visible_items = 18;
        scroll_offset = 0;
        has_scrollbar = true;

        // Fetch items
        int item_count = options.count("item");
        for (int i = 0; i < item_count; i++)
                items.push_back(options.get_value("item", i));

        // Create client area (which is the main listbox)
        CL_Rect rect(4, 4, listbox->get_width() - 4, listbox->get_height() - 4);
        client_area = new CL_Component(rect, listbox, style);

        // Create a scrollbar
        rect = CL_Rect(listbox->get_width() - 19, 3, listbox->get_width() - 3, listbox->get_height() - 3);
        int range = get_count() - max_visible_items;
        scrollbar = new CL_ScrollBar(rect, 0, range, false, listbox, style);
        update_scrollbar();

        slot_on_key_down = client_area->sig_key_down().connect(
                CL_CreateSlot(this, &CL_ListBox_Generic::on_key_down));
        slot_child_add = listbox->sig_child_add().connect(
                CL_CreateSlot(this, &CL_ListBox_Generic::on_child_add));
        slot_child_remove = listbox->sig_child_remove().connect(
                CL_CreateSlot(this, &CL_ListBox_Generic::on_child_remove));
        slot_on_scroll_change = scrollbar->sig_value_changed().connect(
                CL_CreateSlot(this, &CL_ListBox_Generic::on_scroll_change));
}

void CL_ListBox_Generic::update_scrollbar()
{       
        if (get_count() > max_visible_items)
        {
                if(has_scrollbar == false)
                {
                        has_scrollbar = true;
                        listbox->add_child(scrollbar, true);
                }

                scrollbar->set_max_value(get_count() - max_visible_items);
        }
        else {
                if(has_scrollbar)
                {
                        has_scrollbar = false;                
                        listbox->remove_child(scrollbar);
                }
        }
}

// Attributes:

int CL_ListBox_Generic::get_count() const
{
        return items.size();
}

std::list<std::string> &CL_ListBox_Generic::get_items()
{
        return items;
}

std::string CL_ListBox_Generic::get_text(int index) const
{
        int pos = 0;
        std::list<std::string>::const_iterator it;
        for(it = items.begin(); it != items.end(); it++, pos++)
                if(pos == index)
                        return (*it);

        return "";
}

std::string CL_ListBox_Generic::get_current_text() const
{
        return get_text(highlighted_item);
}

int CL_ListBox_Generic::get_current_item() const
{
        return highlighted_item;
}

bool CL_ListBox_Generic::is_selected(int index) const
{
        return (highlighted_item == index);
}

int CL_ListBox_Generic::get_item_height() const
{
        return item_height;
}

int CL_ListBox_Generic::get_top_item() const
{
        return scroll_offset;
}

// Operations:

int CL_ListBox_Generic::insert_item(const std::string &item, int index)
{
        if(index < 0)
                items.push_back(item);
        else
                throw CL_Error("CL_ListBox::insert_item() using index is not implemented");

        update_scrollbar();

        return items.size() - 1;
}

void CL_ListBox_Generic::remove_item(int index)
{
        if(index < 0 || index > get_count())
                return;

        int pos = 0;
        std::list<std::string>::iterator it;
        for (it = items.begin(); it != items.end(); ++it, ++pos)
        {
                if(pos == index)
                {
                        items.erase(it);
                        break;
                }
        }

        if(highlighted_item >= get_count())
                highlighted_item = -1;

        if(get_count() - scroll_offset < max_visible_items)
                scroll_offset = 0;

        update_scrollbar();
}

void CL_ListBox_Generic::change_item(const std::string &text, int index)
{
        throw CL_Error("CL_ListBox::change_item() is not implemented");
}

void CL_ListBox_Generic::set_current_item(int index)
{
        if(index < 0 || index >= get_count())
                return;

        highlighted_item = index;
        sig_activated(highlighted_item);
}

void CL_ListBox_Generic::clear_selection()
{
        highlighted_item = -1;
}

void CL_ListBox_Generic::set_item_height(int height)
{
        item_height = height;
}

void CL_ListBox_Generic::sort(bool ascending)
{
        throw CL_Error("CL_ListBox::sort() is not implemented");
}

void CL_ListBox_Generic::clear()
{
        items.clear();
        highlighted_item = -1;

        update_scrollbar();
}

void CL_ListBox_Generic::set_max_visible_items(int count)
{
        // TODO: Run some update here
        max_visible_items = count;
}

void CL_ListBox_Generic::set_top_item(int index)
{
        // TODO: Check range
        scroll_offset = index;
}

// Callbacks:

void CL_ListBox_Generic::on_key_down(CL_Component *comp, CL_InputDevice *device, CL_Key key)
{
        // TODO: This is NOT nice...find a better way:
//      if (device != CL_Input::pointers[0] || key.id != 0) return;

        int index = (int)(key.y / item_height + scroll_offset);
        set_current_item(index);
}

void CL_ListBox_Generic::on_scroll_change(int new_offset)
{
        set_top_item(new_offset);
}

void CL_ListBox_Generic::on_child_add(CL_Component *child)
{
        CL_Rect rect_child = child->get_position();
        CL_Rect rect_clientarea = client_area->get_position();

        if(rect_child.x2 < rect_clientarea.get_width() / 2)     // Left side
                rect_clientarea.x1 = rect_child.x2 + 2;
        else
                rect_clientarea.x2 = rect_child.x1 - 2;
/*
        if(rect_child.y2 < rect_clientarea.get_height() / 2)    // Top side
                rect_clientarea.y1 = rect_child.y2;
        else
                rect_clientarea.y2 = rect_child.y1;
*/
        client_area->set_position(rect_clientarea);
}

void CL_ListBox_Generic::on_child_remove(CL_Component *child)
{
}

---