1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2005 by Kevin Ferrare
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
34 #include "screen_access.h"
36 #include "scrollbar.h"
42 #include "appevents.h"
43 #include "statusbar-skinned.h"
45 /* The minimum number of pending button events in queue before starting
46 * to limit list drawing interval.
48 #define FRAMEDROP_TRIGGER 6
50 #ifdef HAVE_LCD_BITMAP
51 static int offset_step
= 16; /* pixels per screen scroll step */
52 /* should lines scroll out of the screen */
53 static bool offset_out_of_view
= false;
56 static void gui_list_select_at_offset(struct gui_synclist
* gui_list
,
58 void list_draw(struct screen
*display
, struct gui_synclist
*list
);
60 #ifdef HAVE_LCD_BITMAP
61 static int list_need_reinit
= false;
62 static struct viewport parent
[NB_SCREENS
];
64 static void list_force_reinit(void *param
)
67 list_need_reinit
= true;
72 add_event(GUI_EVENT_THEME_CHANGED
, false, list_force_reinit
);
75 static void list_init_viewports(struct gui_synclist
*list
)
82 parent_used
= (*list
->parent
!= &parent
[SCREEN_MAIN
]);
88 list
->parent
[i
] = &parent
[i
];
89 viewport_set_defaults(&parent
[i
], i
);
91 if (screens
[i
].has_buttonbar
)
92 list
->parent
[i
]->height
-= BUTTONBAR_HEIGHT
;
96 list_need_reinit
= false;
99 static struct viewport parent
[NB_SCREENS
] =
110 #define list_init_viewports(a)
113 #ifdef HAVE_LCD_BITMAP
114 bool list_display_title(struct gui_synclist
*list
, enum screen_type screen
)
116 return list
->title
!= NULL
&&
117 !sb_set_title_text(list
->title
, list
->title_icon
, screen
) &&
118 viewport_get_nb_lines(list
->parent
[screen
]) > 2;
121 static int list_get_nb_lines(struct gui_synclist
*list
, enum screen_type screen
)
123 struct viewport vp
= *list
->parent
[screen
];
124 if (list_display_title(list
, screen
))
125 vp
.height
-= font_get(list
->parent
[screen
]->font
)->height
;
126 return viewport_get_nb_lines(&vp
);
129 #define list_display_title(l, i) false
130 #define list_get_nb_lines(list, screen) \
131 viewport_get_nb_lines((list)->parent[(screen)]);
135 * Initializes a scrolling list
136 * - gui_list : the list structure to initialize
137 * - callback_get_item_name : pointer to a function that associates a label
138 * to a given item number
139 * - data : extra data passed to the list callback
142 * - parent : the parent viewports to use. NULL means the full screen minus
143 * statusbar if enabled. NOTE: new screens should NOT set this to NULL.
145 void gui_synclist_init(struct gui_synclist
* gui_list
,
146 list_get_name callback_get_item_name
,
149 int selected_size
, struct viewport list_parent
[NB_SCREENS
]
153 gui_list
->callback_get_item_icon
= NULL
;
154 gui_list
->callback_get_item_name
= callback_get_item_name
;
155 gui_list
->callback_speak_item
= NULL
;
156 gui_list
->nb_items
= 0;
157 gui_list
->selected_item
= 0;
160 gui_list
->start_item
[i
] = 0;
161 #ifdef HAVE_LCD_BITMAP
162 gui_list
->offset_position
[i
] = 0;
165 gui_list
->parent
[i
] = &list_parent
[i
];
167 gui_list
->parent
[i
] = &parent
[i
];
169 list_init_viewports(gui_list
);
170 gui_list
->limit_scroll
= false;
171 gui_list
->data
= data
;
172 gui_list
->scroll_all
= scroll_all
;
173 gui_list
->selected_size
= selected_size
;
174 gui_list
->title
= NULL
;
175 gui_list
->title_icon
= Icon_NOICON
;
177 gui_list
->scheduled_talk_tick
= gui_list
->last_talked_tick
= 0;
178 gui_list
->show_selection_marker
= true;
180 #ifdef HAVE_LCD_COLOR
181 gui_list
->title_color
= -1;
182 gui_list
->callback_get_item_color
= NULL
;
186 /* this toggles the selection bar or cursor */
187 void gui_synclist_hide_selection_marker(struct gui_synclist
* lists
, bool hide
)
189 lists
->show_selection_marker
= !hide
;
193 #ifdef HAVE_LCD_BITMAP
194 int gui_list_get_item_offset(struct gui_synclist
* gui_list
,
197 struct screen
* display
,
202 if (offset_out_of_view
)
204 item_offset
= gui_list
->offset_position
[display
->screen_type
];
208 /* if text is smaller than view */
209 if (item_width
<= vp
->width
- text_pos
)
213 /* if text got out of view */
214 else if (gui_list
->offset_position
[display
->screen_type
] >
215 item_width
- (vp
->width
- text_pos
))
217 item_offset
= item_width
- (vp
->width
- text_pos
);
220 item_offset
= gui_list
->offset_position
[display
->screen_type
];
228 * Force a full screen update.
230 void gui_synclist_draw(struct gui_synclist
*gui_list
)
233 #ifdef HAVE_LCD_BITMAP
234 if (list_need_reinit
)
236 list_init_viewports(gui_list
);
237 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
242 list_draw(&screens
[i
], gui_list
);
246 /* sets up the list so the selection is shown correctly on the screen */
247 static void gui_list_put_selection_on_screen(struct gui_synclist
* gui_list
,
248 enum screen_type screen
)
250 int nb_lines
= list_get_nb_lines(gui_list
, screen
);
251 int bottom
= MAX(0, gui_list
->nb_items
- nb_lines
);
252 int new_start_item
= gui_list
->start_item
[screen
];
253 int difference
= gui_list
->selected_item
- gui_list
->start_item
[screen
];
254 #ifdef HAVE_LCD_CHARCELLS
255 const int scroll_limit_up
= 0;
256 const int scroll_limit_down
= 1;
258 const int scroll_limit_up
= (nb_lines
< gui_list
->selected_size
+2 ? 0:1);
259 const int scroll_limit_down
= (scroll_limit_up
+gui_list
->selected_size
);
262 if (gui_list
->show_selection_marker
== false)
264 new_start_item
= gui_list
->selected_item
;
266 else if (gui_list
->selected_size
>= nb_lines
)
268 new_start_item
= gui_list
->selected_item
;
270 else if (global_settings
.scroll_paginated
)
272 nb_lines
-= nb_lines
%gui_list
->selected_size
;
273 if (difference
< 0 || difference
>= nb_lines
)
275 new_start_item
= gui_list
->selected_item
-
276 (gui_list
->selected_item
%nb_lines
);
279 else if (difference
<= scroll_limit_up
) /* list moved up */
281 new_start_item
= gui_list
->selected_item
- scroll_limit_up
;
283 else if (difference
> nb_lines
- scroll_limit_down
) /* list moved down */
285 new_start_item
= gui_list
->selected_item
+ scroll_limit_down
- nb_lines
;
287 if (new_start_item
< 0)
288 gui_list
->start_item
[screen
] = 0;
289 else if (new_start_item
> bottom
)
290 gui_list
->start_item
[screen
] = bottom
;
292 gui_list
->start_item
[screen
] = new_start_item
;
296 * Selects an item in the list
297 * - gui_list : the list structure
298 * - item_number : the number of the item which will be selected
300 void gui_synclist_select_item(struct gui_synclist
* gui_list
, int item_number
)
303 if (item_number
>= gui_list
->nb_items
|| item_number
< 0)
305 gui_list
->selected_item
= item_number
;
307 gui_list_put_selection_on_screen(gui_list
, i
);
310 static void gui_list_select_at_offset(struct gui_synclist
* gui_list
,
314 if (gui_list
->selected_size
> 1)
316 offset
*= gui_list
->selected_size
;
319 new_selection
= gui_list
->selected_item
+ offset
;
321 if (new_selection
>= gui_list
->nb_items
)
323 gui_list
->selected_item
= gui_list
->limit_scroll
?
324 gui_list
->nb_items
- gui_list
->selected_size
: 0;
326 else if (new_selection
< 0)
328 gui_list
->selected_item
= gui_list
->limit_scroll
?
329 0 : gui_list
->nb_items
- gui_list
->selected_size
;
331 else if (gui_list
->show_selection_marker
== false)
333 int i
, nb_lines
, screen_top
;
336 nb_lines
= list_get_nb_lines(gui_list
, i
);
339 screen_top
= MAX(0, gui_list
->nb_items
- nb_lines
);
340 gui_list
->start_item
[i
] = MIN(screen_top
, gui_list
->start_item
[i
] +
341 gui_list
->selected_size
);
342 gui_list
->selected_item
= gui_list
->start_item
[i
];
346 gui_list
->start_item
[i
] = MAX(0, gui_list
->start_item
[i
] -
347 gui_list
->selected_size
);
348 gui_list
->selected_item
= gui_list
->start_item
[i
] + nb_lines
;
353 else gui_list
->selected_item
+= offset
;
354 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
358 * Adds an item to the list (the callback will be asked for one more item)
359 * - gui_list : the list structure
361 void gui_synclist_add_item(struct gui_synclist
* gui_list
)
363 gui_list
->nb_items
++;
364 /* if only one item in the list, select it */
365 if (gui_list
->nb_items
== 1)
366 gui_list
->selected_item
= 0;
370 * Removes an item to the list (the callback will be asked for one less item)
371 * - gui_list : the list structure
373 void gui_synclist_del_item(struct gui_synclist
* gui_list
)
375 if (gui_list
->nb_items
> 0)
377 if (gui_list
->selected_item
== gui_list
->nb_items
-1)
378 gui_list
->selected_item
--;
379 gui_list
->nb_items
--;
380 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
384 #ifdef HAVE_LCD_BITMAP
385 void gui_list_screen_scroll_step(int ofs
)
390 void gui_list_screen_scroll_out_of_view(bool enable
)
392 offset_out_of_view
= enable
;
394 #endif /* HAVE_LCD_BITMAP */
397 * Set the title and title icon of the list. Setting title to NULL disables
398 * both the title and icon. Use NOICON if there is no icon.
400 void gui_synclist_set_title(struct gui_synclist
* gui_list
,
401 char * title
, enum themable_icons icon
)
403 gui_list
->title
= title
;
404 gui_list
->title_icon
= icon
;
405 #ifdef HAVE_LCD_BITMAP
408 sb_set_title_text(title
, icon
, i
);
410 send_event(GUI_EVENT_ACTIONUPDATE
, (void*)1);
413 void gui_synclist_set_nb_items(struct gui_synclist
* lists
, int nb_items
)
415 #ifdef HAVE_LCD_BITMAP
418 lists
->nb_items
= nb_items
;
419 #ifdef HAVE_LCD_BITMAP
422 lists
->offset_position
[i
] = 0;
426 int gui_synclist_get_nb_items(struct gui_synclist
* lists
)
428 return lists
->nb_items
;
430 int gui_synclist_get_sel_pos(struct gui_synclist
* lists
)
432 return lists
->selected_item
;
434 void gui_synclist_set_icon_callback(struct gui_synclist
* lists
,
435 list_get_icon icon_callback
)
437 lists
->callback_get_item_icon
= icon_callback
;
440 void gui_synclist_set_voice_callback(struct gui_synclist
* lists
,
441 list_speak_item voice_callback
)
443 lists
->callback_speak_item
= voice_callback
;
446 #ifdef HAVE_LCD_COLOR
447 void gui_synclist_set_color_callback(struct gui_synclist
* lists
,
448 list_get_color color_callback
)
450 lists
->callback_get_item_color
= color_callback
;
454 static void gui_synclist_select_next_page(struct gui_synclist
* lists
,
455 enum screen_type screen
)
457 int nb_lines
= list_get_nb_lines(lists
, screen
);
458 if (lists
->selected_size
> 1)
459 nb_lines
= MAX(1, nb_lines
/lists
->selected_size
);
460 gui_list_select_at_offset(lists
, nb_lines
);
463 static void gui_synclist_select_previous_page(struct gui_synclist
* lists
,
464 enum screen_type screen
)
466 int nb_lines
= list_get_nb_lines(lists
, screen
);
467 if (lists
->selected_size
> 1)
468 nb_lines
= MAX(1, nb_lines
/lists
->selected_size
);
469 gui_list_select_at_offset(lists
, -nb_lines
);
472 void gui_synclist_limit_scroll(struct gui_synclist
* lists
, bool scroll
)
474 lists
->limit_scroll
= scroll
;
477 #ifdef HAVE_LCD_BITMAP
479 * Makes all the item in the list scroll by one step to the right.
480 * Should stop increasing the value when reaching the widest item value
483 static void gui_synclist_scroll_right(struct gui_synclist
* lists
)
488 /* FIXME: This is a fake right boundry limiter. there should be some
489 * callback function to find the longest item on the list in pixels,
490 * to stop the list from scrolling past that point */
491 lists
->offset_position
[i
] += offset_step
;
492 if (lists
->offset_position
[i
] > 1000)
493 lists
->offset_position
[i
] = 1000;
498 * Makes all the item in the list scroll by one step to the left.
499 * stops at starting position.
501 static void gui_synclist_scroll_left(struct gui_synclist
* lists
)
506 lists
->offset_position
[i
] -= offset_step
;
507 if (lists
->offset_position
[i
] < 0)
508 lists
->offset_position
[i
] = 0;
511 #endif /* HAVE_LCD_BITMAP */
513 static void _gui_synclist_speak_item(struct gui_synclist
*lists
, bool repeating
)
515 list_speak_item
*cb
= lists
->callback_speak_item
;
516 if(cb
&& gui_synclist_get_nb_items(lists
) != 0)
518 int sel
= gui_synclist_get_sel_pos(lists
);
520 /* If we got a repeating key action, or we have just very
521 recently started talking, then we want to stay silent for a
522 while until things settle. Likewise if we already had a
523 pending scheduled announcement not yet due: we need to
526 || (lists
->scheduled_talk_tick
527 && TIME_BEFORE(current_tick
, lists
->scheduled_talk_tick
))
528 || (lists
->last_talked_tick
529 && TIME_BEFORE(current_tick
, lists
->last_talked_tick
+HZ
/4)))
531 lists
->scheduled_talk_tick
= current_tick
+HZ
/4;
534 lists
->scheduled_talk_tick
= 0; /* work done */
535 cb(sel
, lists
->data
);
536 lists
->last_talked_tick
= current_tick
;
540 void gui_synclist_speak_item(struct gui_synclist
* lists
)
541 /* The list user should call this to speak the first item on entering
542 the list, and whenever the list is updated. */
544 if(gui_synclist_get_nb_items(lists
) == 0 && global_settings
.talk_menu
)
545 talk_id(VOICE_EMPTY_LIST
, true);
546 else _gui_synclist_speak_item(lists
, false);
549 bool gui_synclist_do_button(struct gui_synclist
* lists
,
550 int *actionptr
, enum list_wrap wrap
)
552 int action
= *actionptr
;
553 #ifdef HAVE_LCD_BITMAP
554 static bool scrolling_left
= false;
557 #ifdef HAVE_WHEEL_ACCELERATION
558 int next_item_modifier
= button_apply_acceleration(get_action_data());
560 static int next_item_modifier
= 1;
561 static int last_accel_tick
= 0;
562 if (global_settings
.list_accel_start_delay
)
564 int start_delay
= global_settings
.list_accel_start_delay
* (HZ
/2);
565 int accel_wait
= global_settings
.list_accel_wait
* HZ
/2;
567 if (get_action_statuscode(NULL
)&ACTION_REPEAT
)
569 if (!last_accel_tick
)
570 last_accel_tick
= current_tick
+ start_delay
;
571 else if (TIME_AFTER(current_tick
, last_accel_tick
+ accel_wait
))
573 last_accel_tick
= current_tick
;
574 next_item_modifier
++;
577 else if (last_accel_tick
)
579 next_item_modifier
= 1;
585 #if defined(HAVE_TOUCHSCREEN)
586 if (action
== ACTION_TOUCHSCREEN
)
587 action
= *actionptr
= gui_synclist_do_touchscreen(lists
);
593 gui_synclist_limit_scroll(lists
, false);
596 gui_synclist_limit_scroll(lists
, true);
598 case LIST_WRAP_UNLESS_HELD
:
599 if (action
== ACTION_STD_PREVREPEAT
||
600 action
== ACTION_STD_NEXTREPEAT
||
601 action
== ACTION_LISTTREE_PGUP
||
602 action
== ACTION_LISTTREE_PGDOWN
)
603 gui_synclist_limit_scroll(lists
, true);
604 else gui_synclist_limit_scroll(lists
, false);
611 gui_synclist_draw(lists
);
614 #ifdef HAVE_VOLUME_IN_LIST
615 case ACTION_LIST_VOLUP
:
616 global_settings
.volume
+= 2;
617 /* up two because the falthrough brings it down one */
618 case ACTION_LIST_VOLDOWN
:
619 global_settings
.volume
--;
623 case ACTION_STD_PREV
:
624 case ACTION_STD_PREVREPEAT
:
625 gui_list_select_at_offset(lists
, -next_item_modifier
);
626 #ifndef HAVE_WHEEL_ACCELERATION
627 if (button_queue_count() < FRAMEDROP_TRIGGER
)
629 gui_synclist_draw(lists
);
630 _gui_synclist_speak_item(lists
,
631 action
== ACTION_STD_PREVREPEAT
632 || next_item_modifier
> 1);
634 *actionptr
= ACTION_STD_PREV
;
637 case ACTION_STD_NEXT
:
638 case ACTION_STD_NEXTREPEAT
:
639 gui_list_select_at_offset(lists
, next_item_modifier
);
640 #ifndef HAVE_WHEEL_ACCELERATION
641 if (button_queue_count() < FRAMEDROP_TRIGGER
)
643 gui_synclist_draw(lists
);
644 _gui_synclist_speak_item(lists
,
645 action
== ACTION_STD_NEXTREPEAT
646 || next_item_modifier
>1);
648 *actionptr
= ACTION_STD_NEXT
;
651 #ifdef HAVE_LCD_BITMAP
652 case ACTION_TREE_PGRIGHT
:
653 gui_synclist_scroll_right(lists
);
654 gui_synclist_draw(lists
);
656 case ACTION_TREE_ROOT_INIT
:
657 /* After this button press ACTION_TREE_PGLEFT is allowed
658 to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
659 keymaps as a repeated button press (the same as the repeated
660 ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
662 if (lists
->offset_position
[0] == 0)
664 scrolling_left
= false;
665 *actionptr
= ACTION_STD_CANCEL
;
668 *actionptr
= ACTION_TREE_PGLEFT
;
669 case ACTION_TREE_PGLEFT
:
670 if(!scrolling_left
&& (lists
->offset_position
[0] == 0))
672 *actionptr
= ACTION_STD_CANCEL
;
675 gui_synclist_scroll_left(lists
);
676 gui_synclist_draw(lists
);
677 scrolling_left
= true; /* stop ACTION_TREE_PAGE_LEFT
681 /* for pgup / pgdown, we are obliged to have a different behaviour depending
682 * on the screen for which the user pressed the key since for example, remote
683 * and main screen doesn't have the same number of lines */
684 case ACTION_LISTTREE_PGUP
:
687 #ifdef HAVE_REMOTE_LCD
688 get_action_statuscode(NULL
)&ACTION_REMOTE
?
692 gui_synclist_select_previous_page(lists
, screen
);
693 gui_synclist_draw(lists
);
694 _gui_synclist_speak_item(lists
, false);
696 *actionptr
= ACTION_STD_NEXT
;
700 case ACTION_LISTTREE_PGDOWN
:
703 #ifdef HAVE_REMOTE_LCD
704 get_action_statuscode(NULL
)&ACTION_REMOTE
?
708 gui_synclist_select_next_page(lists
, screen
);
709 gui_synclist_draw(lists
);
710 _gui_synclist_speak_item(lists
, false);
712 *actionptr
= ACTION_STD_PREV
;
716 if(lists
->scheduled_talk_tick
717 && TIME_AFTER(current_tick
, lists
->scheduled_talk_tick
))
718 /* scheduled postponed item announcement is due */
719 _gui_synclist_speak_item(lists
, false);
723 int list_do_action_timeout(struct gui_synclist
*lists
, int timeout
)
724 /* Returns the lowest of timeout or the delay until a postponed
725 scheduled announcement is due (if any). */
727 if(lists
->scheduled_talk_tick
)
729 long delay
= lists
->scheduled_talk_tick
-current_tick
+1;
730 /* +1 because the trigger condition uses TIME_AFTER(), which
731 is implemented as strictly greater than. */
734 if(timeout
> delay
|| timeout
== TIMEOUT_BLOCK
)
740 bool list_do_action(int context
, int timeout
,
741 struct gui_synclist
*lists
, int *action
,
743 /* Combines the get_action() (with possibly overridden timeout) and
744 gui_synclist_do_button() calls. Returns the list action from
745 do_button, and places the action from get_action in *action. */
747 timeout
= list_do_action_timeout(lists
, timeout
);
748 *action
= get_action(context
, timeout
);
749 return gui_synclist_do_button(lists
, action
, wrap
);
752 bool gui_synclist_item_is_onscreen(struct gui_synclist
*lists
,
753 enum screen_type screen
, int item
)
755 int nb_lines
= list_get_nb_lines(lists
, screen
);
756 return (unsigned)(item
- lists
->start_item
[screen
]) < (unsigned) nb_lines
;
759 /* Simple use list implementation */
760 static int simplelist_line_count
= 0;
761 static char simplelist_text
[SIMPLELIST_MAX_LINES
][SIMPLELIST_MAX_LINELENGTH
];
762 /* set the amount of lines shown in the list */
763 void simplelist_set_line_count(int lines
)
766 simplelist_line_count
= 0;
767 else if (lines
>= SIMPLELIST_MAX_LINES
)
768 simplelist_line_count
= SIMPLELIST_MAX_LINES
;
770 simplelist_line_count
= lines
;
772 /* get the current amount of lines shown */
773 int simplelist_get_line_count(void)
775 return simplelist_line_count
;
777 /* add/edit a line in the list.
778 if line_number > number of lines shown it adds the line,
779 else it edits the line */
780 void simplelist_addline(int line_number
, const char *fmt
, ...)
784 if (line_number
> simplelist_line_count
)
786 if (simplelist_line_count
< SIMPLELIST_MAX_LINES
)
787 line_number
= simplelist_line_count
++;
792 vsnprintf(simplelist_text
[line_number
], SIMPLELIST_MAX_LINELENGTH
, fmt
, ap
);
796 static const char* simplelist_static_getname(int item
,
801 (void)data
; (void)buffer
; (void)buffer_len
;
802 return simplelist_text
[item
];
805 bool simplelist_show_list(struct simplelist_info
*info
)
807 struct gui_synclist lists
;
808 int action
, old_line_count
= simplelist_line_count
, i
;
809 list_get_name
*getname
;
810 int wrap
= LIST_WRAP_UNLESS_HELD
;
812 getname
= info
->get_name
;
814 getname
= simplelist_static_getname
;
817 viewportmanager_theme_enable(i
, true, NULL
);
819 gui_synclist_init(&lists
, getname
, info
->callback_data
,
820 info
->scroll_all
, info
->selection_size
, NULL
);
823 gui_synclist_set_title(&lists
, info
->title
, NOICON
);
825 gui_synclist_set_icon_callback(&lists
, info
->get_icon
);
827 gui_synclist_set_voice_callback(&lists
, info
->get_talk
);
829 if (info
->hide_selection
)
831 gui_synclist_hide_selection_marker(&lists
, true);
832 wrap
= LIST_WRAP_OFF
;
835 if (info
->action_callback
)
836 info
->action_callback(ACTION_REDRAW
, &lists
);
838 if (info
->get_name
== NULL
)
839 gui_synclist_set_nb_items(&lists
,
840 simplelist_line_count
*info
->selection_size
);
842 gui_synclist_set_nb_items(&lists
, info
->count
*info
->selection_size
);
844 gui_synclist_select_item(&lists
, info
->selection
);
846 gui_synclist_draw(&lists
);
847 gui_synclist_speak_item(&lists
);
851 list_do_action(CONTEXT_STD
, info
->timeout
,
852 &lists
, &action
, wrap
);
854 /* We must yield in this case or no other thread can run */
855 if (info
->timeout
== TIMEOUT_NOBLOCK
)
858 if (info
->action_callback
)
860 bool stdok
= action
==ACTION_STD_OK
;
861 action
= info
->action_callback(action
, &lists
);
862 if (stdok
&& action
== ACTION_STD_CANCEL
)
864 /* callback asked us to exit */
865 info
->selection
= gui_synclist_get_sel_pos(&lists
);
869 if (info
->get_name
== NULL
)
870 gui_synclist_set_nb_items(&lists
,
871 simplelist_line_count
*info
->selection_size
);
873 if (action
== ACTION_STD_CANCEL
)
875 info
->selection
= -1;
878 else if ((action
== ACTION_REDRAW
) ||
879 (old_line_count
!= simplelist_line_count
))
881 if (info
->get_name
== NULL
)
883 gui_synclist_set_nb_items(&lists
,
884 simplelist_line_count
*info
->selection_size
);
886 gui_synclist_draw(&lists
);
887 old_line_count
= simplelist_line_count
;
889 else if(default_event_handler(action
) == SYS_USB_CONNECTED
)
894 viewportmanager_theme_undo(i
, false);
898 void simplelist_info_init(struct simplelist_info
*info
, char* title
,
899 int count
, void* data
)
903 info
->selection_size
= 1;
904 info
->hide_selection
= false;
905 info
->scroll_all
= false;
906 info
->timeout
= HZ
/10;
908 info
->action_callback
= NULL
;
909 info
->get_icon
= NULL
;
910 info
->get_name
= NULL
;
911 info
->get_talk
= NULL
;
912 info
->callback_data
= data
;
913 simplelist_line_count
= 0;