/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2007 by Jonathan Gordon * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ /* This file contains the code to draw the list widget on BITMAP LCDs. */ #include "config.h" #include "system.h" #include "lcd.h" #include "font.h" #include "button.h" #include "string.h" #include "settings.h" #include "kernel.h" #include "file.h" #include "action.h" #include "screen_access.h" #include "list.h" #include "scrollbar.h" #include "lang.h" #include "sound.h" #include "misc.h" #include "viewport.h" #include "statusbar-skinned.h" #include "debug.h" #include "line.h" #define ICON_PADDING 1 #define ICON_PADDING_S "1" /* these are static to make scrolling work */ static struct viewport list_text[NB_SCREENS], title_text[NB_SCREENS]; #ifdef HAVE_TOUCHSCREEN static int y_offset; static bool hide_selection; #endif /* list-private helpers from the generic list.c (move to header?) */ int gui_list_get_item_offset(struct gui_synclist * gui_list, int item_width, int text_pos, struct screen * display, struct viewport *vp); bool list_display_title(struct gui_synclist *list, enum screen_type screen); int list_get_nb_lines(struct gui_synclist *list, enum screen_type screen); void gui_synclist_scroll_stop(struct gui_synclist *lists) { FOR_NB_SCREENS(i) { screens[i].scroll_stop_viewport(&list_text[i]); screens[i].scroll_stop_viewport(&title_text[i]); screens[i].scroll_stop_viewport(lists->parent[i]); } } /* Draw the list... internal screen layout: ----------------- |TI| title | TI is title icon ----------------- | | | | |S|I| | S - scrollbar | | | items | I - icons | | | | ------------------ Note: This image is flipped horizontally when the language is a right-to-left one (Hebrew, Arabic) */ static int list_icon_width(enum screen_type screen) { return get_icon_width(screen) + ICON_PADDING * 2; } static bool draw_title(struct screen *display, struct gui_synclist *list) { const int screen = display->screen_type; struct viewport *title_text_vp = &title_text[screen]; struct line_desc line = LINE_DESC_DEFINIT; if (sb_set_title_text(list->title, list->title_icon, screen)) return false; /* the sbs is handling the title */ display->scroll_stop_viewport(title_text_vp); if (!list_display_title(list, screen)) return false; *title_text_vp = *(list->parent[screen]); line.height = list->line_height[screen]; title_text_vp->height = line.height; #if LCD_DEPTH > 1 /* XXX: Do we want to support the separator on remote displays? */ if (display->screen_type == SCREEN_MAIN && global_settings.list_separator_height != 0) line.separator_height = abs(global_settings.list_separator_height) + (lcd_get_dpi() > 200 ? 2 : 1); #endif #ifdef HAVE_LCD_COLOR if (list->title_color >= 0) line.style |= (STYLE_COLORED|list->title_color); #endif line.scroll = true; display->set_viewport(title_text_vp); if (list->title_icon != Icon_NOICON && global_settings.show_icons) put_line(display, 0, 0, &line, "$"ICON_PADDING_S"I$t", list->title_icon, list->title); else put_line(display, 0, 0, &line, "$t", list->title); return true; } void list_draw(struct screen *display, struct gui_synclist *list) { int start, end, item_offset, i; const int screen = display->screen_type; const int list_start_item = list->start_item[screen]; const bool scrollbar_in_left = (global_settings.scrollbar == SCROLLBAR_LEFT); const bool scrollbar_in_right = (global_settings.scrollbar == SCROLLBAR_RIGHT); const bool show_cursor = !global_settings.cursor_style && list->show_selection_marker; const bool have_icons = global_settings.show_icons && list->callback_get_item_icon; struct viewport *parent = (list->parent[screen]); struct line_desc linedes = LINE_DESC_DEFINIT; bool show_title; struct viewport *list_text_vp = &list_text[screen]; int indent = 0; display->set_viewport(parent); display->clear_viewport(); display->scroll_stop_viewport(list_text_vp); *list_text_vp = *parent; if ((show_title = draw_title(display, list))) { int title_height = title_text[screen].height; list_text_vp->y += title_height; list_text_vp->height -= title_height; } const int nb_lines = list_get_nb_lines(list, screen); linedes.height = list->line_height[screen]; linedes.nlines = list->selected_size; #if LCD_DEPTH > 1 /* XXX: Do we want to support the separator on remote displays? */ if (display->screen_type == SCREEN_MAIN) linedes.separator_height = abs(global_settings.list_separator_height); #endif start = list_start_item; end = start + nb_lines; #ifdef HAVE_TOUCHSCREEN if (list->selected_item == 0 || (list->nb_items < nb_lines)) y_offset = 0; /* reset in case it's a new list */ int draw_offset = y_offset; /* draw some extra items to not have empty lines at the top and bottom */ if (y_offset > 0) { /* make it negative for more consistent apparence when switching * directions */ draw_offset -= linedes.height; if (start > 0) start--; } else if (y_offset < 0) end++; #else #define draw_offset 0 #endif /* draw the scrollbar if its needed */ if (global_settings.scrollbar != SCROLLBAR_OFF) { /* if the scrollbar is shown the text viewport needs to shrink */ if (nb_lines < list->nb_items) { struct viewport vp = *list_text_vp; vp.width = SCROLLBAR_WIDTH; vp.height = linedes.height * nb_lines; list_text_vp->width -= SCROLLBAR_WIDTH; if (scrollbar_in_right) vp.x += list_text_vp->width; else /* left */ list_text_vp->x += SCROLLBAR_WIDTH; display->set_viewport(&vp); gui_scrollbar_draw(display, (scrollbar_in_left? 0: 1), 0, SCROLLBAR_WIDTH-1, vp.height, list->nb_items, list_start_item, list_start_item + nb_lines, VERTICAL); } /* shift everything a bit in relation to the title */ else if (!VP_IS_RTL(list_text_vp) && scrollbar_in_left) indent += SCROLLBAR_WIDTH; else if (VP_IS_RTL(list_text_vp) && scrollbar_in_right) indent += SCROLLBAR_WIDTH; } for (i=start; inb_items; i++) { /* do the text */ enum themable_icons icon; unsigned const char *s; char entry_buffer[MAX_PATH]; unsigned char *entry_name; int text_pos = 0; int line = i - start; int line_indent = 0; int style = STYLE_DEFAULT; bool is_selected = false; icon = list->callback_get_item_icon ? list->callback_get_item_icon(i, list->data) : Icon_NOICON; s = list->callback_get_item_name(i, list->data, entry_buffer, sizeof(entry_buffer)); entry_name = P2STR(s); while (*entry_name == '\t') { line_indent++; entry_name++; } if (line_indent) { if (global_settings.show_icons) line_indent *= list_icon_width(screen); else line_indent *= display->getcharwidth(); } line_indent += indent; display->set_viewport(list_text_vp); /* position the string at the correct offset place */ int item_width,h; display->getstringsize(entry_name, &item_width, &h); item_offset = gui_list_get_item_offset(list, item_width, text_pos, display, list_text_vp); /* draw the selected line */ if( #ifdef HAVE_TOUCHSCREEN /* don't draw it during scrolling */ !hide_selection && #endif i >= list->selected_item && i < list->selected_item + list->selected_size && list->show_selection_marker) {/* The selected item must be displayed scrolling */ if (global_settings.cursor_style == 1 #ifdef HAVE_REMOTE_LCD /* the global_settings.cursor_style check is here to make * sure if they want the cursor instead of bar it will work */ || (display->depth < 16 && global_settings.cursor_style) #endif ) { /* Display inverted-line-style */ style = STYLE_INVERT; } #ifdef HAVE_LCD_COLOR else if (global_settings.cursor_style == 2) { /* Display colour line selector */ style = STYLE_COLORBAR; linedes.text_color = global_settings.lst_color; linedes.line_color = global_settings.lss_color; } else if (global_settings.cursor_style == 3) { /* Display gradient line selector */ style = STYLE_GRADIENT; linedes.text_color = global_settings.lst_color; linedes.line_color = global_settings.lss_color; linedes.line_end_color = global_settings.lse_color; } #endif is_selected = true; } #ifdef HAVE_LCD_COLOR /* if the list has a color callback */ if (list->callback_get_item_color) { int c = list->callback_get_item_color(i, list->data); if (c >= 0) { /* if color selected */ linedes.text_color = c; style |= STYLE_COLORED; } } #endif linedes.style = style; linedes.scroll = is_selected ? true : list->scroll_all; linedes.line = i % list->selected_size; /* the list can have both, one of or neither of cursor and item icons, * if both don't apply icon padding twice between the icons */ if (show_cursor && have_icons) put_line(display, 0, line * linedes.height + draw_offset, &linedes, "$*s$"ICON_PADDING_S"I$i$"ICON_PADDING_S"s$*t", line_indent, is_selected ? Icon_Cursor : Icon_NOICON, icon, item_offset, entry_name); else if (show_cursor || have_icons) put_line(display, 0, line * linedes.height + draw_offset, &linedes, "$*s$"ICON_PADDING_S"I$*t", line_indent, show_cursor ? (is_selected ? Icon_Cursor:Icon_NOICON):icon, item_offset, entry_name); else put_line(display, 0, line * linedes.height + draw_offset, &linedes, "$*s$*t", line_indent, item_offset, entry_name); } display->set_viewport(parent); display->update_viewport(); display->set_viewport(NULL); } #if defined(HAVE_TOUCHSCREEN) /* This needs to be fixed if we ever get more than 1 touchscreen on a target. */ /* difference in pixels between draws, above it means enough to start scrolling */ #define SCROLL_BEGIN_THRESHOLD 3 static enum { SCROLL_NONE, /* no scrolling */ SCROLL_BAR, /* scroll by using the scrollbar */ SCROLL_SWIPE, /* scroll by wiping over the screen */ SCROLL_KINETIC, /* state after releasing swipe */ } scroll_mode; static int scrollbar_scroll(struct gui_synclist * gui_list, int y) { const int screen = screens[SCREEN_MAIN].screen_type; const int nb_lines = list_get_nb_lines(gui_list, screen); if (nb_lines < gui_list->nb_items) { /* scrollbar scrolling is still line based */ y_offset = 0; int scrollbar_size = nb_lines*gui_list->line_height[screen]; int actual_y = y - list_text[screen].y; int new_selection = (actual_y * gui_list->nb_items) / scrollbar_size; int start_item = new_selection - nb_lines/2; if(start_item < 0) start_item = 0; else if(start_item > gui_list->nb_items - nb_lines) start_item = gui_list->nb_items - nb_lines; gui_list->start_item[screen] = start_item; return ACTION_REDRAW; } return ACTION_NONE; } /* kinetic scrolling, based on * * v = a*t + v0 and ds = v*dt * * In each (fixed interval) timeout, the list is advanced by ds, then * the v is reduced by a. * This way we get a linear and smooth deceleration of the scrolling * * As v is the difference of distance per time unit, v is passed (as * pixels moved since the last call) to the scrolling function which takes * care of the pixel accurate drawing * * v0 is dertermined by averaging the last 4 movements of the list * (the pixel and time difference is used to compute each v) * * influenced by http://stechz.com/tag/kinetic/ * We take the easy and smooth first approach (until section "Drawbacks"), * since its drawbacks don't apply for us since our timers seem to be * relatively accurate */ #define SIGN(a) ((a) < 0 ? -1 : 1) /* these could possibly be configurable */ /* the lower the smoother */ #define RELOAD_INTERVAL (HZ/25) /* the higher the earler the list stops */ #define DECELERATION (1000*RELOAD_INTERVAL/HZ) /* this array holds data to compute the initial velocity v0 */ static struct kinetic_info { int difference; long ticks; } kinetic_data[4]; static size_t cur_idx; static struct cb_data { struct gui_synclist *list; /* current list */ int velocity; /* in pixel/s */ } cb_data; /* data member points to the above struct */ static struct timeout kinetic_tmo; static bool is_kinetic_over(void) { return !cb_data.velocity && (scroll_mode == SCROLL_KINETIC); } /* * collect data about how fast the list is moved in order to compute * the initial velocity from it later */ static void kinetic_stats_collect(const int difference) { static long last_tick; /* collect velocity statistics */ kinetic_data[cur_idx].difference = difference; kinetic_data[cur_idx].ticks = current_tick - last_tick; last_tick = current_tick; cur_idx += 1; if (cur_idx >= ARRAYLEN(kinetic_data)) cur_idx = 0; /* rewind the index */ } /* * resets the statistic */ static void kinetic_stats_reset(void) { memset(kinetic_data, 0, sizeof(kinetic_data)); cur_idx = 0; } /* cancels all currently active kinetic scrolling */ static void kinetic_force_stop(void) { timeout_cancel(&kinetic_tmo); kinetic_stats_reset(); } /* helper for gui/list.c to cancel scrolling if a normal button event comes * through dpad or keyboard or whatever */ void _gui_synclist_stop_kinetic_scrolling(void) { y_offset = 0; if (scroll_mode == SCROLL_KINETIC) kinetic_force_stop(); scroll_mode = SCROLL_NONE; hide_selection = false; } /* * returns false if scrolling should be stopped entirely * * otherwise it returns true even if it didn't actually scroll, * but scrolling mode shouldn't be changed **/ static int scroll_begin_threshold; static int threshold_accumulation; static bool swipe_scroll(struct gui_synclist * gui_list, int difference) { /* fixme */ const enum screen_type screen = screens[SCREEN_MAIN].screen_type; const int nb_lines = list_get_nb_lines(gui_list, screen); const int line_height = gui_list->line_height[screen]; if (UNLIKELY(scroll_begin_threshold == 0)) scroll_begin_threshold = touchscreen_get_scroll_threshold(); /* make selecting items easier */ threshold_accumulation += abs(difference); if (threshold_accumulation < scroll_begin_threshold && scroll_mode == SCROLL_NONE) return false; threshold_accumulation = 0; /* does the list even scroll? if no, return but still show * the caller that we would scroll */ if (nb_lines >= gui_list->nb_items) return true; const int old_start = gui_list->start_item[screen]; int new_start_item = -1; int line_diff = 0; /* don't scroll at the edges of the list */ if ((old_start == 0 && difference > 0) || (old_start == (gui_list->nb_items - nb_lines) && difference < 0)) { y_offset = 0; gui_list->start_item[screen] = old_start; return scroll_mode != SCROLL_KINETIC; /* stop kinetic at the edges */ } /* add up y_offset over time and translate to lines * if scrolled enough */ y_offset += difference; if (abs(y_offset) > line_height) { line_diff = y_offset/line_height; y_offset -= line_diff * line_height; } if(line_diff != 0) { int selection_offset = gui_list->selected_item - old_start; new_start_item = old_start - line_diff; /* check if new_start_item is bigger than list item count */ if(new_start_item > gui_list->nb_items - nb_lines) new_start_item = gui_list->nb_items - nb_lines; /* set new_start_item to 0 if it's negative */ if(new_start_item < 0) new_start_item = 0; gui_list->start_item[screen] = new_start_item; /* keep selected item in sync */ gui_list->selected_item = new_start_item + selection_offset; } return true; } static int kinetic_callback(struct timeout *tmo) { /* cancel if screen was pressed */ if (scroll_mode != SCROLL_KINETIC) return 0; struct cb_data *data = (struct cb_data*)tmo->data; /* ds = v*dt */ int pixel_diff = data->velocity * RELOAD_INTERVAL / HZ; /* remember signedness to detect stopping */ int old_sign = SIGN(data->velocity); /* advance the list */ if (!swipe_scroll(data->list, pixel_diff)) { /* nothing to scroll? */ data->velocity = 0; } else { /* decelerate by a fixed amount * decrementing v0 over time by the deceleration is * equivalent to computing v = a*t + v0 */ data->velocity -= SIGN(data->velocity)*DECELERATION; if (SIGN(data->velocity) != old_sign) data->velocity = 0; } /* let get_action() timeout, which loads to a * gui_synclist_draw() call from the main thread */ queue_post(&button_queue, BUTTON_REDRAW, 0); /* stop if the velocity hit or crossed zero */ if (!data->velocity) { kinetic_stats_reset(); return 0; } return RELOAD_INTERVAL; /* cancel or reload */ } /* * computes the initial velocity v0 and sets up the timer */ static bool kinetic_setup_scroll(struct gui_synclist *list) { /* compute initial velocity */ int i, _i, v0, len = ARRAYLEN(kinetic_data); for(i = 0, _i = 0, v0 = 0; i < len; i++) { /* in pixel/s */ if (kinetic_data[i].ticks > 0) { v0 += kinetic_data[i].difference*HZ/kinetic_data[i].ticks; _i++; } } if (_i > 0) v0 /= _i; else v0 = 0; if (v0 != 0) { cb_data.list = list; cb_data.velocity = v0; timeout_register(&kinetic_tmo, kinetic_callback, RELOAD_INTERVAL, (intptr_t)&cb_data); return true; } return false; } #define OUTSIDE 0 #define TITLE_TEXT (1<<0) #define TITLE_ICON (1<<1) #define SCROLLBAR (1<<2) #define LIST_TEXT (1<<3) #define LIST_ICON (1<<4) #define TITLE (TITLE_TEXT|TITLE_ICON) #define LIST (LIST_TEXT|LIST_ICON) static int get_click_location(struct gui_synclist *list, int x, int y) { int screen = SCREEN_MAIN; struct viewport *parent, *title, *text; int retval = OUTSIDE; parent = list->parent[screen]; if (viewport_point_within_vp(parent, x, y)) { /* see if the title was clicked */ title = &title_text[screen]; if (viewport_point_within_vp(title, x, y)) retval = TITLE_TEXT; /* check the icon too */ if (list->title_icon != Icon_NOICON && global_settings.show_icons) { int width = list_icon_width(screen); struct viewport vp = *title; if (VP_IS_RTL(&vp)) vp.x += vp.width; else vp.x -= width; vp.width = width; if (viewport_point_within_vp(&vp, x, y)) retval = TITLE_ICON; } /* check scrollbar. assume it's shown, if it isn't it will be handled * later */ if (retval == OUTSIDE) { bool on_scrollbar_clicked; int adj_x = x - parent->x; switch (global_settings.scrollbar) { case SCROLLBAR_LEFT: on_scrollbar_clicked = adj_x <= SCROLLBAR_WIDTH; break; case SCROLLBAR_RIGHT: on_scrollbar_clicked = adj_x > (title->x + title->width - SCROLLBAR_WIDTH); break; default: on_scrollbar_clicked = false; break; } if (on_scrollbar_clicked) retval = SCROLLBAR; } if (retval == OUTSIDE) { text = &list_text[screen]; if (viewport_point_within_vp(text, x, y)) retval = LIST_TEXT; else /* if all fails, it must be on the list icons */ retval = LIST_ICON; } } return retval; } unsigned gui_synclist_do_touchscreen(struct gui_synclist * list) { enum screen_type screen; struct viewport *parent; short x, y; int action, adj_x, adj_y, line, line_height, list_start_item; bool recurse; static bool initial_touch = true; static int last_y; screen = SCREEN_MAIN; parent = list->parent[screen]; line_height = list->line_height[screen]; list_start_item = list->start_item[screen]; /* start with getting the action code and finding the click location */ action = action_get_touchscreen_press(&x, &y); adj_x = x - parent->x; adj_y = y - parent->y; /* some defaults before running the state machine */ recurse = false; hide_selection = false; switch (scroll_mode) { case SCROLL_NONE: { int click_loc; if (initial_touch) { /* on the first touch last_y has to be reset to avoid * glitches with touches from long ago */ last_y = adj_y; initial_touch = false; } line = 0; /* silence gcc 'used uninitialized' warning */ click_loc = get_click_location(list, x, y); if (click_loc & LIST) { if(!skinlist_get_item(&screens[screen], list, adj_x, adj_y, &line)) { /* selection needs to be corrected if items are only partially visible */ line = (adj_y - y_offset) / line_height; if (list_display_title(list, screen)) line -= 1; /* adjust for the list title */ } if (line >= list->nb_items) return ACTION_NONE; list->selected_item = list_start_item+line; gui_synclist_speak_item(list); } if (action == BUTTON_TOUCHSCREEN) { /* if not scrolling, the user is trying to select */ int diff = adj_y - last_y; if ((click_loc & LIST) && swipe_scroll(list, diff)) scroll_mode = SCROLL_SWIPE; else if (click_loc & SCROLLBAR) scroll_mode = SCROLL_BAR; } else if (action == BUTTON_REPEAT) { if (click_loc & LIST) { /* held a single line for a while, bring up the context menu */ gui_synclist_select_item(list, list_start_item + line); /* don't sent context repeatedly */ action_wait_for_release(); initial_touch = true; return ACTION_STD_CONTEXT; } } else if (action & BUTTON_REL) { initial_touch = true; if (click_loc & LIST) { /* release on list item enters it */ gui_synclist_select_item(list, list_start_item + line); return ACTION_STD_OK; } else if (click_loc & TITLE_TEXT) { /* clicking the title goes one level up (cancel) */ return ACTION_STD_CANCEL; } else if (click_loc & TITLE_ICON) { /* clicking the title icon goes back to the root */ return ACTION_STD_MENU; } } break; } case SCROLL_SWIPE: { /* when swipe scrolling, we accept outside presses as well and * grab the entire screen (i.e. click_loc does not matter) */ int diff = adj_y - last_y; hide_selection = true; kinetic_stats_collect(diff); if (swipe_scroll(list, diff)) { /* letting the pen go enters kinetic scrolling */ if ((action & BUTTON_REL)) { if (kinetic_setup_scroll(list)) { hide_selection = true; scroll_mode = SCROLL_KINETIC; } else scroll_mode = SCROLL_NONE; } } else if (action & BUTTON_REL) scroll_mode = SCROLL_NONE; if (scroll_mode == SCROLL_NONE) initial_touch = true; break; } case SCROLL_KINETIC: { /* during kinetic scrolling we need to handle cancellation. * This state is actually only entered upon end of it as this * function is not called during the animation. */ if (!is_kinetic_over()) { /* a) the user touched the screen (manual cancellation) */ kinetic_force_stop(); if (get_click_location(list, x, y) & SCROLLBAR) scroll_mode = SCROLL_BAR; else scroll_mode = SCROLL_SWIPE; } else { /* b) kinetic scrolling stopped on its own */ /* need to re-run this with SCROLL_NONE since otherwise * the next touch is not detected correctly */ scroll_mode = SCROLL_NONE; recurse = true; } break; } case SCROLL_BAR: { hide_selection = true; /* similarly to swipe scroll, using the scrollbar grabs * focus so the click location is irrelevant */ scrollbar_scroll(list, adj_y); if (action & BUTTON_REL) scroll_mode = SCROLL_NONE; break; } } /* register y position unless forcefully reset */ if (!initial_touch) last_y = adj_y; return recurse ? gui_synclist_do_touchscreen(list) : ACTION_REDRAW; } #endif