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