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