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