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  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "config.h"
  21 #include "lcd.h"
  22 #include "font.h"
  23 #include "button.h"
  24 #include "sprintf.h"
  25 #include "string.h"
  26 #include "settings.h"
  27 #include "kernel.h"
  28 #include "system.h"
  29
  30 #include "action.h"
  31 #include "screen_access.h"
  32 #include "list.h"
  33 #include "scrollbar.h"
  34 #include "statusbar.h"
  35 #include "textarea.h"
  36 #include "lang.h"
  37 #include "sound.h"
  38 #include "misc.h"
  39
  40 #ifdef HAVE_LCD_CHARCELLS
  41 #define SCROLL_LIMIT 1
  42 #else
  43 #define SCROLL_LIMIT (nb_lines<3?1:2)
  44 #endif
  45
  46 /* The minimum number of pending button events in queue before starting
  47  * to limit list drawing interval.
  48  */
  49 #define FRAMEDROP_TRIGGER 6
  50
  51 #ifdef HAVE_LCD_BITMAP
  52 static int offset_step = 16; /* pixels per screen scroll step */
  53 /* should lines scroll out of the screen */
  54 static bool offset_out_of_view = false;
  55 #endif
  56 static struct gui_list* last_list_displayed[NB_SCREENS];
  57
  58 #define SHOW_LIST_TITLE ((gui_list->title != NULL) && \
  59                          (gui_list->display->nb_lines > 2))
  60
  61 static void gui_list_select_at_offset(struct gui_list * gui_list, int offset);
  62
  63 /*
  64  * Initializes a scrolling list
  65  *  - gui_list : the list structure to initialize
  66  *  - callback_get_item_name : pointer to a function that associates a label
  67  *    to a given item number
  68  *  - data : extra data passed to the list callback
  69  *  - scroll_all :
  70  *  - selected_size :
  71  */
  72 static void gui_list_init(struct gui_list * gui_list,
  73     list_get_name callback_get_item_name,
  74     void * data,
  75     bool scroll_all,
  76     int selected_size
  77     )
  78 {
  79     gui_list->callback_get_item_icon = NULL;
  80     gui_list->callback_get_item_name = callback_get_item_name;
  81     gui_list->display = NULL;
  82     gui_list_set_nb_items(gui_list, 0);
  83     gui_list->selected_item = 0;
  84     gui_list->start_item = 0;
  85     gui_list->limit_scroll = false;
  86     gui_list->data=data;
  87     gui_list->cursor_flash_state=false;
  88 #ifdef HAVE_LCD_BITMAP
  89     gui_list->offset_position = 0;
  90 #endif
  91     gui_list->scroll_all=scroll_all;
  92     gui_list->selected_size=selected_size;
  93     gui_list->title = NULL;
  94     gui_list->title_width = 0;
  95     gui_list->title_icon = Icon_NOICON;
  96
  97     gui_list->last_displayed_selected_item = -1 ;
  98     gui_list->last_displayed_start_item = -1 ;
  99     gui_list->show_selection_marker = true;
 100
 101 #ifdef HAVE_LCD_COLOR
 102     gui_list->title_color = -1;
 103     gui_list->callback_get_item_color = NULL;
 104 #endif
 105 }
 106
 107 /* this toggles the selection bar or cursor */
 108 void gui_synclist_hide_selection_marker(struct gui_synclist * lists, bool hide)
 109 {
 110     int i;
 111     FOR_NB_SCREENS(i)
 112         lists->gui_list[i].show_selection_marker = !hide;
 113 }
 114
 115 /*
 116  * Attach the scrolling list to a screen
 117  * (The previous screen attachement is lost)
 118  *  - gui_list : the list structure
 119  *  - display : the screen to attach
 120  */
 121 static void gui_list_set_display(struct gui_list * gui_list, struct screen * display)
 122 {
 123     if(gui_list->display != 0) /* we switched from a previous display */
 124         gui_list->display->stop_scroll();
 125     gui_list->display = display;
 126 #ifdef HAVE_LCD_CHARCELLS
 127     display->double_height(false);
 128 #endif
 129     gui_list_select_at_offset(gui_list, 0);
 130 }
 131
 132 /*
 133  * One call on 2, the selected lune will either blink the cursor or
 134  * invert/display normal the selected line
 135  * - gui_list : the list structure
 136  */
 137 static void gui_list_flash(struct gui_list * gui_list)
 138 {
 139     struct screen * display=gui_list->display;
 140     gui_list->cursor_flash_state=!gui_list->cursor_flash_state;
 141     int selected_line=gui_list->selected_item-gui_list->start_item+SHOW_LIST_TITLE;
 142 #ifdef HAVE_LCD_BITMAP
 143     int line_ypos=display->getymargin()+display->char_height*selected_line;
 144     if (global_settings.invert_cursor)
 145     {
 146         int line_xpos=display->getxmargin();
 147         display->set_drawmode(DRMODE_COMPLEMENT);
 148         display->fillrect(line_xpos, line_ypos, display->width,
 149                           display->char_height);
 150         display->set_drawmode(DRMODE_SOLID);
 151         display->invertscroll(0, selected_line);
 152     }
 153     else
 154     {
 155         int cursor_xpos=(global_settings.scrollbar &&
 156                          display->nb_lines < gui_list->nb_items)?1:0;
 157         screen_put_cursorxy(display, cursor_xpos, selected_line,
 158                             gui_list->cursor_flash_state);
 159     }
 160     display->update_rect(0, line_ypos,display->width,
 161                          display->char_height);
 162 #else
 163     screen_put_cursorxy(display, 0, selected_line,
 164                         gui_list->cursor_flash_state);
 165     gui_textarea_update(display);
 166 #endif
 167 }
 168
 169
 170 #ifdef HAVE_LCD_BITMAP
 171 static int gui_list_get_item_offset(struct gui_list * gui_list, int item_width,
 172                              int text_pos)
 173 {
 174     struct screen * display=gui_list->display;
 175     int item_offset;
 176
 177     if (offset_out_of_view)
 178     {
 179         item_offset = gui_list->offset_position;
 180     }
 181     else
 182     {
 183         /* if text is smaller then view */
 184         if (item_width <= display->width - text_pos)
 185         {
 186             item_offset = 0;
 187         }
 188         else
 189         {
 190             /* if text got out of view  */
 191             if (gui_list->offset_position >
 192                     item_width - (display->width - text_pos))
 193                 item_offset = item_width - (display->width - text_pos);
 194             else
 195                 item_offset = gui_list->offset_position;
 196         }
 197     }
 198
 199     return item_offset;
 200 }
 201 #endif
 202
 203 /*
 204  * Draws the list on the attached screen
 205  * - gui_list : the list structure
 206  */
 207 static void gui_list_draw_smart(struct gui_list *gui_list)
 208 {
 209     struct screen * display=gui_list->display;
 210     int text_pos;
 211     bool draw_icons = (gui_list->callback_get_item_icon != NULL && global_settings.show_icons);
 212     bool draw_cursor;
 213     int i;
 214     int lines;
 215     static int last_lines[NB_SCREENS] = {0};
 216 #ifdef HAVE_LCD_BITMAP
 217     int item_offset;
 218     int old_margin = display->getxmargin();
 219 #endif
 220     int start, end;
 221     bool partial_draw = false;
 222
 223 #ifdef HAVE_LCD_BITMAP
 224     display->setfont(FONT_UI);
 225     gui_textarea_update_nblines(display);
 226 #endif
 227     /* Speed up UI by drawing the changed contents only. */
 228     if (gui_list == last_list_displayed[gui_list->display->screen_type]
 229         && gui_list->last_displayed_start_item == gui_list->start_item
 230         && gui_list->selected_size == 1)
 231     {
 232         partial_draw = true;
 233     }
 234
 235     lines = display->nb_lines - SHOW_LIST_TITLE;
 236     if (last_lines[display->screen_type] != lines)
 237     {
 238         gui_list_select_at_offset(gui_list, 0);
 239         last_lines[display->screen_type] = lines;
 240     }
 241
 242     if (partial_draw)
 243     {
 244         end = gui_list->last_displayed_selected_item - gui_list->start_item;
 245         i = gui_list->selected_item - gui_list->start_item;
 246         if (i < end )
 247         {
 248             start = i;
 249             end++;
 250         }
 251         else
 252         {
 253             start = end;
 254             end = i + 1;
 255         }
 256     }
 257     else
 258     {
 259         gui_textarea_clear(display);
 260         start = 0;
 261         end = display->nb_lines;
 262         gui_list->last_displayed_start_item = gui_list->start_item;
 263         last_list_displayed[gui_list->display->screen_type] = gui_list;
 264     }
 265
 266     gui_list->last_displayed_selected_item = gui_list->selected_item;
 267
 268     /* position and draw the list title & icon */
 269     if (SHOW_LIST_TITLE && !partial_draw)
 270     {
 271         if (gui_list->title_icon != NOICON && draw_icons)
 272         {
 273             screen_put_icon(display, 0, 0, gui_list->title_icon);
 274 #ifdef HAVE_LCD_BITMAP
 275             text_pos = get_icon_width(display->screen_type)+2; /* pixels */
 276 #else
 277             text_pos = 1; /* chars */
 278 #endif
 279         }
 280         else
 281         {
 282             text_pos = 0;
 283         }
 284
 285 #ifdef HAVE_LCD_BITMAP
 286         int title_style = STYLE_DEFAULT;
 287 #ifdef HAVE_LCD_COLOR
 288         if (gui_list->title_color >= 0)
 289         {
 290             title_style |= STYLE_COLORED;
 291             title_style |= gui_list->title_color;
 292         }
 293 #endif
 294         screen_set_xmargin(display, text_pos); /* margin for title */
 295         item_offset = gui_list_get_item_offset(gui_list, gui_list->title_width,
 296                                                text_pos);
 297         if (item_offset > gui_list->title_width - (display->width - text_pos))
 298             display->puts_style_offset(0, 0, gui_list->title,
 299                                        title_style, item_offset);
 300         else
 301             display->puts_scroll_style_offset(0, 0, gui_list->title,
 302                                               title_style, item_offset);
 303 #else
 304         display->puts_scroll(text_pos, 0, gui_list->title);
 305 #endif
 306     }
 307
 308     /* Adjust the position of icon, cursor, text for the list */
 309 #ifdef HAVE_LCD_BITMAP
 310     gui_textarea_update_nblines(display);
 311     bool draw_scrollbar;
 312
 313     draw_scrollbar = (global_settings.scrollbar &&
 314                 lines < gui_list->nb_items);
 315
 316     draw_cursor = !global_settings.invert_cursor &&
 317                     gui_list->show_selection_marker;
 318     text_pos = 0; /* here it's in pixels */
 319     if(draw_scrollbar || SHOW_LIST_TITLE) /* indent if there's
 320                                              a title */
 321     {
 322         text_pos += SCROLLBAR_WIDTH;
 323     }
 324     if(draw_cursor)
 325         text_pos += get_icon_width(display->screen_type) + 2;
 326
 327     if(draw_icons)
 328         text_pos += get_icon_width(display->screen_type) + 2;
 329 #else
 330     draw_cursor = true;
 331     if(draw_icons)
 332         text_pos = 2; /* here it's in chars */
 333     else
 334         text_pos = 1;
 335 #endif
 336
 337 #ifdef HAVE_LCD_BITMAP
 338     screen_set_xmargin(display, text_pos); /* margin for list */
 339 #endif
 340
 341     if (SHOW_LIST_TITLE)
 342     {
 343         start++;
 344         if (end < display->nb_lines)
 345             end++;
 346     }
 347
 348     for (i = start; i < end; i++)
 349     {
 350         unsigned char *s;
 351         char entry_buffer[MAX_PATH];
 352         unsigned char *entry_name;
 353         int current_item = gui_list->start_item +
 354                            (SHOW_LIST_TITLE ? i-1 : i);
 355
 356         /* When there are less items to display than the
 357          * current available space on the screen, we stop*/
 358         if(current_item >= gui_list->nb_items)
 359             break;
 360         s = gui_list->callback_get_item_name(current_item,
 361                                              gui_list->data,
 362                                              entry_buffer);
 363         entry_name = P2STR(s);
 364
 365 #ifdef HAVE_LCD_BITMAP
 366         int style = STYLE_DEFAULT;
 367         /* position the string at the correct offset place */
 368         int item_width,h;
 369         display->getstringsize(entry_name, &item_width, &h);
 370         item_offset = gui_list_get_item_offset(gui_list, item_width, text_pos);
 371 #endif
 372
 373 #ifdef HAVE_LCD_COLOR
 374         /* if the list has a color callback */
 375         if (gui_list->callback_get_item_color)
 376         {
 377             int color = gui_list->callback_get_item_color(current_item,
 378                                                           gui_list->data);
 379             /* if color selected */
 380             if (color >= 0)
 381             {
 382                 style |= STYLE_COLORED;
 383                 style |= color;
 384             }
 385         }
 386 #endif
 387
 388         if(gui_list->show_selection_marker &&
 389            current_item >= gui_list->selected_item &&
 390            current_item <  gui_list->selected_item + gui_list->selected_size)
 391         {/* The selected item must be displayed scrolling */
 392 #ifdef HAVE_LCD_BITMAP
 393             if (global_settings.invert_cursor)/* Display inverted-line-style*/
 394             {
 395                 style |= STYLE_INVERT;
 396             }
 397             else  /*  if (!global_settings.invert_cursor) */
 398             {
 399                 if (current_item % gui_list->selected_size != 0)
 400                     draw_cursor = false;
 401             }
 402             /* if the text is smaller than the viewport size */
 403             if (item_offset > item_width - (display->width - text_pos))
 404             {
 405                 /* don't scroll */
 406                 display->puts_style_offset(0, i, entry_name,
 407                                            style, item_offset);
 408             }
 409             else
 410             {
 411                 display->puts_scroll_style_offset(0, i, entry_name,
 412                                                   style, item_offset);
 413             }
 414 #else
 415             display->puts_scroll(text_pos, i, entry_name);
 416 #endif
 417
 418             if (draw_cursor)
 419             {
 420                 screen_put_icon_with_offset(display, 0, i,
 421                                            (draw_scrollbar || SHOW_LIST_TITLE)?
 422                                                    SCROLLBAR_WIDTH: 0,
 423                                            0, Icon_Cursor);
 424             }
 425         }
 426         else
 427         {/* normal item */
 428             if(gui_list->scroll_all)
 429             {
 430 #ifdef HAVE_LCD_BITMAP
 431                 display->puts_scroll_style_offset(0, i, entry_name,
 432                                                   style, item_offset);
 433 #else
 434                 display->puts_scroll(text_pos, i, entry_name);
 435 #endif
 436             }
 437             else
 438             {
 439 #ifdef HAVE_LCD_BITMAP
 440                 display->puts_style_offset(0, i, entry_name,
 441                                            style, item_offset);
 442 #else
 443                 display->puts(text_pos, i, entry_name);
 444 #endif
 445             }
 446         }
 447         /* Icons display */
 448         if(draw_icons)
 449         {
 450             enum themable_icons icon;
 451             icon = gui_list->callback_get_item_icon(current_item, gui_list->data);
 452             if(icon > Icon_NOICON)
 453             {
 454 #ifdef HAVE_LCD_BITMAP
 455                 int x = draw_cursor?1:0;
 456                 int x_off = (draw_scrollbar || SHOW_LIST_TITLE) ? SCROLLBAR_WIDTH: 0;
 457                 screen_put_icon_with_offset(display, x, i,
 458                                            x_off, 0, icon);
 459 #else
 460                 screen_put_icon(display, 1, i, icon);
 461 #endif
 462             }
 463         }
 464     }
 465
 466 #ifdef HAVE_LCD_BITMAP
 467     /* Draw the scrollbar if needed*/
 468     if(draw_scrollbar)
 469     {
 470         int y_start = gui_textarea_get_ystart(display);
 471         if (SHOW_LIST_TITLE)
 472             y_start += display->char_height;
 473         int scrollbar_y_end = display->char_height *
 474                               lines + y_start;
 475         gui_scrollbar_draw(display, 0, y_start, SCROLLBAR_WIDTH-1,
 476                            scrollbar_y_end - y_start, gui_list->nb_items,
 477                            gui_list->start_item,
 478                            gui_list->start_item + lines, VERTICAL);
 479     }
 480
 481     screen_set_xmargin(display, old_margin);
 482 #endif
 483
 484     gui_textarea_update(display);
 485 }
 486
 487 /*
 488  * Force a full screen update.
 489  */
 490 static void gui_list_draw(struct gui_list *gui_list)
 491 {
 492     last_list_displayed[gui_list->display->screen_type] = NULL;
 493     return gui_list_draw_smart(gui_list);
 494 }
 495
 496 /*
 497  * Selects an item in the list
 498  *  - gui_list : the list structure
 499  *  - item_number : the number of the item which will be selected
 500  */
 501 static void gui_list_select_item(struct gui_list * gui_list, int item_number)
 502 {
 503     if( item_number > gui_list->nb_items-1 || item_number < 0 )
 504         return;
 505     gui_list->selected_item = item_number;
 506     gui_list_select_at_offset(gui_list, 0);
 507 }
 508
 509 /* select an item above the current one */
 510 static void gui_list_select_above(struct gui_list * gui_list,
 511                                   int items, int nb_lines)
 512 {
 513     gui_list->selected_item -= items;
 514
 515     /* in bottom "3rd" of the screen, so dont move the start item.
 516        by 3rd I mean above SCROLL_LIMIT lines above the end of the screen */
 517     if (items && gui_list->start_item + SCROLL_LIMIT < gui_list->selected_item)
 518     {
 519         if (gui_list->show_selection_marker == false)
 520         {
 521             gui_list->start_item -= items;
 522             if (gui_list->start_item < 0)
 523                 gui_list->start_item = 0;
 524         }
 525         return;
 526     }
 527     if (gui_list->selected_item < 0)
 528     {
 529         if(gui_list->limit_scroll)
 530         {
 531             gui_list->selected_item = 0;
 532             gui_list->start_item = 0;
 533         }
 534         else
 535         {
 536             gui_list->selected_item += gui_list->nb_items;
 537             if (global_settings.scroll_paginated)
 538             {
 539                 gui_list->start_item = gui_list->nb_items - nb_lines;
 540             }
 541         }
 542     }
 543     if (gui_list->nb_items > nb_lines)
 544     {
 545         if (global_settings.scroll_paginated)
 546         {
 547             if (gui_list->start_item > gui_list->selected_item)
 548                 gui_list->start_item = MAX(0, gui_list->start_item - nb_lines);
 549         }
 550         else
 551         {
 552             int top_of_screen = gui_list->selected_item - SCROLL_LIMIT;
 553             int temp = MIN(top_of_screen, gui_list->nb_items - nb_lines);
 554             gui_list->start_item = MAX(0, temp);
 555         }
 556     }
 557     else gui_list->start_item = 0;
 558     if (gui_list->selected_size > 1)
 559     {
 560         if (gui_list->start_item + nb_lines == gui_list->selected_item)
 561             gui_list->start_item++;
 562     }
 563 }
 564 /* select an item below the current one */
 565 static void gui_list_select_below(struct gui_list * gui_list,
 566                                   int items, int nb_lines)
 567 {
 568     int bottom;
 569
 570     gui_list->selected_item += items;
 571     bottom = gui_list->nb_items - nb_lines;
 572
 573     /* always move the screen if selection isnt "visible" */
 574     if (items && gui_list->show_selection_marker == false)
 575     {
 576         if (bottom < 0)
 577             bottom = 0;
 578         gui_list->start_item = MIN(bottom, gui_list->start_item +
 579                                            items);
 580         return;
 581     }
 582     /* in top "3rd" of the screen, so dont move the start item */
 583     if (items &&
 584         (gui_list->start_item + nb_lines - SCROLL_LIMIT > gui_list->selected_item)
 585         && (gui_list->selected_item < gui_list->nb_items))
 586     {
 587         if (gui_list->show_selection_marker == false)
 588         {
 589             if (bottom < 0)
 590                 bottom = 0;
 591             gui_list->start_item = MIN(bottom,
 592                                        gui_list->start_item + items);
 593         }
 594         return;
 595     }
 596
 597     if (gui_list->selected_item >= gui_list->nb_items)
 598     {
 599         if(gui_list->limit_scroll)
 600         {
 601             gui_list->selected_item = gui_list->nb_items-gui_list->selected_size;
 602             gui_list->start_item = MAX(0,gui_list->nb_items - nb_lines);
 603         }
 604         else
 605         {
 606             gui_list->selected_item = 0;
 607             gui_list->start_item = 0;
 608         }
 609         return;
 610     }
 611
 612     if (gui_list->nb_items > nb_lines)
 613     {
 614         if (global_settings.scroll_paginated)
 615         {
 616             if (gui_list->start_item + nb_lines <= gui_list->selected_item)
 617                 gui_list->start_item = MIN(bottom, gui_list->selected_item);
 618         }
 619         else
 620         {
 621             int top_of_screen = gui_list->selected_item + SCROLL_LIMIT - nb_lines;
 622             int temp = MAX(0, top_of_screen);
 623             gui_list->start_item = MIN(bottom, temp);
 624         }
 625     }
 626     else gui_list->start_item = 0;
 627 }
 628
 629 static void gui_list_select_at_offset(struct gui_list * gui_list, int offset)
 630 {
 631     /* do this here instead of in both select_above and select_below */
 632     int nb_lines = gui_list->display->nb_lines;
 633     if (SHOW_LIST_TITLE)
 634         nb_lines--;
 635
 636     if (gui_list->selected_size > 1)
 637     {
 638         offset *= gui_list->selected_size;
 639         /* always select the first item of multi-line lists */
 640         offset -= offset%gui_list->selected_size;
 641     }
 642     if (offset == 0 && global_settings.scroll_paginated &&
 643         (gui_list->nb_items > nb_lines))
 644     {
 645         int bottom = gui_list->nb_items - nb_lines;
 646         gui_list->start_item = MIN(gui_list->selected_item, bottom);
 647     }
 648     else if (offset < 0)
 649         gui_list_select_above(gui_list, -offset, nb_lines);
 650     else
 651         gui_list_select_below(gui_list, offset, nb_lines);
 652 }
 653
 654 /*
 655  * Adds an item to the list (the callback will be asked for one more item)
 656  * - gui_list : the list structure
 657  */
 658 static void gui_list_add_item(struct gui_list * gui_list)
 659 {
 660     gui_list->nb_items++;
 661     /* if only one item in the list, select it */
 662     if(gui_list->nb_items == 1)
 663         gui_list->selected_item = 0;
 664 }
 665
 666 /*
 667  * Removes an item to the list (the callback will be asked for one less item)
 668  * - gui_list : the list structure
 669  */
 670 static void gui_list_del_item(struct gui_list * gui_list)
 671 {
 672     if(gui_list->nb_items > 0)
 673     {
 674         gui_textarea_update_nblines(gui_list->display);
 675         int nb_lines = gui_list->display->nb_lines;
 676
 677         int dist_selected_from_end = gui_list->nb_items
 678             - gui_list->selected_item - 1;
 679         int dist_start_from_end = gui_list->nb_items
 680             - gui_list->start_item - 1;
 681         if(dist_selected_from_end == 0)
 682         {
 683             /* Oops we are removing the selected item,
 684                select the previous one */
 685             gui_list->selected_item--;
 686         }
 687         gui_list->nb_items--;
 688
 689         /* scroll the list if needed */
 690         if( (dist_start_from_end < nb_lines) && (gui_list->start_item != 0) )
 691             gui_list->start_item--;
 692     }
 693 }
 694
 695 #ifdef HAVE_LCD_BITMAP
 696
 697 /*
 698  * Makes all the item in the list scroll by one step to the right.
 699  * Should stop increasing the value when reaching the widest item value
 700  * in the list.
 701  */
 702 static void gui_list_scroll_right(struct gui_list * gui_list)
 703 {
 704     /* FIXME: This is a fake right boundry limiter. there should be some
 705      * callback function to find the longest item on the list in pixels,
 706      * to stop the list from scrolling past that point */
 707     gui_list->offset_position+=offset_step;
 708     if (gui_list->offset_position > 1000)
 709         gui_list->offset_position = 1000;
 710 }
 711
 712 /*
 713  * Makes all the item in the list scroll by one step to the left.
 714  * stops at starting position.
 715  */
 716 static void gui_list_scroll_left(struct gui_list * gui_list)
 717 {
 718     gui_list->offset_position-=offset_step;
 719     if (gui_list->offset_position < 0)
 720         gui_list->offset_position = 0;
 721 }
 722 void gui_list_screen_scroll_step(int ofs)
 723 {
 724      offset_step = ofs;
 725 }
 726
 727 void gui_list_screen_scroll_out_of_view(bool enable)
 728 {
 729     if (enable)
 730         offset_out_of_view = true;
 731     else
 732         offset_out_of_view = false;
 733 }
 734 #endif /* HAVE_LCD_BITMAP */
 735
 736 /*
 737  * Set the title and title icon of the list. Setting title to NULL disables
 738  * both the title and icon. Use NOICON if there is no icon.
 739  */
 740 static void gui_list_set_title(struct gui_list * gui_list,
 741                                char * title, enum themable_icons icon)
 742 {
 743     gui_list->title = title;
 744     gui_list->title_icon = icon;
 745     if (title) {
 746 #ifdef HAVE_LCD_BITMAP
 747         gui_list->display->getstringsize(title, &gui_list->title_width, NULL);
 748 #else
 749         gui_list->title_width = strlen(title);
 750 #endif
 751     } else {
 752         gui_list->title_width = 0;
 753     }
 754 }
 755
 756 /*
 757  * Synchronized lists stuffs
 758  */
 759 void gui_synclist_init(
 760     struct gui_synclist * lists,
 761     list_get_name callback_get_item_name,
 762     void * data,
 763     bool scroll_all,
 764     int selected_size
 765     )
 766 {
 767     int i;
 768     FOR_NB_SCREENS(i)
 769     {
 770         gui_list_init(&(lists->gui_list[i]),
 771                       callback_get_item_name,
 772                       data, scroll_all, selected_size);
 773         gui_list_set_display(&(lists->gui_list[i]), &(screens[i]));
 774     }
 775 }
 776
 777 void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items)
 778 {
 779     int i;
 780     FOR_NB_SCREENS(i)
 781     {
 782         gui_list_set_nb_items(&(lists->gui_list[i]), nb_items);
 783 #ifdef HAVE_LCD_BITMAP
 784         lists->gui_list[i].offset_position = 0;
 785 #endif
 786     }
 787 }
 788 int gui_synclist_get_nb_items(struct gui_synclist * lists)
 789 {
 790     return gui_list_get_nb_items(&((lists)->gui_list[0]));
 791 }
 792 int  gui_synclist_get_sel_pos(struct gui_synclist * lists)
 793 {
 794     return gui_list_get_sel_pos(&((lists)->gui_list[0]));
 795 }
 796 void gui_synclist_set_icon_callback(struct gui_synclist * lists,
 797                                     list_get_icon icon_callback)
 798 {
 799     int i;
 800     FOR_NB_SCREENS(i)
 801     {
 802         gui_list_set_icon_callback(&(lists->gui_list[i]), icon_callback);
 803     }
 804 }
 805
 806 void gui_synclist_draw(struct gui_synclist * lists)
 807 {
 808     int i;
 809     FOR_NB_SCREENS(i)
 810         gui_list_draw(&(lists->gui_list[i]));
 811 }
 812
 813 void gui_synclist_select_item(struct gui_synclist * lists, int item_number)
 814 {
 815     int i;
 816     FOR_NB_SCREENS(i)
 817         gui_list_select_item(&(lists->gui_list[i]), item_number);
 818 }
 819
 820 static void gui_synclist_select_next_page(struct gui_synclist * lists,
 821                                    enum screen_type screen)
 822 {
 823     int i;
 824     FOR_NB_SCREENS(i)
 825         gui_list_select_at_offset(&(lists->gui_list[i]),
 826                                   screens[screen].nb_lines);
 827 }
 828
 829 static void gui_synclist_select_previous_page(struct gui_synclist * lists,
 830                                        enum screen_type screen)
 831 {
 832     int i;
 833     FOR_NB_SCREENS(i)
 834         gui_list_select_at_offset(&(lists->gui_list[i]),
 835                                       -screens[screen].nb_lines);
 836 }
 837
 838 void gui_synclist_add_item(struct gui_synclist * lists)
 839 {
 840     int i;
 841     FOR_NB_SCREENS(i)
 842         gui_list_add_item(&(lists->gui_list[i]));
 843 }
 844
 845 void gui_synclist_del_item(struct gui_synclist * lists)
 846 {
 847     int i;
 848     FOR_NB_SCREENS(i)
 849         gui_list_del_item(&(lists->gui_list[i]));
 850 }
 851
 852 void gui_synclist_limit_scroll(struct gui_synclist * lists, bool scroll)
 853 {
 854     int i;
 855     FOR_NB_SCREENS(i)
 856         gui_list_limit_scroll(&(lists->gui_list[i]), scroll);
 857 }
 858
 859 void gui_synclist_set_title(struct gui_synclist * lists,
 860                             char * title, enum themable_icons icon)
 861 {
 862     int i;
 863     FOR_NB_SCREENS(i)
 864             gui_list_set_title(&(lists->gui_list[i]), title, icon);
 865 }
 866
 867 void gui_synclist_flash(struct gui_synclist * lists)
 868 {
 869     int i;
 870     FOR_NB_SCREENS(i)
 871         gui_list_flash(&(lists->gui_list[i]));
 872 }
 873
 874 #ifdef HAVE_LCD_BITMAP
 875 static void gui_synclist_scroll_right(struct gui_synclist * lists)
 876 {
 877     int i;
 878     FOR_NB_SCREENS(i)
 879         gui_list_scroll_right(&(lists->gui_list[i]));
 880 }
 881
 882 static void gui_synclist_scroll_left(struct gui_synclist * lists)
 883 {
 884     int i;
 885     FOR_NB_SCREENS(i)
 886         gui_list_scroll_left(&(lists->gui_list[i]));
 887 }
 888 #endif /* HAVE_LCD_BITMAP */
 889
 890 extern intptr_t get_action_data(void);
 891
 892 unsigned gui_synclist_do_button(struct gui_synclist * lists,
 893                                 unsigned button,enum list_wrap wrap)
 894 {
 895 #ifdef HAVE_LCD_BITMAP
 896     static bool scrolling_left = false;
 897 #endif
 898     int i;
 899
 900 #ifdef HAVE_SCROLLWHEEL
 901     int next_item_modifier = button_apply_acceleration(get_action_data(),
 902                                                        WHEEL_ACCELERATION_FACTOR);
 903 #else
 904     static int next_item_modifier = 1;
 905     static int last_accel_tick = 0;
 906
 907     if (global_settings.list_accel_start_delay)
 908     {
 909         int start_delay = global_settings.list_accel_start_delay * (HZ/2);
 910         int accel_wait = global_settings.list_accel_wait * HZ/2;
 911
 912         if (get_action_statuscode(NULL)&ACTION_REPEAT)
 913         {
 914             if (!last_accel_tick)
 915                 last_accel_tick = current_tick + start_delay;
 916             else if (current_tick >=
 917                         last_accel_tick + accel_wait)
 918             {
 919                 last_accel_tick = current_tick;
 920                 next_item_modifier++;
 921             }
 922         }
 923         else if (last_accel_tick)
 924         {
 925             next_item_modifier = 1;
 926             last_accel_tick = 0;
 927         }
 928     }
 929 #endif
 930
 931     switch (wrap)
 932     {
 933         case LIST_WRAP_ON:
 934             gui_synclist_limit_scroll(lists, false);
 935         break;
 936         case LIST_WRAP_OFF:
 937             gui_synclist_limit_scroll(lists, true);
 938         break;
 939         case LIST_WRAP_UNLESS_HELD:
 940             if (button == ACTION_STD_PREVREPEAT ||
 941                 button == ACTION_STD_NEXTREPEAT ||
 942                 button == ACTION_LISTTREE_PGUP  ||
 943                 button == ACTION_LISTTREE_PGDOWN)
 944                 gui_synclist_limit_scroll(lists, true);
 945             else gui_synclist_limit_scroll(lists, false);
 946         break;
 947     };
 948
 949     switch(button)
 950     {
 951 #ifdef HAVE_VOLUME_IN_LIST
 952         case ACTION_LIST_VOLUP:
 953             global_settings.volume += 2;
 954             /* up two because the falthrough brings it down one */
 955         case ACTION_LIST_VOLDOWN:
 956             global_settings.volume--;
 957             setvol();
 958             return button;
 959 #endif
 960         case ACTION_STD_PREV:
 961         case ACTION_STD_PREVREPEAT:
 962             FOR_NB_SCREENS(i)
 963                 gui_list_select_at_offset(&(lists->gui_list[i]), -next_item_modifier);
 964 #ifndef HAVE_SCROLLWHEEL
 965             if (queue_count(&button_queue) < FRAMEDROP_TRIGGER)
 966 #endif
 967             {
 968                 gui_synclist_draw(lists);
 969             }
 970             yield();
 971             return ACTION_STD_PREV;
 972
 973         case ACTION_STD_NEXT:
 974         case ACTION_STD_NEXTREPEAT:
 975             FOR_NB_SCREENS(i)
 976                 gui_list_select_at_offset(&(lists->gui_list[i]), next_item_modifier);
 977 #ifndef HAVE_SCROLLWHEEL
 978             if (queue_count(&button_queue) < FRAMEDROP_TRIGGER)
 979 #endif
 980             {
 981                 gui_synclist_draw(lists);
 982             }
 983             yield();
 984             return ACTION_STD_NEXT;
 985
 986 #ifdef HAVE_LCD_BITMAP
 987         case ACTION_TREE_ROOT_INIT:
 988          /* After this button press ACTION_TREE_PGLEFT is allowed
 989             to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
 990             keymaps as a repeated button press (the same as the repeated
 991             ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
 992             button press */
 993             if (lists->gui_list[0].offset_position == 0)
 994             {
 995                 scrolling_left = false;
 996                 return ACTION_STD_CANCEL;
 997             }
 998         case ACTION_TREE_PGRIGHT:
 999             gui_synclist_scroll_right(lists);
1000             gui_synclist_draw(lists);
1001             return ACTION_TREE_PGRIGHT;
1002         case ACTION_TREE_PGLEFT:
1003             if(!scrolling_left && (lists->gui_list[0].offset_position == 0))
1004                 return ACTION_STD_CANCEL;
1005             gui_synclist_scroll_left(lists);
1006             gui_synclist_draw(lists);
1007             scrolling_left = true; /* stop ACTION_TREE_PAGE_LEFT
1008                                       skipping to root */
1009             return ACTION_TREE_PGLEFT;
1010 #endif
1011
1012 /* for pgup / pgdown, we are obliged to have a different behaviour depending
1013  * on the screen for which the user pressed the key since for example, remote
1014  * and main screen doesn't have the same number of lines */
1015         case ACTION_LISTTREE_PGUP:
1016         {
1017             int screen =
1018 #ifdef HAVE_REMOTE_LCD
1019                 get_action_statuscode(NULL)&ACTION_REMOTE ?
1020                          SCREEN_REMOTE :
1021 #endif
1022                                           SCREEN_MAIN;
1023             gui_synclist_select_previous_page(lists, screen);
1024             gui_synclist_draw(lists);
1025             yield();
1026         }
1027         return ACTION_STD_NEXT;
1028
1029         case ACTION_LISTTREE_PGDOWN:
1030         {
1031             int screen =
1032 #ifdef HAVE_REMOTE_LCD
1033                 get_action_statuscode(NULL)&ACTION_REMOTE ?
1034                          SCREEN_REMOTE :
1035 #endif
1036                                           SCREEN_MAIN;
1037             gui_synclist_select_next_page(lists, screen);
1038             gui_synclist_draw(lists);
1039             yield();
1040         }
1041         return ACTION_STD_PREV;
1042     }
1043     return 0;
1044 }