| /*************************************************************************** |
| * __________ __ ___. |
| * 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 "lcd.h" |
| #include "font.h" |
| #include "button.h" |
| #include "sprintf.h" |
| #include "string.h" |
| #include "settings.h" |
| #include "kernel.h" |
| #include "system.h" |
| |
| #include "action.h" |
| #include "screen_access.h" |
| #include "list.h" |
| #include "scrollbar.h" |
| #include "statusbar.h" |
| #include "lang.h" |
| #include "sound.h" |
| #include "misc.h" |
| #include "talk.h" |
| #include "viewport.h" |
| |
| #define SCROLLBAR_WIDTH 6 |
| #define ICON_PADDING 1 |
| |
| static struct viewport title_text[NB_SCREENS], title_icons[NB_SCREENS], |
| list_text[NB_SCREENS], list_icons[NB_SCREENS]; |
| |
| /* should probably be moved somewhere else */ |
| int list_title_height(struct gui_synclist *list, struct viewport *vp) |
| { |
| (void)list; |
| return font_get(vp->font)->height; |
| } |
| 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, struct viewport *vp); |
| |
| /* Draw the list... |
| internal screen layout: |
| ----------------- |
| |TI| title | TI is title icon |
| ----------------- |
| | | | | |
| |S|I| | S - scrollbar |
| | | | items | I - icons |
| | | | | |
| ------------------ |
| */ |
| static bool draw_title(struct screen *display, struct viewport *parent, |
| struct gui_synclist *list) |
| { |
| struct viewport *vp_icons = &title_icons[display->screen_type]; |
| struct viewport *vp_text = &title_text[display->screen_type]; |
| if (!list_display_title(list, parent)) |
| return false; |
| *vp_text = *parent; |
| vp_text->height = list_title_height(list, parent); |
| if (list->title_icon != Icon_NOICON && global_settings.show_icons) |
| { |
| *vp_icons = *vp_text; |
| vp_icons->width = get_icon_width(display->screen_type) |
| + ICON_PADDING*2; |
| vp_icons->x += ICON_PADDING; |
| |
| vp_text->width -= vp_icons->width + vp_icons->x; |
| vp_text->x += vp_icons->width + vp_icons->x; |
| |
| display->set_viewport(vp_icons); |
| screen_put_icon(display, 0, 0, list->title_icon); |
| } |
| display->set_viewport(vp_text); |
| vp_text->drawmode = STYLE_DEFAULT; |
| #ifdef HAVE_LCD_COLOR |
| if (list->title_color >= 0) |
| { |
| vp_text->drawmode |= (STYLE_COLORED|list->title_color);} |
| #endif |
| display->puts_scroll_style_offset(0, 0, list->title, |
| vp_text->drawmode, 0); |
| return true; |
| } |
| |
| void list_draw(struct screen *display, struct viewport *parent, |
| struct gui_synclist *list) |
| { |
| int start, end, line_height, i; |
| int icon_width = get_icon_width(display->screen_type) + ICON_PADDING; |
| bool show_cursor = !global_settings.cursor_style && |
| list->show_selection_marker; |
| #ifdef HAVE_LCD_COLOR |
| unsigned char cur_line = 0; |
| #endif |
| int item_offset; |
| bool show_title; |
| line_height = font_get(parent->font)->height; |
| display->set_viewport(parent); |
| display->clear_viewport(); |
| display->stop_scroll(); |
| list_text[display->screen_type] = *parent; |
| if ((show_title = draw_title(display, parent, list))) |
| { |
| list_text[display->screen_type].y += list_title_height(list, parent); |
| list_text[display->screen_type].height -= list_title_height(list, parent); |
| } |
| |
| start = list->start_item[display->screen_type]; |
| end = start + viewport_get_nb_lines(&list_text[display->screen_type]); |
| |
| /* draw the scrollbar if its needed */ |
| if (global_settings.scrollbar && |
| viewport_get_nb_lines(&list_text[display->screen_type]) < list->nb_items) |
| { |
| struct viewport vp; |
| vp = list_text[display->screen_type]; |
| vp.width = SCROLLBAR_WIDTH; |
| list_text[display->screen_type].width -= SCROLLBAR_WIDTH; |
| list_text[display->screen_type].x += SCROLLBAR_WIDTH; |
| vp.height = line_height * |
| viewport_get_nb_lines(&list_text[display->screen_type]); |
| vp.x = parent->x; |
| display->set_viewport(&vp); |
| gui_scrollbar_draw(display, 0, 0, SCROLLBAR_WIDTH-1, |
| vp.height, list->nb_items, |
| list->start_item[display->screen_type], |
| list->start_item[display->screen_type] + end-start, |
| VERTICAL); |
| } |
| else if (show_title) |
| { |
| /* shift everything right a bit... */ |
| list_text[display->screen_type].width -= SCROLLBAR_WIDTH; |
| list_text[display->screen_type].x += SCROLLBAR_WIDTH; |
| } |
| |
| /* setup icon placement */ |
| list_icons[display->screen_type] = list_text[display->screen_type]; |
| int icon_count = global_settings.show_icons && |
| (list->callback_get_item_icon != NULL) ? 1 : 0; |
| if (show_cursor) |
| icon_count++; |
| if (icon_count) |
| { |
| list_icons[display->screen_type].width = icon_width * icon_count; |
| list_text[display->screen_type].width -= |
| list_icons[display->screen_type].width + ICON_PADDING; |
| list_text[display->screen_type].x += |
| list_icons[display->screen_type].width + ICON_PADDING; |
| } |
| |
| for (i=start; i<end && i<list->nb_items; i++) |
| { |
| /* do the text */ |
| unsigned char *s; |
| char entry_buffer[MAX_PATH]; |
| unsigned char *entry_name; |
| int text_pos = 0; |
| s = list->callback_get_item_name(i, list->data, entry_buffer, |
| sizeof(entry_buffer)); |
| entry_name = P2STR(s); |
| display->set_viewport(&list_text[display->screen_type]); |
| list_text[display->screen_type].drawmode = STYLE_DEFAULT; |
| /* 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[display->screen_type]); |
| |
| #ifdef HAVE_LCD_COLOR |
| /* if the list has a color callback */ |
| if (list->callback_get_item_color) |
| { |
| int color = list->callback_get_item_color(i, list->data); |
| /* if color selected */ |
| if (color >= 0) |
| { |
| list_text[display->screen_type].drawmode |= STYLE_COLORED|color; |
| } |
| } |
| #endif |
| if(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 */ |
| list_text[display->screen_type].drawmode = STYLE_INVERT; |
| } |
| #ifdef HAVE_LCD_COLOR |
| else if (global_settings.cursor_style == 2) |
| { |
| /* Display colour line selector */ |
| list_text[display->screen_type].drawmode = STYLE_COLORBAR; |
| } |
| else if (global_settings.cursor_style == 3) |
| { |
| /* Display gradient line selector */ |
| list_text[display->screen_type].drawmode = STYLE_GRADIENT; |
| |
| /* Make the lcd driver know how many lines the gradient should |
| cover and current line number */ |
| /* number of selected lines */ |
| list_text[display->screen_type].drawmode |= NUMLN_PACK(list->selected_size); |
| /* current line number, zero based */ |
| list_text[display->screen_type].drawmode |= CURLN_PACK(cur_line); |
| cur_line++; |
| } |
| #endif |
| /* if the text is smaller than the viewport size */ |
| if (item_offset > item_width - (list_text[display->screen_type].width - text_pos)) |
| { |
| /* don't scroll */ |
| display->puts_style_offset(0, i-start, entry_name, |
| list_text[display->screen_type].drawmode, item_offset); |
| } |
| else |
| { |
| display->puts_scroll_style_offset(0, i-start, entry_name, |
| list_text[display->screen_type].drawmode, item_offset); |
| } |
| } |
| else |
| display->puts_style_offset(0, i-start, entry_name, |
| list_text[display->screen_type].drawmode, item_offset); |
| /* do the icon */ |
| if (list->callback_get_item_icon && global_settings.show_icons) |
| { |
| display->set_viewport(&list_icons[display->screen_type]); |
| screen_put_icon_with_offset(display, show_cursor?1:0, |
| (i-start),show_cursor?ICON_PADDING:0,0, |
| list->callback_get_item_icon(i, list->data)); |
| if (show_cursor && i >= list->selected_item && |
| i < list->selected_item + list->selected_size) |
| { |
| screen_put_icon(display, 0, i-start, Icon_Cursor); |
| } |
| } |
| else if (show_cursor && i >= list->selected_item && |
| i < list->selected_item + list->selected_size) |
| { |
| display->set_viewport(&list_icons[display->screen_type]); |
| screen_put_icon(display, 0, (i-start), Icon_Cursor); |
| } |
| } |
| |
| display->set_viewport(parent); |
| display->update_viewport(); |
| display->set_viewport(NULL); |
| } |
| |
| |
| #if defined(HAVE_TOUCHPAD) |
| /* This needs to be fixed if we ever get more than 1 touchscreen on a target. |
| * This also assumes the whole screen is used, which is a bad assumption but |
| * fine until customizable lists comes in... |
| */ |
| static bool scrolling=false; |
| |
| unsigned gui_synclist_do_touchpad(struct gui_synclist * gui_list, struct viewport *parent) |
| { |
| short x, y; |
| unsigned button = action_get_touchpad_press(&x, &y); |
| int line; |
| struct screen *display = &screens[SCREEN_MAIN]; |
| if (button == BUTTON_NONE) |
| return ACTION_NONE; |
| if (x<list_text[SCREEN_MAIN].x) |
| { |
| /* Top left corner is hopefully GO_TO_ROOT */ |
| if (y<list_text[SCREEN_MAIN].y) |
| { |
| if (button == BUTTON_REL) |
| return ACTION_STD_MENU; |
| else if (button == (BUTTON_REPEAT|BUTTON_REL)) |
| return ACTION_STD_CONTEXT; |
| else |
| return ACTION_NONE; |
| } |
| /* Scroll bar */ |
| else |
| { |
| int new_selection, nb_lines; |
| int height, size; |
| nb_lines = viewport_get_nb_lines(&list_text[SCREEN_MAIN]); |
| if (nb_lines < gui_list->nb_items) |
| { |
| height = nb_lines * font_get(parent->font)->height; |
| size = height / gui_list->nb_items; |
| new_selection = ((y-list_text[SCREEN_MAIN].y)*(gui_list->nb_items-nb_lines))/(height-size); |
| |
| if (new_selection - gui_list->start_item[SCREEN_MAIN] > (nb_lines/2)) |
| new_selection = gui_list->start_item[SCREEN_MAIN]+(nb_lines/2); |
| else if (new_selection > gui_list->nb_items-nb_lines) |
| new_selection = gui_list->nb_items-nb_lines; |
| |
| gui_synclist_select_item(gui_list, new_selection); |
| gui_list->start_item[SCREEN_MAIN] = new_selection; |
| return ACTION_REDRAW; |
| } |
| } |
| } |
| else |
| { |
| /* |--------------------------------------------------------| |
| * | Description of the touchscreen list interface: | |
| * |--------------------------------------------------------| |
| * | Pressing an item will select it and "enter" it. | |
| * | | |
| * | Pressing and holding your pen down will scroll through | |
| * | the list of items. | |
| * | | |
| * | Pressing and holding your pen down on a single item | |
| * | will bring up the context menu of it. | |
| * |--------------------------------------------------------| |
| */ |
| if (y > list_text[SCREEN_MAIN].y) |
| { |
| int line_height, actual_y; |
| |
| actual_y = y - list_text[SCREEN_MAIN].y; |
| line_height = font_get(parent->font)->height; |
| line = actual_y / line_height; |
| |
| if(actual_y%line_height == 0) /* Pressed a border */ |
| return ACTION_NONE; |
| |
| if (line != gui_list->selected_item - gui_list->start_item[SCREEN_MAIN] && button ^ BUTTON_REL) |
| { |
| if (gui_list->start_item[SCREEN_MAIN]+line > gui_list->nb_items) |
| return ACTION_NONE; |
| if(button & BUTTON_REPEAT) |
| scrolling = true; |
| gui_synclist_select_item(gui_list, gui_list->start_item[SCREEN_MAIN]+line); |
| return ACTION_REDRAW; |
| } |
| |
| if (button == (BUTTON_REPEAT|BUTTON_REL)) |
| { |
| if(!scrolling) |
| { |
| /* Pen was hold on the same line as the previously selected one |
| * => simulate long button press |
| */ |
| return ACTION_STD_CONTEXT; |
| } |
| else |
| { |
| /* Pen was moved across several lines and then released on this one |
| * => do nothing |
| */ |
| scrolling = false; |
| return ACTION_NONE; |
| } |
| } |
| else if(button == BUTTON_REL) |
| { |
| /* Pen was released on either the same line as the previously selected one |
| * or an other one |
| * => simulate short press |
| */ |
| return ACTION_STD_OK; |
| } |
| else |
| return ACTION_NONE; |
| } |
| /* Title goes up one level (only on BUTTON_REL&~BUTTON_REPEAT) */ |
| else if (y > title_text[SCREEN_MAIN].y && draw_title(display, parent, gui_list) && button == BUTTON_REL) |
| return ACTION_STD_CANCEL; |
| /* Title or statusbar is cancel (only on BUTTON_REL&~BUTTON_REPEAT) */ |
| else if (global_settings.statusbar && button == BUTTON_REL) |
| return ACTION_STD_CANCEL; |
| } |
| return ACTION_NONE; |
| } |
| #endif |