hvirtual/guicast/bclistbox.C

Go to the documentation of this file.

#include "bcdragwindow.h"
#include "bclistbox.h"
#include "bclistboxitem.h"
#include "bcpixmap.h"
#include "bcresources.h"
#include "bcsignals.h"
#include "clip.h"
#include "cursors.h"
#include "fonts.h"
#include "keys.h"
#include "language.h"
#include "bctimer.h"
#include "vframe.h"

#include <string.h>
#include <unistd.h>

// ====================================================== scrollbars


BC_ListBoxYScroll::BC_ListBoxYScroll(BC_ListBox *listbox, 
                          int total_height, 
                                          int view_height, 
                          int position)
 : BC_ScrollBar(listbox->get_yscroll_x(), 
        listbox->get_yscroll_y(), 
        SCROLL_VERT, 
        listbox->get_yscroll_height(), 
        total_height, 
        position, 
        view_height)
{
        this->listbox = listbox;
}

BC_ListBoxYScroll::~BC_ListBoxYScroll()
{
}

int BC_ListBoxYScroll::handle_event()
{
        listbox->set_yposition(get_value());
        return 1;
}







BC_ListBoxXScroll::BC_ListBoxXScroll(BC_ListBox *listbox, 
                          int total_width, 
                                          int view_width,
                          int position)
 : BC_ScrollBar(listbox->get_xscroll_x(), 
        listbox->get_xscroll_y(), 
        SCROLL_HORIZ, 
        listbox->get_xscroll_width(), 
        total_width, 
        position, 
        view_width)
{
        this->listbox = listbox;
}

BC_ListBoxXScroll::~BC_ListBoxXScroll()
{
}

int BC_ListBoxXScroll::handle_event()
{
        listbox->set_xposition(get_value());
        return 1;
}








BC_ListBoxToggle::BC_ListBoxToggle(BC_ListBox *listbox, 
        BC_ListBoxItem *item, 
        int x, 
        int y)
{
        this->listbox = listbox;
        this->item = item;
        this->x = x;
        this->y = y;
        this->value = item->get_expand();
        if(this->value) 
                state = BC_Toggle::TOGGLE_CHECKED;
        else
                state = BC_Toggle::TOGGLE_UP;
}

void BC_ListBoxToggle::update(BC_ListBoxItem *item, 
        int x, 
        int y,
        int flash)
{
        this->value = item->get_expand();
        this->item = item;
        this->x = x;
        this->y = y;

// update state
        switch(state)
        {
                case TOGGLE_UP:
                        if(value)
                                state = TOGGLE_CHECKED;
                        break;

                case TOGGLE_UPHI:
                        if(value)
                                state = TOGGLE_CHECKEDHI;
                        break;

                case TOGGLE_CHECKED:
                        if(!value)
                                state = TOGGLE_UP;
                        break;

                case TOGGLE_DOWN:
                        break;

                case TOGGLE_CHECKEDHI:
                        if(!value)
                                state = TOGGLE_UPHI;
                        break;

                case TOGGLE_DOWN_EXIT:
                        break;
        }


        draw(flash);
}

int BC_ListBoxToggle::cursor_motion_event(int *redraw_toggles)
{
        int w = listbox->toggle_images[0]->get_w();
        int h = listbox->toggle_images[0]->get_h();
        int cursor_inside = listbox->get_cursor_x() >= x && 
                listbox->get_cursor_x() < x + w &&
                listbox->get_cursor_y() >= y && 
                listbox->get_cursor_y() < y + h;
        int result = 0;

        switch(state)
        {
                case BC_ListBoxToggle::TOGGLE_UPHI:
                        if(!cursor_inside)
                        {
                                state = BC_ListBoxToggle::TOGGLE_UP;
                                *redraw_toggles = 1;
                        }
                        break;

                case BC_ListBoxToggle::TOGGLE_CHECKEDHI:
                        if(!cursor_inside)
                        {
                                state = BC_ListBoxToggle::TOGGLE_CHECKED;
                                *redraw_toggles = 1;
                        }
                        break;

                case BC_ListBoxToggle::TOGGLE_DOWN:
                        if(!cursor_inside)
                        {
                                state = BC_ListBoxToggle::TOGGLE_DOWN_EXIT;
                                *redraw_toggles = 1;
                        }
                        result = 1;
                        break;

                case BC_ListBoxToggle::TOGGLE_DOWN_EXIT:
                        if(cursor_inside)
                        {
                                state = BC_ListBoxToggle::TOGGLE_DOWN;
                                *redraw_toggles = 1;
                        }
                        result = 1;
                        break;

                default:
                        if(cursor_inside)
                        {
                                if(value)
                                        state = BC_ListBoxToggle::TOGGLE_CHECKEDHI;
                                else
                                        state = BC_ListBoxToggle::TOGGLE_UPHI;
                                *redraw_toggles = 1;
                        }
                        break;
        }
        return result;
}

int BC_ListBoxToggle::cursor_leave_event(int *redraw_toggles)
{
        if(value)
                state = BC_ListBoxToggle::TOGGLE_CHECKED;
        else
                state = BC_ListBoxToggle::TOGGLE_UP;
}

int BC_ListBoxToggle::button_press_event()
{
        int w = listbox->toggle_images[0]->get_w();
        int h = listbox->toggle_images[0]->get_h();

        if(listbox->gui->get_cursor_x() >= x && 
                listbox->gui->get_cursor_x() < x + w &&
                listbox->gui->get_cursor_y() >= y && 
                listbox->gui->get_cursor_y() < y + h)
        {
                state = BC_ListBoxToggle::TOGGLE_DOWN;
                return 1;
        }
        return 0;
}

int BC_ListBoxToggle::button_release_event(int *redraw_toggles)
{
        int result = 0;
        switch(state)
        {
                case BC_ListBoxToggle::TOGGLE_DOWN:
                        value = !value;
                        if(value)
                                state = BC_ListBoxToggle::TOGGLE_CHECKEDHI;
                        else
                                state = BC_ListBoxToggle::TOGGLE_UPHI;
                        listbox->expand_item(item, value);
                        result = 1;
                        break;

                case BC_ListBoxToggle::TOGGLE_DOWN_EXIT:
                        if(value)
                                state = BC_ListBoxToggle::TOGGLE_CHECKED;
                        else
                                state = BC_ListBoxToggle::TOGGLE_UP;
                        *redraw_toggles = 1;
                        result = 1;
                        break;
        }
        return result;
}

void BC_ListBoxToggle::draw(int flash)
{
        if(listbox->gui)
        {
                int image_number = 0;
                int w = listbox->toggle_images[0]->get_w();
                int h = listbox->toggle_images[0]->get_h();

                switch(state)
                {
                        case BC_ListBoxToggle::TOGGLE_UP: image_number = 0; break;
                        case BC_ListBoxToggle::TOGGLE_UPHI: image_number = 1; break;
                        case BC_ListBoxToggle::TOGGLE_CHECKED: image_number = 2; break;
                        case BC_ListBoxToggle::TOGGLE_DOWN: image_number = 3; break;
                        case BC_ListBoxToggle::TOGGLE_CHECKEDHI: image_number = 4; break;
                        case BC_ListBoxToggle::TOGGLE_DOWN_EXIT:
                                if(value)
                                        image_number = 2;
                                else
                                        image_number = 0;
                                break;
                }

//printf("BC_ListBoxToggle::draw 1 %d\n", state);
                listbox->gui->draw_pixmap(listbox->toggle_images[image_number],
                        x,
                        y);


                if(flash)
                {
                        listbox->gui->flash(x, y, w, h);
                        listbox->gui->flush();
                }
        }
}














// ====================================================== box

BC_ListBox::BC_ListBox(int x, 
        int y, 
        int w, 
        int h,
        int display_format,
        ArrayList<BC_ListBoxItem*> *data,
        char **column_titles,
        int *column_width,
        int columns,
        int yposition,
        int is_popup,
        int selection_mode,
        int icon_position,
        int allow_drag)
 : BC_SubWindow(x, y, w, h, -1)
{
        justify = LISTBOX_RIGHT;
        xposition = 0;
        highlighted_item = -1;
        highlighted_title = -1;
        highlighted_division = -1;
        highlighted_ptr = 0;
        xscrollbar = 0;
        yscrollbar = 0;
        current_cursor = ARROW_CURSOR;
        gui = 0;
        view_h = 0;
        view_w = 0;
        title_h = 0;
        active = 0;
        new_value = 0;
        need_xscroll = 0;
        need_yscroll = 0;
        bg_tile = 0;
        drag_popup = 0;
        selection_number1 = -1;
        selection_number2 = -1;
        bg_surface = 0;
        bg_pixmap = 0;

        current_operation = NO_OPERATION;
        button_highlighted = 0;

        disabled = 0;

        list_highlighted = 0;

        allow_drag_scroll = 1;
        process_drag = 1;

        sort_column = -1;
        sort_order = 0;

        allow_drag_column = 0;
        master_column = 0;
        search_column = 0;

        popup_w = w;
        popup_h = h;

        for(int i = 0; i < 3; i++)
                column_bg[i] = 0;

        for(int i = 0; i < 4; i++)
                button_images[i] = 0;

        for(int i = 0; i < 5; i++)
                toggle_images[i] = 0;

        column_sort_up = 0;
        column_sort_dn = 0;

//printf("BC_ListBox::BC_ListBox 1\n");
        this->data = data;
        this->columns = columns;
        this->yposition = yposition;
        this->is_popup = is_popup;
        this->display_format = display_format;
        this->selection_mode = selection_mode;
        this->icon_position = icon_position;
        this->allow_drag = allow_drag;
        this->column_titles = 0;
        this->column_width = 0;
//printf("BC_ListBox::BC_ListBox 1\n");

        if((!column_titles && column_width) ||
                (column_titles && !column_width))
        {
                printf("BC_ListBox::BC_ListBox either column_titles or column_widths == NULL but not both.\n");
        }
//printf("BC_ListBox::BC_ListBox 2 %p %p\n", column_titles, column_width);
        set_columns(column_titles, 
                column_width, 
                columns);

//printf("BC_ListBox::BC_ListBox 3\n");

        drag_icon_vframe = 0;
        drag_column_icon_vframe = 0;



// reset the search engine
//printf("BC_ListBox::BC_ListBox 4\n");
        reset_query();
//printf("BC_ListBox::BC_ListBox 5\n");
}

BC_ListBox::~BC_ListBox()
{
        expanders.remove_all_objects();
        if(bg_surface) delete bg_surface;
        if(bg_pixmap) delete bg_pixmap;
        if(xscrollbar) delete xscrollbar;
        if(yscrollbar) delete yscrollbar;
        for(int i = 0; i < 3; i++)
                if(column_bg[i]) delete column_bg[i];
        for(int i = 0; i < 4; i++)
                if(button_images[i]) delete button_images[i];
        for(int i = 0; i < 5; i++)
                if(toggle_images[i]) delete toggle_images[i];
        if(column_sort_up) delete column_sort_up;
        if(column_sort_dn) delete column_sort_dn;

        delete_columns();
        if(drag_popup) delete drag_popup;
}

int BC_ListBox::enable()
{
  disabled = 0;
  draw_button();
  return 1;
}

int BC_ListBox::disable()
{
  disabled = 1;
  draw_button();
  return 1;
}

void BC_ListBox::reset_query()
{
        query[0] = 0;  // reset query
}

int BC_ListBox::evaluate_query(int list_item, char *string)
{
        return(strcmp(string, data[search_column].values[list_item]->text) <= 0 && 
                data[search_column].values[list_item]->searchable);
}

int BC_ListBox::query_list()
{
        if(query[0] == 0) return 0;

        int done = 0;
        int result;
        int selection_changed = 0;
        int prev_selection = -1;
        for(int i = 0; !done && i < data[0].total; i++)
        {
                if(evaluate_query(i, query))
                {
                        result = i;
                        done = 1;
                }
        }

        if(done)
        {
// Deselect all
                for(int i = 0; i < data[0].total; i++)
                {
                        for(int j = 0; j < columns; j++)
                        {
                                if(data[j].values[i]->selected) prev_selection = i;
                                data[j].values[i]->selected = 0;
                        }
                }

// Select one
                if(prev_selection != result)
                        selection_changed = 1;
                for(int j = 0; j < columns; j++)
                {
                        data[j].values[result]->selected = 1;
                }
                center_selection(result);
        }

        return selection_changed;
}

void BC_ListBox::init_column_width()
{
        if(!column_width && data)
        {
                int widest = 5, w;
                for(int i = 0; i < data[0].total; i++)
                {
                w = get_text_width(MEDIUMFONT, data[0].values[i]->get_text()) + 2 * LISTBOX_MARGIN;
                        if(w > widest) widest = w;
                }
                default_column_width[0] = widest;
        }
}

int BC_ListBox::initialize()
{
        if(is_popup)
        {
                for(int i = 0; i < 4; i++)
                {
                        button_images[i] = new BC_Pixmap(parent_window, 
                                BC_WindowBase::get_resources()->listbox_button[i], 
                                PIXMAP_ALPHA);
                }
                w = button_images[0]->get_w();
                h = button_images[0]->get_h();
                
                gui = 0;
                current_operation = NO_OPERATION;
        }
        else
        {
                gui = this;
                current_operation = NO_OPERATION;
        }

        for(int i = 0; i < 3; i++)
        {
                column_bg[i] = new BC_Pixmap(parent_window,
                        get_resources()->listbox_column[i],
                        PIXMAP_ALPHA);
        }
        for(int i = 0; i < 5; i++)
        {
                toggle_images[i] = new BC_Pixmap(parent_window,
                        get_resources()->listbox_expand[i],
                        PIXMAP_ALPHA);
        }

        column_sort_up = new BC_Pixmap(parent_window, 
                BC_WindowBase::get_resources()->listbox_up, 
                PIXMAP_ALPHA);
        column_sort_dn = new BC_Pixmap(parent_window, 
                BC_WindowBase::get_resources()->listbox_dn, 
                PIXMAP_ALPHA);

//printf("BC_ListBox::initialize 10\n");
        drag_icon_vframe = get_resources()->type_to_icon[ICON_UNKNOWN];
        drag_column_icon_vframe = get_resources()->type_to_icon[ICON_COLUMN];
// = new BC_Pixmap(parent_window, 
//              get_resources()->type_to_icon[ICON_UNKNOWN], 
//              PIXMAP_ALPHA);
//      drag_column_icon = new BC_Pixmap(parent_window,
//              get_resources()->type_to_icon[ICON_COLUMN],
//              PIXMAP_ALPHA);
        BC_SubWindow::initialize();

        init_column_width();

        if(top_level->get_resources()->listbox_bg)
                bg_pixmap = new BC_Pixmap(this, 
                        get_resources()->listbox_bg, 
                        PIXMAP_OPAQUE);

        draw_button();
        draw_items(1);
        return 0;
}

void BC_ListBox::deactivate_selection()
{
        current_operation = NO_OPERATION;
}

int BC_ListBox::draw_button()
{
// Draw the button for a popup listbox
        if(is_popup)
        {
                int image_number = 0;

                draw_top_background(parent_window, 0, 0, w, h);

                if(button_highlighted)
                        image_number = 1;
                if(current_operation == BUTTON_DN)
                        image_number = 2;
                if(disabled)
                        image_number = 3;


                pixmap->draw_pixmap(button_images[image_number], 
                        0, 
                        0,
                        w,
                        h,
                        0,
                        0);
                flash();
        }
        return 0;
}

int BC_ListBox::calculate_item_coords()
{
        if(!data) return 0;

        int icon_x = 0;
        int next_icon_x = 0;
        int next_icon_y = 0;
        int next_text_y = 0;
// Change the display_format to get the right item dimensions for both
// text and icons.
        int display_format_temp = display_format;


// Scan the first column for lowest y coord of all text
// and lowest right x and y coord for all icons which aren't auto placable
        calculate_last_coords_recursive(data,
                &icon_x,
                &next_icon_x, 
                &next_icon_y,
                &next_text_y,
                1);

// Reset last column width.  It's recalculated based on text width.

        calculate_item_coords_recursive(data,
                &icon_x,
                &next_icon_x, 
                &next_icon_y,
                &next_text_y,
                1);



        display_format = display_format_temp;

        return 0;
}

void BC_ListBox::calculate_last_coords_recursive(
        ArrayList<BC_ListBoxItem*> *data,
        int *icon_x,
        int *next_icon_x,
        int *next_icon_y,
        int *next_text_y,
        int top_level)
{
        for(int i = 0; i < data[0].total; i++)
        {
                int current_text_y = 0;
                int current_icon_x = 0;
                int current_icon_y = 0;
                BC_ListBoxItem *item = data[0].values[i];

// Get next_text_y
                if(!item->autoplace_text)
                {
// Lowest text coordinate
                        display_format = LISTBOX_TEXT;
                        current_text_y = item->text_y + 
                                get_text_height(MEDIUMFONT);
                        if(current_text_y > *next_text_y)
                                *next_text_y = current_text_y;

// Add sublist depth if it is expanded
                        if(item->get_sublist() && 
                                item->get_columns() &&
                                item->get_expand())
                        {
                                calculate_last_coords_recursive(item->get_sublist(),
                                        icon_x,
                                        next_icon_x, 
                                        next_icon_y,
                                        next_text_y,
                                        0);
                        }
                }

// Get next_icon coordinate
                if(top_level)
                {
                        BC_ListBoxItem *item = data[master_column].values[i];
                        if(!item->autoplace_icon)
                        {
                                display_format = LISTBOX_ICONS;
// Lowest right icon coordinate.
                                current_icon_x = item->icon_x;
                                if(current_icon_x > *icon_x) *icon_x = current_icon_x;
                                if(current_icon_x + get_item_w(item) > *next_icon_x)
                                        *next_icon_x = current_icon_x + get_item_w(item);

                                current_icon_y = item->icon_y + get_item_h(item);
                                if(current_icon_y > *next_icon_y) 
                                        *next_icon_y = current_icon_y;
                        }
                }
        }
}


void BC_ListBox::calculate_item_coords_recursive(
        ArrayList<BC_ListBoxItem*> *data,
        int *icon_x,
        int *next_icon_x,
        int *next_icon_y,
        int *next_text_y,
        int top_level)
{



// Set up items which need autoplacement.
// Should fill icons down and then across
        for(int i = 0; i < data[0].total; i++)
        {
// Don't increase y unless the row requires autoplacing.
                int total_autoplaced_columns = 0;

// Set up icons in first column
                if(top_level)
                {
                        BC_ListBoxItem *item = data[master_column].values[i];
                        if(item->autoplace_icon)
                        {
// 1 column only if icons are used
                                display_format = LISTBOX_ICONS;
// Test row height
// Start new row.
                                if(*next_icon_y + get_item_h(item) >= get_h() && 
                                        *next_icon_y > 0)
                                {
                                        *icon_x = *next_icon_x;
                                        *next_icon_y = 0;
                                }

                                if(*icon_x + get_item_w(item) > *next_icon_x)
                                        *next_icon_x = *icon_x + get_item_w(item);


                                item->set_icon_x(*icon_x);
                                item->set_icon_y(*next_icon_y);

                                *next_icon_y += get_item_h(item);
                        }
                }



// Set up a text row
                int next_text_x = 0;
                for(int j = 0; j < columns; j++)
                {
                        BC_ListBoxItem *item = data[j].values[i];
                        if(item->autoplace_text)
                        {
                                display_format = LISTBOX_TEXT;
                                item->set_text_x(next_text_x);
                                item->set_text_y(*next_text_y);

// printf("BC_ListBox::calculate_item_coords_recursive %p %d %d %d %d %s \n", 
// item->get_sublist(), 
// item->get_columns(), 
// item->get_expand(), 
// next_text_x, 
// *next_text_y,
// item->get_text());
// Increment position of next column
                                if(j < columns - 1)
                                        next_text_x += (column_width ? 
                                                column_width[j] : 
                                                default_column_width[j]);
                                else
// Set last column width based on text width
                                {
                                        int new_w = get_item_w(item);

                                        int *previous_w = (column_width ? 
                                                &column_width[j] : 
                                                &default_column_width[j]);
                                        if(new_w > *previous_w)
                                                *previous_w = new_w;
//printf("BC_ListBox::calculate_item_coords_recursive 1 %d\n", new_w);
                                }
                                total_autoplaced_columns++;
                        }
                }

// Increase the text vertical position
                if(total_autoplaced_columns)
                {
                        display_format = LISTBOX_TEXT;
                        *next_text_y += get_text_height(MEDIUMFONT);
                }

// Set up a sublist
                BC_ListBoxItem *item = data[master_column].values[i];
                if(item->get_sublist() &&
                        item->get_columns() &&
                        item->get_expand())
                {
                        calculate_item_coords_recursive(
                                item->get_sublist(),
                                icon_x,
                                next_icon_x,
                                next_icon_y,
                                next_text_y,
                                0);
                }
        }
}

void BC_ListBox::set_justify(int value)
{
        this->justify = value;
}

void BC_ListBox::set_allow_drag_column(int value)
{
        this->allow_drag_column = value;
}

void BC_ListBox::set_process_drag(int value)
{
        this->process_drag = value;
}

void BC_ListBox::set_master_column(int value, int redraw)
{
        this->master_column = value;
        if(redraw)
        {
                draw_items(1);
        }
}

void BC_ListBox::set_search_column(int value)
{
        this->search_column = value;
}

int BC_ListBox::get_sort_column()
{
        return sort_column;
}

void BC_ListBox::set_sort_column(int value, int redraw)
{
        sort_column = value;
        if(redraw)
        {
                draw_titles(1);
        }
}

int BC_ListBox::get_sort_order()
{
        return sort_order;
}

void BC_ListBox::set_sort_order(int value, int redraw)
{
        sort_order = value;
        if(redraw)
        {
                draw_titles(1);
        }
}





int BC_ListBox::get_display_mode()
{
        return display_format;
}

int BC_ListBox::get_yposition()
{
        return yposition;
}

int BC_ListBox::get_xposition()
{
        return xposition;
}

int BC_ListBox::get_highlighted_item()
{
        return highlighted_item;
}


int BC_ListBox::get_item_x(BC_ListBoxItem *item)
{
        if(display_format == LISTBOX_TEXT)
                return item->text_x - xposition + 2;
        else
                return item->icon_x - xposition + 2;
}

int BC_ListBox::get_item_y(BC_ListBoxItem *item)
{
        int result;
        if(display_format == LISTBOX_TEXT)
                result = item->text_y - yposition + title_h + 2;
        else
                result = item->icon_y - yposition + title_h + 2;
        return result;
}

int BC_ListBox::get_item_w(BC_ListBoxItem *item)
{
        if(display_format == LISTBOX_ICONS)
        {
                int x, y, w, h;
                get_icon_mask(item, x, y, w, h);
                int icon_w = w;
                get_text_mask(item, x, y, w, h);
                int text_w = w;

                if(icon_position == ICON_LEFT)
                        return icon_w + text_w;
                else
                        return (icon_w > text_w) ? icon_w : text_w;
        }
        else
        {
                return get_text_width(MEDIUMFONT, item->text) + 2 * LISTBOX_MARGIN;
        }
}

int BC_ListBox::get_item_h(BC_ListBoxItem *item)
{
        if(display_format == LISTBOX_ICONS)
        {
                int x, y, w, h;
                get_icon_mask(item, x, y, w, h);
                int icon_h = h;
                get_text_mask(item, x, y, w, h);
                int text_h = h;

                if(icon_position == ICON_LEFT)
                        return (icon_h > text_h) ? icon_h : text_h;
                else
                        return icon_h + text_h;
        }
        else
        {
                return get_text_height(MEDIUMFONT);
        }
        return 0;
}


int BC_ListBox::get_icon_w(BC_ListBoxItem *item)
{
        BC_Pixmap *icon = item->icon;
        if(icon) return icon->get_w();
        return 0;
}

int BC_ListBox::get_icon_h(BC_ListBoxItem *item)
{
        BC_Pixmap *icon = item->icon;
        if(icon) return icon->get_h();
        return 0;
}

int BC_ListBox::get_items_width()
{
        int widest = 0;

        if(display_format == LISTBOX_ICONS)
        {
                for(int i = 0; i < columns; i++)
                {
                        for(int j = 0; j < data[i].total; j++)
                        {
                                int x1, x, y, w, h;
                                BC_ListBoxItem *item = data[i].values[j];
                                x1 = item->icon_x;

                                get_icon_mask(item, x, y, w, h);
                                if(x1 + w > widest) widest = x1 + w;

                                if(display_format == LISTBOX_ICONS && icon_position == ICON_LEFT)
                                        x1 += w;

                                get_text_mask(item, x, y, w, h);
                                if(x1 + w > widest) widest = x1 + w;
                        }
                }
        }
        else
        if(display_format == LISTBOX_TEXT)
        {
                return get_column_offset(columns);
        }
        return widest;
}

int BC_ListBox::get_items_height(ArrayList<BC_ListBoxItem*> *data, 
        int columns,
        int *result)
{
        int temp = 0;
        int top_level = 0;
        int highest = 0;
        if(!result)
        {
                result = &temp;
                top_level = 1;
        }





        for(int j = 0; j < (data ? data[master_column].total : 0); j++)
        {
                int y1, x, y, w, h;
                BC_ListBoxItem *item = data[master_column].values[j];

                if(display_format == LISTBOX_ICONS)
                {
                        get_icon_mask(item, x, y, w, h);
                        if(y + h + yposition > highest) highest = y + h + yposition;

                        get_text_mask(item, x, y, w, h);
                        if(y + h + yposition > highest) highest = y + h + yposition;
                }
                else
                {
                        get_text_mask(item, x, y, w, h);
                        *result += h;


// Descend into sublist
                        if(item->get_sublist() &&
                                item->get_expand())
                        {
                                get_items_height(item->get_sublist(), 
                                        item->get_columns(), 
                                        result);
                        }
                }
        }
        if(display_format == LISTBOX_TEXT && top_level) 
        {
                highest = LISTBOX_MARGIN + *result;
        }


        return highest;
}

int BC_ListBox::set_yposition(int position, int draw_items)
{
        this->yposition = position;
        if(draw_items)
        {
                this->draw_items(1);
        }
        return 0;
}

int BC_ListBox::set_xposition(int position)
{
        this->xposition = position;
        draw_items(1);
        return 0;
}

void BC_ListBox::expand_item(BC_ListBoxItem *item, int expand)
{
        if(item)
        {
                item->expand = e