/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id: list.c 18338 2008-08-23 09:46:38Z mcuelenaere $
 *
 * Copyright (C) 2005 by Kevin Ferrare
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

#include "config.h"
#include "lcd.h"
#include "font.h"
#include "button.h"
#include "sprintf.h"
#include "string.h"
#include "settings.h"
#include "kernel.h"
#include "system.h"

#include "action.h"
#include "screen_access.h"
#include "list.h"
#include "scrollbar.h"
#include "statusbar.h"
#include "lang.h"
#include "sound.h"
#include "misc.h"
#include "talk.h"
#include "viewport.h"
#include "list.h"

#ifdef HAVE_LCD_CHARCELLS
#define SCROLL_LIMIT 1
#else
#define SCROLL_LIMIT (nb_lines<3?1:2)
#endif

/* The minimum number of pending button events in queue before starting
 * to limit list drawing interval.
 */
#define FRAMEDROP_TRIGGER 6

#ifdef HAVE_LCD_BITMAP
static int offset_step = 16; /* pixels per screen scroll step */
/* should lines scroll out of the screen */
static bool offset_out_of_view = false;
#endif
static int force_list_reinit = false;

static void gui_list_select_at_offset(struct gui_synclist * gui_list,
                                      int offset);
void list_draw(struct screen *display, struct viewport *parent, struct gui_synclist *list);

#ifdef HAVE_LCD_BITMAP
static struct viewport parent[NB_SCREENS];
void list_init_viewports(struct gui_synclist *list)
{
    int i;
    struct viewport *vp;
    FOR_NB_SCREENS(i)
    {
        vp = &parent[i];
        if (!list)
            viewport_set_defaults(vp, i);
        else if (list->parent[i] == vp)
        {
            viewport_set_defaults(vp, i);
            list->parent[i]->y = gui_statusbar_height();
            list->parent[i]->height = screens[i].lcdheight - list->parent[i]->y;
        }
    }
#ifdef HAVE_BUTTONBAR
    if (list && (list->parent[0] == &parent[0]) && global_settings.buttonbar)
        list->parent[0]->height -= BUTTONBAR_HEIGHT;
#endif
    force_list_reinit = false;
}
#else
static struct viewport parent[NB_SCREENS] =
{
    [SCREEN_MAIN] = 
    {
        .x        = 0,
        .y        = 0,
        .width    = LCD_WIDTH,
        .height   = LCD_HEIGHT
    },
};
void list_init_viewports(struct gui_synclist *list)
{
    (void)list;
}
#endif

#ifdef HAVE_LCD_BITMAP
bool list_display_title(struct gui_synclist *list, struct viewport *vp)
{
    return list->title != NULL && viewport_get_nb_lines(vp)>2;
}
#else
#define list_display_title(l,v) false
#endif

/*
 * Initializes a scrolling list
 *  - gui_list : the list structure to initialize
 *  - callback_get_item_name : pointer to a function that associates a label
 *    to a given item number
 *  - data : extra data passed to the list callback
 *  - scroll_all : 
 *  - selected_size : 
 *  - parent : the parent viewports to use. NULL means the full screen minus
 *             statusbar if enabled. NOTE: new screens should NOT set this to NULL.
 */
void gui_synclist_init(struct gui_synclist * gui_list,
    list_get_name callback_get_item_name,
    void * data,
    bool scroll_all,
    int selected_size, struct viewport list_parent[NB_SCREENS]
    )
{
    int i;
    gui_list->callback_get_item_icon = NULL;
    gui_list->callback_get_item_name = callback_get_item_name;
    gui_list->callback_speak_item = NULL;
    gui_list->nb_items = 0;
    gui_list->selected_item = 0;
    FOR_NB_SCREENS(i)
    {
        gui_list->start_item[i] = 0;
        gui_list->last_displayed_start_item[i] = -1 ;
#ifdef HAVE_LCD_BITMAP
        gui_list->offset_position[i] = 0;
#endif
        if (list_parent)
            gui_list->parent[i] = &list_parent[i];
        else
        {
            gui_list->parent[i] = &parent[i];
        }
    }
    list_init_viewports(gui_list);
    gui_list->limit_scroll = false;
    gui_list->data=data;
    gui_list->scroll_all=scroll_all;
    gui_list->selected_size=selected_size;
    gui_list->title = NULL;
    gui_list->title_width = 0;
    gui_list->title_icon = Icon_NOICON;

    gui_list->scheduled_talk_tick = gui_list->last_talked_tick = 0;
    gui_list->show_selection_marker = true;
    gui_list->last_displayed_selected_item = -1 ;

#ifdef HAVE_LCD_COLOR
    gui_list->title_color = -1;
    gui_list->callback_get_item_color = NULL;
#endif
    force_list_reinit = true;
}

/* this toggles the selection bar or cursor */
void gui_synclist_hide_selection_marker(struct gui_synclist * lists, bool hide)
{
    lists->show_selection_marker = !hide;
}


#ifdef HAVE_LCD_BITMAP
int list_title_height(struct gui_synclist *list, struct viewport *vp);

int gui_list_get_item_offset(struct gui_synclist * gui_list, int item_width,
                             int text_pos, struct screen * display, struct viewport *vp)
{
    int item_offset;

    if (offset_out_of_view)
    {
        item_offset = gui_list->offset_position[display->screen_type];
    }
    else
    {
        /* if text is smaller then view */
        if (item_width <= vp->width - text_pos)
        {
            item_offset = 0;
        }
        else
        {
            /* if text got out of view  */
            if (gui_list->offset_position[display->screen_type] >
                    item_width - (vp->width - text_pos))
                item_offset = item_width - (vp->width - text_pos);
            else
                item_offset = gui_list->offset_position[display->screen_type];
        }
    }

    return item_offset;
}
#endif
/*
 * Force a full screen update.
 */
 
void gui_synclist_draw(struct gui_synclist *gui_list)
{
    int i;
    static struct gui_synclist *last_list = NULL;
    static int last_count = -1;
#ifdef HAVE_BUTTONBAR
    static bool last_buttonbar = false;
#endif
    if (force_list_reinit ||
#ifdef HAVE_BUTTONBAR
        last_buttonbar != screens[SCREEN_MAIN].has_buttonbar ||
#endif
        last_list != gui_list ||
        gui_list->nb_items != last_count)
    {
        list_init_viewports(gui_list);
        force_list_reinit = false;
    }
#ifdef HAVE_BUTTONBAR
    last_buttonbar = screens[SCREEN_MAIN].has_buttonbar;
#endif
    last_count = gui_list->nb_items;
    last_list = gui_list;
    FOR_NB_SCREENS(i)
    {
        list_draw(&screens[i], gui_list->parent[i], gui_list);
    }
}

/* sets up the list so the selection is shown correctly on the screen */
static void gui_list_put_selection_on_screen(struct gui_synclist * gui_list,
                                             enum screen_type screen)
{
    int nb_lines;
    int difference = gui_list->selected_item - gui_list->start_item[screen];
    struct viewport vp = *gui_list->parent[screen];
#ifdef HAVE_LCD_BITMAP
    if (list_display_title(gui_list, gui_list->parent[screen]))
        vp.height -= list_title_height(gui_list,gui_list->parent[screen]);
#endif
    nb_lines = viewport_get_nb_lines(&vp);
    
    /* edge case,, selected last item */
    if (gui_list->selected_item == gui_list->nb_items -1)
    {
        gui_list->start_item[screen] = MAX(0, gui_list->nb_items - nb_lines);
    }
    /* selected first item */
    else if (gui_list->selected_item == 0)
    {
        gui_list->start_item[screen] = 0;
    }
    else if (difference < SCROLL_LIMIT) /* list moved up */
    {
        if (global_settings.scroll_paginated)
        {
            if (gui_list->start_item[screen] > gui_list->selected_item)
                gui_list->start_item[screen] = (gui_list->selected_item/nb_lines)*nb_lines;
            if (gui_list->nb_items <= nb_lines)
                gui_list->start_item[screen] = 0;
        }
        else
        {
            int top_of_screen = gui_list->selected_item - SCROLL_LIMIT + 1;
            int temp = MIN(top_of_screen, gui_list->nb_items - nb_lines);
            gui_list->start_item[screen] = MAX(0, temp);
        }
    }
    else if (difference > nb_lines - SCROLL_LIMIT) /* list moved down */
    {
        int bottom = gui_list->nb_items - nb_lines;
        /* always move the screen if selection isnt "visible" */
        if (gui_list->show_selection_marker == false)
        {
            if (bottom < 0)
                bottom = 0;
            gui_list->start_item[screen] = MIN(bottom, gui_list->start_item[screen] + 
                                                       2*gui_list->selected_size);
        }
        else if (global_settings.scroll_paginated)
        {
            if (gui_list->start_item[screen] + nb_lines <= gui_list->selected_item)
                gui_list->start_item[screen] = MIN(bottom, gui_list->selected_item);
        }
        else
        {
            int top_of_screen = gui_list->selected_item + SCROLL_LIMIT - nb_lines;
            int temp = MAX(0, top_of_screen);
            gui_list->start_item[screen] = MIN(bottom, temp);
        }
    }
}
/*
 * Selects an item in the list
 *  - gui_list : the list structure
 *  - item_number : the number of the item which will be selected
 */
void gui_synclist_select_item(struct gui_synclist * gui_list, int item_number)
{
    int i;
    if( item_number > gui_list->nb_items-1 || item_number < 0 )
        return;
    gui_list->selected_item = item_number;
    FOR_NB_SCREENS(i)
        gui_list_put_selection_on_screen(gui_list, i);
}

static void gui_list_select_at_offset(struct gui_synclist * gui_list,
                                      int offset)
{
    int new_selection;
    if (gui_list->selected_size > 1)
    {
        offset *= gui_list->selected_size;
        /* always select the first item of multi-line lists */
        offset -= offset%gui_list->selected_size;
    }
    new_selection = gui_list->selected_item + offset;
    if (new_selection >= gui_list->nb_items)
    {
        gui_list->selected_item = gui_list->limit_scroll ?
          gui_list->nb_items - gui_list->selected_size : 0;
    }
    else if (new_selection < 0)
    {
        gui_list->selected_item = gui_list->limit_scroll ?
          0 : gui_list->nb_items - gui_list->selected_size;
    }
    else if (gui_list->show_selection_marker == false)
    {
        /* NOTE: this part doesnt work as well as it used to, the problem is
                 we want to scroll the lists seperatly but we only have one
                 selected item now, I dont think this is such a big deal though  */
        int i, nb_lines, screen_top;
        FOR_NB_SCREENS(i)
        {
            struct viewport vp = *gui_list->parent[i];
#ifdef HAVE_LCD_BITMAP
            if (list_display_title(gui_list, gui_list->parent[i]))
                vp.height -= list_title_height(gui_list,gui_list->parent[i]);
#endif
            nb_lines = viewport_get_nb_lines(&vp);
            if (offset > 0)
            {
                screen_top = gui_list->nb_items-nb_lines;
                if (screen_top < 0)
                    screen_top = 0;
                gui_list->start_item[i] = MIN(screen_top, gui_list->start_item[i] + 
                                                          gui_list->selected_size);
            }
            else
            {
                gui_list->start_item[i] = MAX(0, gui_list->start_item[i] - 
                                                 gui_list->selected_size);
            }
        }
        return;
    }
    else gui_list->selected_item += offset;
    gui_synclist_select_item(gui_list, gui_list->selected_item);
}

/*
 * Adds an item to the list (the callback will be asked for one more item)
 * - gui_list : the list structure
 */
void gui_synclist_add_item(struct gui_synclist * gui_list)
{
    gui_list->nb_items++;
    /* if only one item in the list, select it */
    if(gui_list->nb_items == 1)
        gui_list->selected_item = 0;
}

/*
 * Removes an item to the list (the callback will be asked for one less item)
 * - gui_list : the list structure
 */
void gui_synclist_del_item(struct gui_synclist * gui_list)
{
    if(gui_list->nb_items > 0)
    {
        if (gui_list->selected_item == gui_list->nb_items-1)
            gui_list->selected_item--;
        gui_list->nb_items--;
        gui_synclist_select_item(gui_list, gui_list->selected_item);
    }
}

#ifdef HAVE_LCD_BITMAP
void gui_list_screen_scroll_step(int ofs)
{
     offset_step = ofs;
}

void gui_list_screen_scroll_out_of_view(bool enable)
{
    if (enable)
        offset_out_of_view = true;
    else
        offset_out_of_view = false;
}
#endif /* HAVE_LCD_BITMAP */

/* 
 * Set the title and title icon of the list. Setting title to NULL disables
 * both the title and icon. Use NOICON if there is no icon.
 */
void gui_synclist_set_title(struct gui_synclist * gui_list, 
                               char * title, enum themable_icons icon)
{
    gui_list->title = title;
    gui_list->title_icon = icon;
    if (title) {
#ifdef HAVE_LCD_BITMAP
        int i;
        FOR_NB_SCREENS(i)
            screens[i].getstringsize(title, &gui_list->title_width, NULL);
#else
        gui_list->title_width = strlen(title);
#endif
    } else {
        gui_list->title_width = 0;
    }
    force_list_reinit = true;
}


void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items)
{
#ifdef HAVE_LCD_BITMAP
    int i;
#endif
    lists->nb_items = nb_items;
#ifdef HAVE_LCD_BITMAP
    FOR_NB_SCREENS(i)
    {
        lists->offset_position[i] = 0;
    }
#endif
}
int gui_synclist_get_nb_items(struct gui_synclist * lists)
{
    return lists->nb_items;
}
int  gui_synclist_get_sel_pos(struct gui_synclist * lists)
{
    return lists->selected_item;
}
void gui_synclist_set_icon_callback(struct gui_synclist * lists,
                                    list_get_icon icon_callback)
{
    lists->callback_get_item_icon = icon_callback;
}

void gui_synclist_set_voice_callback(struct gui_synclist * lists,
                                    list_speak_item voice_callback)
{
    lists->callback_speak_item = voice_callback;
}

#ifdef HAVE_LCD_COLOR
void gui_synclist_set_color_callback(struct gui_synclist * lists,
                                    list_get_color color_callback)
{
    lists->callback_get_item_color = color_callback;
}
#endif

static void gui_synclist_select_next_page(struct gui_synclist * lists,
                                   enum screen_type screen)
{
    int nb_lines = viewport_get_nb_lines(lists->parent[screen]);
    gui_list_select_at_offset(lists, nb_lines);
}

static void gui_synclist_select_previous_page(struct gui_synclist * lists,
                                       enum screen_type screen)
{
    int nb_lines = viewport_get_nb_lines(lists->parent[screen]);
    gui_list_select_at_offset(lists, -nb_lines);
}

void gui_synclist_limit_scroll(struct gui_synclist * lists, bool scroll)
{
    lists->limit_scroll = scroll;
}

#ifdef HAVE_LCD_BITMAP
/*
 * Makes all the item in the list scroll by one step to the right.
 * Should stop increasing the value when reaching the widest item value 
 * in the list.
 */
static void gui_synclist_scroll_right(struct gui_synclist * lists)
{
    int i;
    FOR_NB_SCREENS(i)
    {
        /* FIXME: This is a fake right boundry limiter. there should be some
        * callback function to find the longest item on the list in pixels,
        * to stop the list from scrolling past that point */
        lists->offset_position[i]+=offset_step;
        if (lists->offset_position[i] > 1000)
            lists->offset_position[i] = 1000;
    }
}

/*
 * Makes all the item in the list scroll by one step to the left.
 * stops at starting position.
 */
static void gui_synclist_scroll_left(struct gui_synclist * lists)
{
    int i;
    FOR_NB_SCREENS(i)
    {
        lists->offset_position[i]-=offset_step;
        if (lists->offset_position[i] < 0)
            lists->offset_position[i] = 0;
    }
}
#endif /* HAVE_LCD_BITMAP */

static void _gui_synclist_speak_item(struct gui_synclist *lists, bool repeating)
{
    list_speak_item *cb = lists->callback_speak_item;
    if(cb && gui_synclist_get_nb_items(lists) != 0)
    {
        int sel = gui_synclist_get_sel_pos(lists);
        talk_shutup();
        /* If we got a repeating key action, or we have just very
           recently started talking, then we want to stay silent for a
           while until things settle. Likewise if we already had a
           pending scheduled announcement not yet due: we need to
           reschedule it. */
        if(repeating
           || (lists->scheduled_talk_tick
               && TIME_BEFORE(current_tick, lists->scheduled_talk_tick))
           || (lists->last_talked_tick
               && TIME_BEFORE(current_tick, lists->last_talked_tick +HZ/4)))
        {
            lists->scheduled_talk_tick = current_tick +HZ/4;
            return;
        } else {
            lists->scheduled_talk_tick = 0; /* work done */
            cb(sel, lists->data);
            lists->last_talked_tick = current_tick;
        }
    }
}
void gui_synclist_speak_item(struct gui_synclist * lists)
/* The list user should call this to speak the first item on entering
   the list, and whenever the list is updated. */
{
    if(gui_synclist_get_nb_items(lists) == 0 && global_settings.talk_menu)
        talk_id(VOICE_EMPTY_LIST, true);
    else _gui_synclist_speak_item(lists, false);
}

extern intptr_t get_action_data(void);
#if  defined(HAVE_TOUCHSCREEN)
/* this needs to be fixed if we ever get more than 1 touchscreen on a target */
unsigned gui_synclist_do_touchscreen(struct gui_synclist * gui_list, struct viewport *parent);
#endif

bool gui_synclist_do_button(struct gui_synclist * lists,
                            unsigned *actionptr, enum list_wrap wrap)
{
    int action = *actionptr;
#ifdef HAVE_LCD_BITMAP
    static bool scrolling_left = false;
#endif

#ifdef HAVE_SCROLLWHEEL
    int next_item_modifier = button_apply_acceleration(get_action_data());
#else
    static int next_item_modifier = 1;
    static int last_accel_tick = 0;

    if (global_settings.list_accel_start_delay)
    {
        int start_delay = global_settings.list_accel_start_delay * (HZ/2);
        int accel_wait = global_settings.list_accel_wait * HZ/2;

        if (get_action_statuscode(NULL)&ACTION_REPEAT)
        {
            if (!last_accel_tick)
                last_accel_tick = current_tick + start_delay;
            else if (current_tick >= 
                        last_accel_tick + accel_wait)
            {
                last_accel_tick = current_tick;
                next_item_modifier++;
            }
        }
        else if (last_accel_tick)
        {
            next_item_modifier = 1;
            last_accel_tick = 0;
        }
    }
#endif
    
#if defined(HAVE_TOUCHSCREEN)
    if (action == ACTION_TOUCHSCREEN)
        action = *actionptr = gui_synclist_do_touchscreen(lists, &parent[SCREEN_MAIN]);
#endif

    switch (wrap)
    {
        case LIST_WRAP_ON:
            gui_synclist_limit_scroll(lists, false);
        break;
        case LIST_WRAP_OFF:
            gui_synclist_limit_scroll(lists, true);
        break;
        case LIST_WRAP_UNLESS_HELD:
            if (action == ACTION_STD_PREVREPEAT ||
                action == ACTION_STD_NEXTREPEAT ||
                action == ACTION_LISTTREE_PGUP  ||
                action == ACTION_LISTTREE_PGDOWN)
                gui_synclist_limit_scroll(lists, true);
            else gui_synclist_limit_scroll(lists, false);
        break;
    };

    switch (action)
    {
        case ACTION_REDRAW:
            gui_synclist_draw(lists);
            return true;
            
#ifdef HAVE_VOLUME_IN_LIST
        case ACTION_LIST_VOLUP:
            global_settings.volume += 2; 
            /* up two because the falthrough brings it down one */
        case ACTION_LIST_VOLDOWN:
            global_settings.volume--;
            setvol();
            return true;
#endif
        case ACTION_STD_PREV:
        case ACTION_STD_PREVREPEAT:
                gui_list_select_at_offset(lists, -next_item_modifier);
#ifndef HAVE_SCROLLWHEEL
            if (button_queue_count() < FRAMEDROP_TRIGGER)
#endif
                gui_synclist_draw(lists);
            _gui_synclist_speak_item(lists,
                                     action == ACTION_STD_PREVREPEAT
                                     || next_item_modifier >1);
            yield();
            *actionptr = ACTION_STD_PREV;
            return true;

        case ACTION_STD_NEXT:
        case ACTION_STD_NEXTREPEAT:
                gui_list_select_at_offset(lists, next_item_modifier);
#ifndef HAVE_SCROLLWHEEL
            if (button_queue_count() < FRAMEDROP_TRIGGER)
#endif
                gui_synclist_draw(lists);
            _gui_synclist_speak_item(lists,
                                     action == ACTION_STD_NEXTREPEAT
                                     || next_item_modifier >1);
            yield();
            *actionptr = ACTION_STD_NEXT;
            return true;

#ifdef HAVE_LCD_BITMAP
        case ACTION_TREE_PGRIGHT:
            gui_synclist_scroll_right(lists);
            gui_synclist_draw(lists);
            return true;
        case ACTION_TREE_ROOT_INIT:
         /* After this button press ACTION_TREE_PGLEFT is allowed
            to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
            keymaps as a repeated button press (the same as the repeated
            ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
            button press */
            if (lists->offset_position[0] == 0)
            {
                scrolling_left = false;
                *actionptr = ACTION_STD_CANCEL;
                return true;
            }
            *actionptr = ACTION_TREE_PGLEFT;
        case ACTION_TREE_PGLEFT:
            if(!scrolling_left && (lists->offset_position[0] == 0))
            {
                *actionptr = ACTION_STD_CANCEL;
                return false;
            }
            gui_synclist_scroll_left(lists);
            gui_synclist_draw(lists);
            scrolling_left = true; /* stop ACTION_TREE_PAGE_LEFT
                                      skipping to root */
            return true;
#endif
/* for pgup / pgdown, we are obliged to have a different behaviour depending
 * on the screen for which the user pressed the key since for example, remote
 * and main screen doesn't have the same number of lines */
        case ACTION_LISTTREE_PGUP:
        {
            int screen =
#ifdef HAVE_REMOTE_LCD
                get_action_statuscode(NULL)&ACTION_REMOTE ?
                         SCREEN_REMOTE : 
#endif
                                          SCREEN_MAIN;
            gui_synclist_select_previous_page(lists, screen);
            gui_synclist_draw(lists);
            _gui_synclist_speak_item(lists, false);
            yield();
            *actionptr = ACTION_STD_NEXT;
        }
        return true;

        case ACTION_LISTTREE_PGDOWN:
        {
            int screen =
#ifdef HAVE_REMOTE_LCD
                get_action_statuscode(NULL)&ACTION_REMOTE ?
                         SCREEN_REMOTE : 
#endif
                                          SCREEN_MAIN;
            gui_synclist_select_next_page(lists, screen);
            gui_synclist_draw(lists);
            _gui_synclist_speak_item(lists, false);
            yield();
            *actionptr = ACTION_STD_PREV;
        }
        return true;
    }
    if(lists->scheduled_talk_tick
       && TIME_AFTER(current_tick, lists->scheduled_talk_tick))
        /* scheduled postponed item announcement is due */
        _gui_synclist_speak_item(lists, false);
    return false;
}

int list_do_action_timeout(struct gui_synclist *lists, int timeout)
/* Returns the lowest of timeout or the delay until a postponed
   scheduled announcement is due (if any). */
{
    if(lists->scheduled_talk_tick)
    {
        long delay = lists->scheduled_talk_tick -current_tick +1;
        /* +1 because the trigger condition uses TIME_AFTER(), which
           is implemented as strictly greater than. */
        if(delay < 0)
            delay = 0;
        if(timeout > delay || timeout == TIMEOUT_BLOCK)
            timeout = delay;
    }
    return timeout;
}

bool list_do_action(int context, int timeout,
                    struct gui_synclist *lists, int *action,
                    enum list_wrap wrap)
/* Combines the get_action() (with possibly overridden timeout) and
   gui_synclist_do_button() calls. Returns the list action from
   do_button, and places the action from get_action in *action. */
{
    timeout = list_do_action_timeout(lists, timeout);
    *action = get_action(context, timeout);
    return gui_synclist_do_button(lists, action, wrap);
}

bool gui_synclist_item_is_onscreen(struct gui_synclist *lists,
                                   enum screen_type screen, int item)
{
    struct viewport vp = *lists->parent[screen];
#ifdef HAVE_LCD_BITMAP
    if (list_display_title(lists, lists->parent[screen]))
        vp.height -= list_title_height(lists, lists->parent[screen]);
#endif
    return item <= (lists->start_item[screen] + viewport_get_nb_lines(&vp));
}

/* Simple use list implementation */
static int simplelist_line_count = 0;
static char simplelist_text[SIMPLELIST_MAX_LINES][SIMPLELIST_MAX_LINELENGTH];
/* set the amount of lines shown in the list */
void simplelist_set_line_count(int lines)
{
    if (lines < 0)
        simplelist_line_count = 0;
    else if (lines >= SIMPLELIST_MAX_LINES)
        simplelist_line_count = SIMPLELIST_MAX_LINES;
    else
        simplelist_line_count = lines;
}
/* get the current amount of lines shown */
int simplelist_get_line_count(void)
{
    return simplelist_line_count;
}
/* add/edit a line in the list.
   if line_number > number of lines shown it adds the line, else it edits the line */
void simplelist_addline(int line_number, const char *fmt, ...)
{
    va_list ap;

    if (line_number > simplelist_line_count)
    {
        if (simplelist_line_count < SIMPLELIST_MAX_LINES)
            line_number = simplelist_line_count++;
        else 
             return;
    }
    va_start(ap, fmt);
    vsnprintf(simplelist_text[line_number], SIMPLELIST_MAX_LINELENGTH, fmt, ap);
    va_end(ap);
}

static char* simplelist_static_getname(int item,
                                       void * data,
                                       char *buffer,
                                       size_t buffer_len)
{
    (void)data; (void)buffer; (void)buffer_len;
    return simplelist_text[item];
}

bool simplelist_show_list(struct simplelist_info *info)
{
    struct gui_synclist lists;
    struct viewport vp[NB_SCREENS];
    int action, old_line_count = simplelist_line_count,i;
    char* (*getname)(int item, void * data, char *buffer, size_t buffer_len);
    if (info->get_name)
        getname = info->get_name;
    else
        getname = simplelist_static_getname;
    FOR_NB_SCREENS(i)
    {
        viewport_set_defaults(&vp[i], i);
    }
    gui_synclist_init(&lists, getname,  info->callback_data, 
                      info->scroll_all, info->selection_size, vp);
    
    if (info->title)
        gui_synclist_set_title(&lists, info->title, NOICON);
    if (info->get_icon)
        gui_synclist_set_icon_callback(&lists, info->get_icon);
    if (info->get_talk)
        gui_synclist_set_voice_callback(&lists, info->get_talk);
    
    gui_synclist_hide_selection_marker(&lists, info->hide_selection);
    
    if (info->action_callback)
        info->action_callback(ACTION_REDRAW, &lists);

    if (info->get_name == NULL)
        gui_synclist_set_nb_items(&lists, simplelist_line_count*info->selection_size);
    else
        gui_synclist_set_nb_items(&lists, info->count*info->selection_size);
    
    gui_synclist_select_item(&lists, info->start_selection);
    
    gui_synclist_draw(&lists);
    gui_synclist_speak_item(&lists);

    while(1)
    {
        gui_syncstatusbar_draw(&statusbars, true);
        list_do_action(CONTEXT_STD, info->timeout,
                       &lists, &action, LIST_WRAP_UNLESS_HELD);

        /* We must yield in this case or no other thread can run */
        if (info->timeout == TIMEOUT_NOBLOCK)
            yield();

        if (info->action_callback)
        {
            action = info->action_callback(action, &lists);
            if (info->get_name == NULL)
                gui_synclist_set_nb_items(&lists, simplelist_line_count*info->selection_size);
        }
        if (action == ACTION_STD_CANCEL)
            break;
        else if ((action == ACTION_REDRAW) ||
                 (old_line_count != simplelist_line_count))
        {
            if (info->get_name == NULL)
                gui_synclist_set_nb_items(&lists, simplelist_line_count*info->selection_size);
            gui_synclist_draw(&lists);
            old_line_count = simplelist_line_count;
        }
        else if(default_event_handler(action) == SYS_USB_CONNECTED)
            return true;
    }
    talk_shutup();
    return false;
}

void simplelist_info_init(struct simplelist_info *info, char* title,
                          int count, void* data)
{
    info->title = title;
    info->count = count;
    info->selection_size = 1;
    info->hide_selection = false;
    info->scroll_all = false;
    info->timeout = HZ/10;
    info->start_selection = 0;
    info->action_callback = NULL;
    info->get_icon = NULL;
    info->get_name = NULL;
    info->get_talk = NULL;
    info->callback_data = data;
}







