apps/gui/list.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Kevin Ferrare
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "config.h"
  23 #include "lcd.h"
  24 #include "font.h"
  25 #include "button.h"
  26 #include "sprintf.h"
  27 #include "string.h"
  28 #include "settings.h"
  29 #include "kernel.h"
  30 #include "system.h"
  31
  32 #include "action.h"
  33 #include "screen_access.h"
  34 #include "list.h"
  35 #include "scrollbar.h"
  36 #include "lang.h"
  37 #include "sound.h"
  38 #include "misc.h"
  39 #include "talk.h"
  40 #include "viewport.h"
  41 #include "appevents.h"
  42 #include "statusbar-skinned.h"
  43
  44 /* The minimum number of pending button events in queue before starting
  45  * to limit list drawing interval.
  46  */
  47 #define FRAMEDROP_TRIGGER 6
  48
  49 #ifdef HAVE_LCD_BITMAP
  50 static int offset_step = 16; /* pixels per screen scroll step */
  51 /* should lines scroll out of the screen */
  52 static bool offset_out_of_view = false;
  53 #endif
  54
  55 static void gui_list_select_at_offset(struct gui_synclist * gui_list,
  56                                       int offset);
  57 void list_draw(struct screen *display, struct gui_synclist *list);
  58
  59 #ifdef HAVE_LCD_BITMAP
  60 static int list_need_reinit = false;
  61 static struct viewport parent[NB_SCREENS];
  62
  63 static void list_force_reinit(void *param)
  64 {
  65     (void)param;
  66     list_need_reinit = true;
  67 }
  68
  69 void list_init(void)
  70 {
  71     add_event(GUI_EVENT_THEME_CHANGED, false, list_force_reinit);
  72 }
  73
  74 static void list_init_viewports(struct gui_synclist *list)
  75 {
  76     int i, parent_used;
  77
  78     if (!list)
  79         return;
  80
  81     parent_used = (*list->parent != &parent[SCREEN_MAIN]);
  82
  83     if (!parent_used)
  84     {
  85         FOR_NB_SCREENS(i)
  86         {
  87             list->parent[i] = &parent[i];
  88             viewport_set_defaults(&parent[i], i);
  89 #ifdef HAVE_BUTTONBAR
  90             if (screens[i].has_buttonbar)
  91                 list->parent[i]->height -= BUTTONBAR_HEIGHT;
  92 #endif
  93         }
  94     }
  95     list_need_reinit = false;
  96 }
  97 #else
  98 static struct viewport parent[NB_SCREENS] =
  99 {
 100     [SCREEN_MAIN] =
 101     {
 102         .x        = 0,
 103         .y        = 0,
 104         .width    = LCD_WIDTH,
 105         .height   = LCD_HEIGHT
 106     },
 107 };
 108
 109 #define list_init_viewports(a)
 110 #endif
 111
 112 #ifdef HAVE_LCD_BITMAP
 113 bool list_display_title(struct gui_synclist *list, enum screen_type screen)
 114 {
 115     return list->title != NULL &&
 116         viewport_get_nb_lines(list->parent[screen]) > 2;
 117 }
 118
 119 static int list_get_nb_lines(struct gui_synclist *list, enum screen_type screen)
 120 {
 121     struct viewport vp = *list->parent[screen];
 122     if (list_display_title(list, screen))
 123         vp.height -= font_get(list->parent[screen]->font)->height;
 124     return viewport_get_nb_lines(&vp);
 125 }
 126 #else
 127 #define list_display_title(l, i) false
 128 #define list_get_nb_lines(list, screen) \
 129             viewport_get_nb_lines((list)->parent[(screen)]);
 130 #endif
 131
 132 /*
 133  * Initializes a scrolling list
 134  *  - gui_list : the list structure to initialize
 135  *  - callback_get_item_name : pointer to a function that associates a label
 136  *    to a given item number
 137  *  - data : extra data passed to the list callback
 138  *  - scroll_all :
 139  *  - selected_size :
 140  *  - parent : the parent viewports to use. NULL means the full screen minus
 141  *             statusbar if enabled. NOTE: new screens should NOT set this to NULL.
 142  */
 143 void gui_synclist_init(struct gui_synclist * gui_list,
 144     list_get_name callback_get_item_name,
 145     void * data,
 146     bool scroll_all,
 147     int selected_size, struct viewport list_parent[NB_SCREENS]
 148     )
 149 {
 150     int i;
 151     gui_list->callback_get_item_icon = NULL;
 152     gui_list->callback_get_item_name = callback_get_item_name;
 153     gui_list->callback_speak_item = NULL;
 154     gui_list->nb_items = 0;
 155     gui_list->selected_item = 0;
 156     FOR_NB_SCREENS(i)
 157     {
 158         gui_list->start_item[i] = 0;
 159 #ifdef HAVE_LCD_BITMAP
 160         gui_list->offset_position[i] = 0;
 161 #endif
 162         if (list_parent)
 163             gui_list->parent[i] = &list_parent[i];
 164         else
 165             gui_list->parent[i] = &parent[i];
 166     }
 167     list_init_viewports(gui_list);
 168     gui_list->limit_scroll = false;
 169     gui_list->data = data;
 170     gui_list->scroll_all = scroll_all;
 171     gui_list->selected_size = selected_size;
 172     gui_list->title = NULL;
 173     gui_list->title_icon = Icon_NOICON;
 174
 175     gui_list->scheduled_talk_tick = gui_list->last_talked_tick = 0;
 176     gui_list->show_selection_marker = true;
 177
 178 #ifdef HAVE_LCD_COLOR
 179     gui_list->title_color = -1;
 180     gui_list->callback_get_item_color = NULL;
 181 #endif
 182 }
 183
 184 /* this toggles the selection bar or cursor */
 185 void gui_synclist_hide_selection_marker(struct gui_synclist * lists, bool hide)
 186 {
 187     lists->show_selection_marker = !hide;
 188 }
 189
 190
 191 #ifdef HAVE_LCD_BITMAP
 192 int gui_list_get_item_offset(struct gui_synclist * gui_list,
 193                             int item_width,
 194                             int text_pos,
 195                             struct screen * display,
 196                             struct viewport *vp)
 197 {
 198     int item_offset;
 199
 200     if (offset_out_of_view)
 201     {
 202         item_offset = gui_list->offset_position[display->screen_type];
 203     }
 204     else
 205     {
 206         /* if text is smaller than view */
 207         if (item_width <= vp->width - text_pos)
 208         {
 209             item_offset = 0;
 210         }
 211         /* if text got out of view  */
 212         else if (gui_list->offset_position[display->screen_type] >
 213                     item_width - (vp->width - text_pos))
 214         {
 215             item_offset = item_width - (vp->width - text_pos);
 216         }
 217         else
 218             item_offset = gui_list->offset_position[display->screen_type];
 219     }
 220
 221     return item_offset;
 222 }
 223 #endif
 224
 225 /*
 226  * Force a full screen update.
 227  */
 228 void gui_synclist_draw(struct gui_synclist *gui_list)
 229 {
 230     int i;
 231 #ifdef HAVE_LCD_BITMAP
 232     if (list_need_reinit)
 233     {
 234         list_init_viewports(gui_list);
 235         gui_synclist_select_item(gui_list, gui_list->selected_item);
 236     }
 237 #endif
 238     FOR_NB_SCREENS(i)
 239     {
 240         list_draw(&screens[i], gui_list);
 241     }
 242 }
 243
 244 /* sets up the list so the selection is shown correctly on the screen */
 245 static void gui_list_put_selection_on_screen(struct gui_synclist * gui_list,
 246                                              enum screen_type screen)
 247 {
 248     int nb_lines = list_get_nb_lines(gui_list, screen);
 249     int bottom = MAX(0, gui_list->nb_items - nb_lines);
 250     int new_start_item = gui_list->start_item[screen];
 251     int difference = gui_list->selected_item - gui_list->start_item[screen];
 252 #ifdef HAVE_LCD_CHARCELLS
 253     const int scroll_limit_up   = 0;
 254     const int scroll_limit_down = 1;
 255 #else
 256     const int scroll_limit_up   = (nb_lines < gui_list->selected_size+2 ? 0:1);
 257     const int scroll_limit_down = (scroll_limit_up+gui_list->selected_size);
 258 #endif
 259
 260     if (gui_list->show_selection_marker == false)
 261     {
 262         new_start_item = gui_list->selected_item;
 263     }
 264     else if (gui_list->selected_size >= nb_lines)
 265     {
 266         new_start_item = gui_list->selected_item;
 267     }
 268     else if (global_settings.scroll_paginated)
 269     {
 270         nb_lines -= nb_lines%gui_list->selected_size;
 271         if (difference < 0 || difference >= nb_lines)
 272         {
 273             new_start_item = gui_list->selected_item -
 274                                 (gui_list->selected_item%nb_lines);
 275         }
 276     }
 277     else if (difference <= scroll_limit_up) /* list moved up */
 278     {
 279         new_start_item = gui_list->selected_item - scroll_limit_up;
 280     }
 281     else if (difference > nb_lines - scroll_limit_down) /* list moved down */
 282     {
 283         new_start_item = gui_list->selected_item + scroll_limit_down - nb_lines;
 284     }
 285     if (new_start_item < 0)
 286         gui_list->start_item[screen] = 0;
 287     else if (new_start_item > bottom)
 288         gui_list->start_item[screen] = bottom;
 289     else
 290         gui_list->start_item[screen] = new_start_item;
 291 }
 292
 293 /*
 294  * Selects an item in the list
 295  *  - gui_list : the list structure
 296  *  - item_number : the number of the item which will be selected
 297  */
 298 void gui_synclist_select_item(struct gui_synclist * gui_list, int item_number)
 299 {
 300     int i;
 301     if (item_number >= gui_list->nb_items || item_number < 0)
 302         return;
 303     gui_list->selected_item = item_number;
 304     FOR_NB_SCREENS(i)
 305         gui_list_put_selection_on_screen(gui_list, i);
 306 }
 307
 308 static void gui_list_select_at_offset(struct gui_synclist * gui_list,
 309                                       int offset)
 310 {
 311     int new_selection;
 312     if (gui_list->selected_size > 1)
 313     {
 314         offset *= gui_list->selected_size;
 315     }
 316
 317     new_selection = gui_list->selected_item + offset;
 318
 319     if (new_selection >= gui_list->nb_items)
 320     {
 321         gui_list->selected_item = gui_list->limit_scroll ?
 322             gui_list->nb_items - gui_list->selected_size : 0;
 323     }
 324     else if (new_selection < 0)
 325     {
 326         gui_list->selected_item = gui_list->limit_scroll ?
 327             0 : gui_list->nb_items - gui_list->selected_size;
 328     }
 329     else if (gui_list->show_selection_marker == false)
 330     {
 331         int i, nb_lines, screen_top;
 332         FOR_NB_SCREENS(i)
 333         {
 334             nb_lines = list_get_nb_lines(gui_list, i);
 335             if (offset > 0)
 336             {
 337                 screen_top = MAX(0, gui_list->nb_items - nb_lines);
 338                 gui_list->start_item[i] = MIN(screen_top, gui_list->start_item[i] +
 339                                                 gui_list->selected_size);
 340                 gui_list->selected_item = gui_list->start_item[i];
 341             }
 342             else
 343             {
 344                 gui_list->start_item[i] = MAX(0, gui_list->start_item[i] -
 345                                                     gui_list->selected_size);
 346                 gui_list->selected_item = gui_list->start_item[i] + nb_lines;
 347             }
 348         }
 349         return;
 350     }
 351     else gui_list->selected_item += offset;
 352     gui_synclist_select_item(gui_list, gui_list->selected_item);
 353 }
 354
 355 /*
 356  * Adds an item to the list (the callback will be asked for one more item)
 357  * - gui_list : the list structure
 358  */
 359 void gui_synclist_add_item(struct gui_synclist * gui_list)
 360 {
 361     gui_list->nb_items++;
 362     /* if only one item in the list, select it */
 363     if (gui_list->nb_items == 1)
 364         gui_list->selected_item = 0;
 365 }
 366
 367 /*
 368  * Removes an item to the list (the callback will be asked for one less item)
 369  * - gui_list : the list structure
 370  */
 371 void gui_synclist_del_item(struct gui_synclist * gui_list)
 372 {
 373     if (gui_list->nb_items > 0)
 374     {
 375         if (gui_list->selected_item == gui_list->nb_items-1)
 376             gui_list->selected_item--;
 377         gui_list->nb_items--;
 378         gui_synclist_select_item(gui_list, gui_list->selected_item);
 379     }
 380 }
 381
 382 #ifdef HAVE_LCD_BITMAP
 383 void gui_list_screen_scroll_step(int ofs)
 384 {
 385     offset_step = ofs;
 386 }
 387
 388 void gui_list_screen_scroll_out_of_view(bool enable)
 389 {
 390     offset_out_of_view = enable;
 391 }
 392 #endif /* HAVE_LCD_BITMAP */
 393
 394 /*
 395  * Set the title and title icon of the list. Setting title to NULL disables
 396  * both the title and icon. Use NOICON if there is no icon.
 397  */
 398 void gui_synclist_set_title(struct gui_synclist * gui_list,
 399                             char * title, enum themable_icons icon)
 400 {
 401     gui_list->title = title;
 402     gui_list->title_icon = icon;
 403 #ifdef HAVE_LCD_BITMAP
 404     int i;
 405     FOR_NB_SCREENS(i)
 406         sb_set_title_text(title, icon, i);
 407 #endif
 408     send_event(GUI_EVENT_ACTIONUPDATE, (void*)1);
 409 }
 410
 411 void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items)
 412 {
 413 #ifdef HAVE_LCD_BITMAP
 414     int i;
 415 #endif
 416     lists->nb_items = nb_items;
 417 #ifdef HAVE_LCD_BITMAP
 418     FOR_NB_SCREENS(i)
 419     {
 420         lists->offset_position[i] = 0;
 421     }
 422 #endif
 423 }
 424 int gui_synclist_get_nb_items(struct gui_synclist * lists)
 425 {
 426     return lists->nb_items;
 427 }
 428 int  gui_synclist_get_sel_pos(struct gui_synclist * lists)
 429 {
 430     return lists->selected_item;
 431 }
 432 void gui_synclist_set_icon_callback(struct gui_synclist * lists,
 433                                     list_get_icon icon_callback)
 434 {
 435     lists->callback_get_item_icon = icon_callback;
 436 }
 437
 438 void gui_synclist_set_voice_callback(struct gui_synclist * lists,
 439                                      list_speak_item voice_callback)
 440 {
 441     lists->callback_speak_item = voice_callback;
 442 }
 443
 444 #ifdef HAVE_LCD_COLOR
 445 void gui_synclist_set_color_callback(struct gui_synclist * lists,
 446                                      list_get_color color_callback)
 447 {
 448     lists->callback_get_item_color = color_callback;
 449 }
 450 #endif
 451
 452 static void gui_synclist_select_next_page(struct gui_synclist * lists,
 453                                           enum screen_type screen)
 454 {
 455     int nb_lines = list_get_nb_lines(lists, screen);
 456     if (lists->selected_size > 1)
 457         nb_lines = MAX(1, nb_lines/lists->selected_size);
 458     gui_list_select_at_offset(lists, nb_lines);
 459 }
 460
 461 static void gui_synclist_select_previous_page(struct gui_synclist * lists,
 462                                               enum screen_type screen)
 463 {
 464     int nb_lines = list_get_nb_lines(lists, screen);
 465     if (lists->selected_size > 1)
 466         nb_lines = MAX(1, nb_lines/lists->selected_size);
 467     gui_list_select_at_offset(lists, -nb_lines);
 468 }
 469
 470 void gui_synclist_limit_scroll(struct gui_synclist * lists, bool scroll)
 471 {
 472     lists->limit_scroll = scroll;
 473 }
 474
 475 #ifdef HAVE_LCD_BITMAP
 476 /*
 477  * Makes all the item in the list scroll by one step to the right.
 478  * Should stop increasing the value when reaching the widest item value
 479  * in the list.
 480  */
 481 static void gui_synclist_scroll_right(struct gui_synclist * lists)
 482 {
 483     int i;
 484     FOR_NB_SCREENS(i)
 485     {
 486         /* FIXME: This is a fake right boundry limiter. there should be some
 487         * callback function to find the longest item on the list in pixels,
 488         * to stop the list from scrolling past that point */
 489         lists->offset_position[i] += offset_step;
 490         if (lists->offset_position[i] > 1000)
 491             lists->offset_position[i] = 1000;
 492     }
 493 }
 494
 495 /*
 496  * Makes all the item in the list scroll by one step to the left.
 497  * stops at starting position.
 498  */
 499 static void gui_synclist_scroll_left(struct gui_synclist * lists)
 500 {
 501     int i;
 502     FOR_NB_SCREENS(i)
 503     {
 504         lists->offset_position[i] -= offset_step;
 505         if (lists->offset_position[i] < 0)
 506             lists->offset_position[i] = 0;
 507     }
 508 }
 509 #endif /* HAVE_LCD_BITMAP */
 510
 511 static void _gui_synclist_speak_item(struct gui_synclist *lists, bool repeating)
 512 {
 513     list_speak_item *cb = lists->callback_speak_item;
 514     if(cb && gui_synclist_get_nb_items(lists) != 0)
 515     {
 516         int sel = gui_synclist_get_sel_pos(lists);
 517         talk_shutup();
 518         /* If we got a repeating key action, or we have just very
 519            recently started talking, then we want to stay silent for a
 520            while until things settle. Likewise if we already had a
 521            pending scheduled announcement not yet due: we need to
 522            reschedule it. */
 523         if(repeating
 524            || (lists->scheduled_talk_tick
 525                && TIME_BEFORE(current_tick, lists->scheduled_talk_tick))
 526            || (lists->last_talked_tick
 527                && TIME_BEFORE(current_tick, lists->last_talked_tick +HZ/4)))
 528         {
 529             lists->scheduled_talk_tick = current_tick +HZ/4;
 530             return;
 531         } else {
 532             lists->scheduled_talk_tick = 0; /* work done */
 533             cb(sel, lists->data);
 534             lists->last_talked_tick = current_tick;
 535         }
 536     }
 537 }
 538 void gui_synclist_speak_item(struct gui_synclist * lists)
 539 /* The list user should call this to speak the first item on entering
 540    the list, and whenever the list is updated. */
 541 {
 542     if(gui_synclist_get_nb_items(lists) == 0 && global_settings.talk_menu)
 543         talk_id(VOICE_EMPTY_LIST, true);
 544     else _gui_synclist_speak_item(lists, false);
 545 }
 546
 547 bool gui_synclist_do_button(struct gui_synclist * lists,
 548                             int *actionptr, enum list_wrap wrap)
 549 {
 550     int action = *actionptr;
 551 #ifdef HAVE_LCD_BITMAP
 552     static bool scrolling_left = false;
 553 #endif
 554
 555 #ifdef HAVE_WHEEL_ACCELERATION
 556     int next_item_modifier = button_apply_acceleration(get_action_data());
 557 #else
 558     static int next_item_modifier = 1;
 559     static int last_accel_tick = 0;
 560     if (global_settings.list_accel_start_delay)
 561     {
 562         int start_delay = global_settings.list_accel_start_delay * (HZ/2);
 563         int accel_wait = global_settings.list_accel_wait * HZ/2;
 564
 565         if (get_action_statuscode(NULL)&ACTION_REPEAT)
 566         {
 567             if (!last_accel_tick)
 568                 last_accel_tick = current_tick + start_delay;
 569             else if (TIME_AFTER(current_tick, last_accel_tick + accel_wait))
 570             {
 571                 last_accel_tick = current_tick;
 572                 next_item_modifier++;
 573             }
 574         }
 575         else if (last_accel_tick)
 576         {
 577             next_item_modifier = 1;
 578             last_accel_tick = 0;
 579         }
 580     }
 581 #endif
 582
 583 #if defined(HAVE_TOUCHSCREEN)
 584     if (action == ACTION_TOUCHSCREEN)
 585         action = *actionptr = gui_synclist_do_touchscreen(lists);
 586 #endif
 587
 588     switch (wrap)
 589     {
 590         case LIST_WRAP_ON:
 591             gui_synclist_limit_scroll(lists, false);
 592         break;
 593         case LIST_WRAP_OFF:
 594             gui_synclist_limit_scroll(lists, true);
 595         break;
 596         case LIST_WRAP_UNLESS_HELD:
 597             if (action == ACTION_STD_PREVREPEAT ||
 598                 action == ACTION_STD_NEXTREPEAT ||
 599                 action == ACTION_LISTTREE_PGUP  ||
 600                 action == ACTION_LISTTREE_PGDOWN)
 601                 gui_synclist_limit_scroll(lists, true);
 602             else gui_synclist_limit_scroll(lists, false);
 603         break;
 604     };
 605
 606     switch (action)
 607     {
 608         case ACTION_REDRAW:
 609             gui_synclist_draw(lists);
 610             return true;
 611
 612 #ifdef HAVE_VOLUME_IN_LIST
 613         case ACTION_LIST_VOLUP:
 614             global_settings.volume += 2;
 615             /* up two because the falthrough brings it down one */
 616         case ACTION_LIST_VOLDOWN:
 617             global_settings.volume--;
 618             setvol();
 619             return true;
 620 #endif
 621         case ACTION_STD_PREV:
 622         case ACTION_STD_PREVREPEAT:
 623             gui_list_select_at_offset(lists, -next_item_modifier);
 624 #ifndef HAVE_WHEEL_ACCELERATION
 625             if (button_queue_count() < FRAMEDROP_TRIGGER)
 626 #endif
 627                 gui_synclist_draw(lists);
 628             _gui_synclist_speak_item(lists,
 629                                      action == ACTION_STD_PREVREPEAT
 630                                      || next_item_modifier > 1);
 631             yield();
 632             *actionptr = ACTION_STD_PREV;
 633             return true;
 634
 635         case ACTION_STD_NEXT:
 636         case ACTION_STD_NEXTREPEAT:
 637             gui_list_select_at_offset(lists, next_item_modifier);
 638 #ifndef HAVE_WHEEL_ACCELERATION
 639             if (button_queue_count() < FRAMEDROP_TRIGGER)
 640 #endif
 641                 gui_synclist_draw(lists);
 642             _gui_synclist_speak_item(lists,
 643                                      action == ACTION_STD_NEXTREPEAT
 644                                      || next_item_modifier >1);
 645             yield();
 646             *actionptr = ACTION_STD_NEXT;
 647             return true;
 648
 649 #ifdef HAVE_LCD_BITMAP
 650         case ACTION_TREE_PGRIGHT:
 651             gui_synclist_scroll_right(lists);
 652             gui_synclist_draw(lists);
 653             return true;
 654         case ACTION_TREE_ROOT_INIT:
 655          /* After this button press ACTION_TREE_PGLEFT is allowed
 656             to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
 657             keymaps as a repeated button press (the same as the repeated
 658             ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
 659             button press */
 660             if (lists->offset_position[0] == 0)
 661             {
 662                 scrolling_left = false;
 663                 *actionptr = ACTION_STD_CANCEL;
 664                 return true;
 665             }
 666             *actionptr = ACTION_TREE_PGLEFT;
 667         case ACTION_TREE_PGLEFT:
 668             if(!scrolling_left && (lists->offset_position[0] == 0))
 669             {
 670                 *actionptr = ACTION_STD_CANCEL;
 671                 return false;
 672             }
 673             gui_synclist_scroll_left(lists);
 674             gui_synclist_draw(lists);
 675             scrolling_left = true; /* stop ACTION_TREE_PAGE_LEFT
 676                                       skipping to root */
 677             return true;
 678 #endif
 679 /* for pgup / pgdown, we are obliged to have a different behaviour depending
 680  * on the screen for which the user pressed the key since for example, remote
 681  * and main screen doesn't have the same number of lines */
 682         case ACTION_LISTTREE_PGUP:
 683         {
 684             int screen =
 685 #ifdef HAVE_REMOTE_LCD
 686                 get_action_statuscode(NULL)&ACTION_REMOTE ?
 687                          SCREEN_REMOTE :
 688 #endif
 689                                           SCREEN_MAIN;
 690             gui_synclist_select_previous_page(lists, screen);
 691             gui_synclist_draw(lists);
 692             _gui_synclist_speak_item(lists, false);
 693             yield();
 694             *actionptr = ACTION_STD_NEXT;
 695         }
 696         return true;
 697
 698         case ACTION_LISTTREE_PGDOWN:
 699         {
 700             int screen =
 701 #ifdef HAVE_REMOTE_LCD
 702                 get_action_statuscode(NULL)&ACTION_REMOTE ?
 703                          SCREEN_REMOTE :
 704 #endif
 705                                           SCREEN_MAIN;
 706             gui_synclist_select_next_page(lists, screen);
 707             gui_synclist_draw(lists);
 708             _gui_synclist_speak_item(lists, false);
 709             yield();
 710             *actionptr = ACTION_STD_PREV;
 711         }
 712         return true;
 713     }
 714     if(lists->scheduled_talk_tick
 715        && TIME_AFTER(current_tick, lists->scheduled_talk_tick))
 716         /* scheduled postponed item announcement is due */
 717         _gui_synclist_speak_item(lists, false);
 718     return false;
 719 }
 720
 721 int list_do_action_timeout(struct gui_synclist *lists, int timeout)
 722 /* Returns the lowest of timeout or the delay until a postponed
 723    scheduled announcement is due (if any). */
 724 {
 725     if(lists->scheduled_talk_tick)
 726     {
 727         long delay = lists->scheduled_talk_tick -current_tick +1;
 728         /* +1 because the trigger condition uses TIME_AFTER(), which
 729            is implemented as strictly greater than. */
 730         if(delay < 0)
 731             delay = 0;
 732         if(timeout > delay || timeout == TIMEOUT_BLOCK)
 733             timeout = delay;
 734     }
 735     return timeout;
 736 }
 737
 738 bool list_do_action(int context, int timeout,
 739                     struct gui_synclist *lists, int *action,
 740                     enum list_wrap wrap)
 741 /* Combines the get_action() (with possibly overridden timeout) and
 742    gui_synclist_do_button() calls. Returns the list action from
 743    do_button, and places the action from get_action in *action. */
 744 {
 745     timeout = list_do_action_timeout(lists, timeout);
 746     *action = get_action(context, timeout);
 747     return gui_synclist_do_button(lists, action, wrap);
 748 }
 749
 750 bool gui_synclist_item_is_onscreen(struct gui_synclist *lists,
 751                                    enum screen_type screen, int item)
 752 {
 753     int nb_lines = list_get_nb_lines(lists, screen);
 754     return (unsigned)(item - lists->start_item[screen]) < (unsigned) nb_lines;
 755 }
 756
 757 /* Simple use list implementation */
 758 static int simplelist_line_count = 0;
 759 static char simplelist_text[SIMPLELIST_MAX_LINES][SIMPLELIST_MAX_LINELENGTH];
 760 /* set the amount of lines shown in the list */
 761 void simplelist_set_line_count(int lines)
 762 {
 763     if (lines < 0)
 764         simplelist_line_count = 0;
 765     else if (lines >= SIMPLELIST_MAX_LINES)
 766         simplelist_line_count = SIMPLELIST_MAX_LINES;
 767     else
 768         simplelist_line_count = lines;
 769 }
 770 /* get the current amount of lines shown */
 771 int simplelist_get_line_count(void)
 772 {
 773     return simplelist_line_count;
 774 }
 775 /* add/edit a line in the list.
 776    if line_number > number of lines shown it adds the line,
 777    else it edits the line */
 778 void simplelist_addline(int line_number, const char *fmt, ...)
 779 {
 780     va_list ap;
 781
 782     if (line_number > simplelist_line_count)
 783     {
 784         if (simplelist_line_count < SIMPLELIST_MAX_LINES)
 785             line_number = simplelist_line_count++;
 786         else
 787             return;
 788     }
 789     va_start(ap, fmt);
 790     vsnprintf(simplelist_text[line_number], SIMPLELIST_MAX_LINELENGTH, fmt, ap);
 791     va_end(ap);
 792 }
 793
 794 static const char* simplelist_static_getname(int item,
 795                                              void * data,
 796                                              char *buffer,
 797                                              size_t buffer_len)
 798 {
 799     (void)data; (void)buffer; (void)buffer_len;
 800     return simplelist_text[item];
 801 }
 802
 803 bool simplelist_show_list(struct simplelist_info *info)
 804 {
 805     struct gui_synclist lists;
 806     int action, old_line_count = simplelist_line_count, i;
 807     const char* (*getname)(int item, void * data, char *buffer, size_t buffer_len);
 808     int wrap = LIST_WRAP_UNLESS_HELD;
 809     if (info->get_name)
 810         getname = info->get_name;
 811     else
 812         getname = simplelist_static_getname;
 813
 814     FOR_NB_SCREENS(i)
 815         viewportmanager_theme_enable(i, true, NULL);
 816
 817     gui_synclist_init(&lists, getname,  info->callback_data,
 818                       info->scroll_all, info->selection_size, NULL);
 819
 820     if (info->title)
 821         gui_synclist_set_title(&lists, info->title, NOICON);
 822     if (info->get_icon)
 823         gui_synclist_set_icon_callback(&lists, info->get_icon);
 824     if (info->get_talk)
 825         gui_synclist_set_voice_callback(&lists, info->get_talk);
 826
 827     if (info->hide_selection)
 828     {
 829         gui_synclist_hide_selection_marker(&lists, true);
 830         wrap = LIST_WRAP_OFF;
 831     }
 832
 833     if (info->action_callback)
 834         info->action_callback(ACTION_REDRAW, &lists);
 835
 836     if (info->get_name == NULL)
 837         gui_synclist_set_nb_items(&lists,
 838                 simplelist_line_count*info->selection_size);
 839     else
 840         gui_synclist_set_nb_items(&lists, info->count*info->selection_size);
 841
 842     gui_synclist_select_item(&lists, info->selection);
 843
 844     gui_synclist_draw(&lists);
 845     gui_synclist_speak_item(&lists);
 846
 847     while(1)
 848     {
 849         list_do_action(CONTEXT_STD, info->timeout,
 850                        &lists, &action, wrap);
 851
 852         /* We must yield in this case or no other thread can run */
 853         if (info->timeout == TIMEOUT_NOBLOCK)
 854             yield();
 855
 856         if (info->action_callback)
 857         {
 858             bool stdok = action==ACTION_STD_OK;
 859             action = info->action_callback(action, &lists);
 860             if (stdok && action == ACTION_STD_CANCEL)
 861             {
 862                 /* callback asked us to exit */
 863                 info->selection = gui_synclist_get_sel_pos(&lists);
 864                 break;
 865             }
 866
 867             if (info->get_name == NULL)
 868                 gui_synclist_set_nb_items(&lists,
 869                         simplelist_line_count*info->selection_size);
 870         }
 871         if (action == ACTION_STD_CANCEL)
 872         {
 873             info->selection = -1;
 874             break;
 875         }
 876         else if ((action == ACTION_REDRAW) ||
 877                  (old_line_count != simplelist_line_count))
 878         {
 879             if (info->get_name == NULL)
 880             {
 881                 gui_synclist_set_nb_items(&lists,
 882                         simplelist_line_count*info->selection_size);
 883             }
 884             gui_synclist_draw(&lists);
 885             old_line_count = simplelist_line_count;
 886         }
 887         else if(default_event_handler(action) == SYS_USB_CONNECTED)
 888             return true;
 889     }
 890     talk_shutup();
 891     FOR_NB_SCREENS(i)
 892         viewportmanager_theme_undo(i, false);
 893     return false;
 894 }
 895
 896 void simplelist_info_init(struct simplelist_info *info, char* title,
 897                           int count, void* data)
 898 {
 899     info->title = title;
 900     info->count = count;
 901     info->selection_size = 1;
 902     info->hide_selection = false;
 903     info->scroll_all = false;
 904     info->timeout = HZ/10;
 905     info->selection = 0;
 906     info->action_callback = NULL;
 907     info->get_icon = NULL;
 908     info->get_name = NULL;
 909     info->get_talk = NULL;
 910     info->callback_data = data;
 911 }