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