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