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