1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2005 by Kevin Ferrare
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
31 #include "screen_access.h"
33 #include "scrollbar.h"
34 #include "statusbar.h"
42 #ifdef HAVE_LCD_CHARCELLS
43 #define SCROLL_LIMIT 1
45 #define SCROLL_LIMIT (nb_lines<3?1:2)
48 /* The minimum number of pending button events in queue before starting
49 * to limit list drawing interval.
51 #define FRAMEDROP_TRIGGER 6
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;
58 static int force_list_reinit
= false;
60 static void gui_list_select_at_offset(struct gui_synclist
* gui_list
,
62 void list_draw(struct screen
*display
, struct viewport
*parent
, struct gui_synclist
*list
);
64 #ifdef HAVE_LCD_BITMAP
65 static struct viewport parent
[NB_SCREENS
];
66 void list_init_viewports(struct gui_synclist
*list
)
74 viewport_set_defaults(vp
, i
);
75 else if (list
->parent
[i
] == vp
)
77 viewport_set_defaults(vp
, i
);
78 list
->parent
[i
]->y
= gui_statusbar_height();
79 list
->parent
[i
]->height
= screens
[i
].height
- list
->parent
[i
]->y
;
83 if (list
&& (list
->parent
[0] == &parent
[0]) && global_settings
.buttonbar
)
84 list
->parent
[0]->height
-= BUTTONBAR_HEIGHT
;
86 force_list_reinit
= false;
89 static struct viewport parent
[NB_SCREENS
] =
99 void list_init_viewports(struct gui_synclist
*list
)
105 #ifdef HAVE_LCD_BITMAP
106 bool list_display_title(struct gui_synclist
*list
, struct viewport
*vp
)
108 return list
->title
!= NULL
&& viewport_get_nb_lines(vp
)>2;
111 #define list_display_title(l,v) false
115 * Initializes a scrolling list
116 * - gui_list : the list structure to initialize
117 * - callback_get_item_name : pointer to a function that associates a label
118 * to a given item number
119 * - data : extra data passed to the list callback
122 * - parent : the parent viewports to use. NULL means the full screen minus
123 * statusbar if enabled. NOTE: new screens should NOT set this to NULL.
125 void gui_synclist_init(struct gui_synclist
* gui_list
,
126 list_get_name callback_get_item_name
,
129 int selected_size
, struct viewport list_parent
[NB_SCREENS
]
133 gui_list
->callback_get_item_icon
= NULL
;
134 gui_list
->callback_get_item_name
= callback_get_item_name
;
135 gui_list
->callback_speak_item
= NULL
;
136 gui_list
->nb_items
= 0;
137 gui_list
->selected_item
= 0;
140 gui_list
->start_item
[i
] = 0;
141 gui_list
->last_displayed_start_item
[i
] = -1 ;
142 #ifdef HAVE_LCD_BITMAP
143 gui_list
->offset_position
[i
] = 0;
146 gui_list
->parent
[i
] = &list_parent
[i
];
149 gui_list
->parent
[i
] = &parent
[i
];
152 list_init_viewports(gui_list
);
153 gui_list
->limit_scroll
= false;
155 gui_list
->scroll_all
=scroll_all
;
156 gui_list
->selected_size
=selected_size
;
157 gui_list
->title
= NULL
;
158 gui_list
->title_width
= 0;
159 gui_list
->title_icon
= Icon_NOICON
;
161 gui_list
->scheduled_talk_tick
= gui_list
->last_talked_tick
= 0;
162 gui_list
->show_selection_marker
= true;
163 gui_list
->last_displayed_selected_item
= -1 ;
165 #ifdef HAVE_LCD_COLOR
166 gui_list
->title_color
= -1;
167 gui_list
->callback_get_item_color
= NULL
;
169 force_list_reinit
= true;
172 /* this toggles the selection bar or cursor */
173 void gui_synclist_hide_selection_marker(struct gui_synclist
* lists
, bool hide
)
175 lists
->show_selection_marker
= !hide
;
179 #ifdef HAVE_LCD_BITMAP
180 int list_title_height(struct gui_synclist
*list
, struct viewport
*vp
);
182 int gui_list_get_item_offset(struct gui_synclist
* gui_list
, int item_width
,
183 int text_pos
, struct screen
* display
, struct viewport
*vp
)
187 if (offset_out_of_view
)
189 item_offset
= gui_list
->offset_position
[display
->screen_type
];
193 /* if text is smaller then view */
194 if (item_width
<= vp
->width
- text_pos
)
200 /* if text got out of view */
201 if (gui_list
->offset_position
[display
->screen_type
] >
202 item_width
- (vp
->width
- text_pos
))
203 item_offset
= item_width
- (vp
->width
- text_pos
);
205 item_offset
= gui_list
->offset_position
[display
->screen_type
];
213 * Force a full screen update.
216 void gui_synclist_draw(struct gui_synclist
*gui_list
)
219 static struct gui_synclist
*last_list
= NULL
;
220 static int last_count
= -1;
221 #ifdef HAVE_BUTTONBAR
222 static bool last_buttonbar
= false;
224 if (force_list_reinit
||
225 #ifdef HAVE_BUTTONBAR
226 last_buttonbar
!= screens
[SCREEN_MAIN
].has_buttonbar
||
228 last_list
!= gui_list
||
229 gui_list
->nb_items
!= last_count
)
231 list_init_viewports(gui_list
);
232 force_list_reinit
= false;
234 #ifdef HAVE_BUTTONBAR
235 last_buttonbar
= screens
[SCREEN_MAIN
].has_buttonbar
;
237 last_count
= gui_list
->nb_items
;
238 last_list
= gui_list
;
241 list_draw(&screens
[i
], gui_list
->parent
[i
], gui_list
);
245 /* sets up the list so the selection is shown correctly on the screen */
246 static void gui_list_put_selection_on_screen(struct gui_synclist
* gui_list
,
247 enum screen_type screen
)
250 int difference
= gui_list
->selected_item
- gui_list
->start_item
[screen
];
251 struct viewport vp
= *gui_list
->parent
[screen
];
252 #ifdef HAVE_LCD_BITMAP
253 if (list_display_title(gui_list
, gui_list
->parent
[screen
]))
254 vp
.height
-= list_title_height(gui_list
,gui_list
->parent
[screen
]);
256 nb_lines
= viewport_get_nb_lines(&vp
);
258 /* edge case,, selected last item */
259 if (gui_list
->selected_item
== gui_list
->nb_items
-1)
261 gui_list
->start_item
[screen
] = MAX(0, gui_list
->nb_items
- nb_lines
);
263 /* selected first item */
264 else if (gui_list
->selected_item
== 0)
266 gui_list
->start_item
[screen
] = 0;
268 else if (difference
< SCROLL_LIMIT
) /* list moved up */
270 if (global_settings
.scroll_paginated
)
272 if (gui_list
->start_item
[screen
] > gui_list
->selected_item
)
273 gui_list
->start_item
[screen
] = (gui_list
->selected_item
/nb_lines
)*nb_lines
;
274 if (gui_list
->nb_items
<= nb_lines
)
275 gui_list
->start_item
[screen
] = 0;
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
);
284 else if (difference
> nb_lines
- SCROLL_LIMIT
) /* list moved down */
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)
292 gui_list
->start_item
[screen
] = MIN(bottom
, gui_list
->start_item
[screen
] +
293 2*gui_list
->selected_size
);
295 else if (global_settings
.scroll_paginated
)
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
);
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
);
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
313 void gui_synclist_select_item(struct gui_synclist
* gui_list
, int item_number
)
316 if( item_number
> gui_list
->nb_items
-1 || item_number
< 0 )
318 gui_list
->selected_item
= item_number
;
320 gui_list_put_selection_on_screen(gui_list
, i
);
323 static void gui_list_select_at_offset(struct gui_synclist
* gui_list
,
327 if (gui_list
->selected_size
> 1)
329 offset
*= gui_list
->selected_size
;
330 /* always select the first item of multi-line lists */
331 offset
-= offset
%gui_list
->selected_size
;
333 new_selection
= gui_list
->selected_item
+ offset
;
334 if (new_selection
>= gui_list
->nb_items
)
336 gui_list
->selected_item
= gui_list
->limit_scroll
?
337 gui_list
->nb_items
- gui_list
->selected_size
: 0;
339 else if (new_selection
< 0)
341 gui_list
->selected_item
= gui_list
->limit_scroll
?
342 0 : gui_list
->nb_items
- gui_list
->selected_size
;
344 else if (gui_list
->show_selection_marker
== false)
346 /* NOTE: this part doesnt work as well as it used to, the problem is
347 we want to scroll the lists seperatly but we only have one
348 selected item now, I dont think this is such a big deal though */
349 int i
, nb_lines
, screen_top
;
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
]);
357 nb_lines
= viewport_get_nb_lines(&vp
);
360 screen_top
= gui_list
->nb_items
-nb_lines
;
363 gui_list
->start_item
[i
] = MIN(screen_top
, gui_list
->start_item
[i
] +
364 gui_list
->selected_size
);
368 gui_list
->start_item
[i
] = MAX(0, gui_list
->start_item
[i
] -
369 gui_list
->selected_size
);
374 else gui_list
->selected_item
+= offset
;
375 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
379 * Adds an item to the list (the callback will be asked for one more item)
380 * - gui_list : the list structure
382 void gui_synclist_add_item(struct gui_synclist
* gui_list
)
384 gui_list
->nb_items
++;
385 /* if only one item in the list, select it */
386 if(gui_list
->nb_items
== 1)
387 gui_list
->selected_item
= 0;
391 * Removes an item to the list (the callback will be asked for one less item)
392 * - gui_list : the list structure
394 void gui_synclist_del_item(struct gui_synclist
* gui_list
)
396 if(gui_list
->nb_items
> 0)
398 if (gui_list
->selected_item
== gui_list
->nb_items
-1)
399 gui_list
->selected_item
--;
400 gui_list
->nb_items
--;
401 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
405 #ifdef HAVE_LCD_BITMAP
406 void gui_list_screen_scroll_step(int ofs
)
411 void gui_list_screen_scroll_out_of_view(bool enable
)
414 offset_out_of_view
= true;
416 offset_out_of_view
= false;
418 #endif /* HAVE_LCD_BITMAP */
421 * Set the title and title icon of the list. Setting title to NULL disables
422 * both the title and icon. Use NOICON if there is no icon.
424 void gui_synclist_set_title(struct gui_synclist
* gui_list
,
425 char * title
, enum themable_icons icon
)
427 gui_list
->title
= title
;
428 gui_list
->title_icon
= icon
;
430 #ifdef HAVE_LCD_BITMAP
433 screens
[i
].getstringsize(title
, &gui_list
->title_width
, NULL
);
435 gui_list
->title_width
= strlen(title
);
438 gui_list
->title_width
= 0;
440 force_list_reinit
= true;
444 void gui_synclist_set_nb_items(struct gui_synclist
* lists
, int nb_items
)
446 #ifdef HAVE_LCD_BITMAP
449 lists
->nb_items
= nb_items
;
450 #ifdef HAVE_LCD_BITMAP
453 lists
->offset_position
[i
] = 0;
457 int gui_synclist_get_nb_items(struct gui_synclist
* lists
)
459 return lists
->nb_items
;
461 int gui_synclist_get_sel_pos(struct gui_synclist
* lists
)
463 return lists
->selected_item
;
465 void gui_synclist_set_icon_callback(struct gui_synclist
* lists
,
466 list_get_icon icon_callback
)
468 lists
->callback_get_item_icon
= icon_callback
;
471 void gui_synclist_set_voice_callback(struct gui_synclist
* lists
,
472 list_speak_item voice_callback
)
474 lists
->callback_speak_item
= voice_callback
;
477 #ifdef HAVE_LCD_COLOR
478 void gui_synclist_set_color_callback(struct gui_synclist
* lists
,
479 list_get_color color_callback
)
481 lists
->callback_get_item_color
= color_callback
;
485 static void gui_synclist_select_next_page(struct gui_synclist
* lists
,
486 enum screen_type screen
)
488 int nb_lines
= viewport_get_nb_lines(lists
->parent
[screen
]);
489 gui_list_select_at_offset(lists
, nb_lines
);
492 static void gui_synclist_select_previous_page(struct gui_synclist
* lists
,
493 enum screen_type screen
)
495 int nb_lines
= viewport_get_nb_lines(lists
->parent
[screen
]);
496 gui_list_select_at_offset(lists
, -nb_lines
);
499 void gui_synclist_limit_scroll(struct gui_synclist
* lists
, bool scroll
)
501 lists
->limit_scroll
= scroll
;
504 #ifdef HAVE_LCD_BITMAP
506 * Makes all the item in the list scroll by one step to the right.
507 * Should stop increasing the value when reaching the widest item value
510 static void gui_synclist_scroll_right(struct gui_synclist
* lists
)
515 /* FIXME: This is a fake right boundry limiter. there should be some
516 * callback function to find the longest item on the list in pixels,
517 * to stop the list from scrolling past that point */
518 lists
->offset_position
[i
]+=offset_step
;
519 if (lists
->offset_position
[i
] > 1000)
520 lists
->offset_position
[i
] = 1000;
525 * Makes all the item in the list scroll by one step to the left.
526 * stops at starting position.
528 static void gui_synclist_scroll_left(struct gui_synclist
* lists
)
533 lists
->offset_position
[i
]-=offset_step
;
534 if (lists
->offset_position
[i
] < 0)
535 lists
->offset_position
[i
] = 0;
538 #endif /* HAVE_LCD_BITMAP */
540 static void _gui_synclist_speak_item(struct gui_synclist
*lists
, bool repeating
)
542 list_speak_item
*cb
= lists
->callback_speak_item
;
543 if(cb
&& gui_synclist_get_nb_items(lists
) != 0)
545 int sel
= gui_synclist_get_sel_pos(lists
);
547 /* If we got a repeating key action, or we have just very
548 recently started talking, then we want to stay silent for a
549 while until things settle. Likewise if we already had a
550 pending scheduled announcement not yet due: we need to
553 || (lists
->scheduled_talk_tick
554 && TIME_BEFORE(current_tick
, lists
->scheduled_talk_tick
))
555 || (lists
->last_talked_tick
556 && TIME_BEFORE(current_tick
, lists
->last_talked_tick
+HZ
/4)))
558 lists
->scheduled_talk_tick
= current_tick
+HZ
/4;
561 lists
->scheduled_talk_tick
= 0; /* work done */
562 cb(sel
, lists
->data
);
563 lists
->last_talked_tick
= current_tick
;
567 void gui_synclist_speak_item(struct gui_synclist
* lists
)
568 /* The list user should call this to speak the first item on entering
569 the list, and whenever the list is updated. */
571 if(gui_synclist_get_nb_items(lists
) == 0 && global_settings
.talk_menu
)
572 talk_id(VOICE_EMPTY_LIST
, true);
573 else _gui_synclist_speak_item(lists
, false);
576 extern intptr_t get_action_data(void);
577 #if defined(HAVE_TOUCHPAD)
578 /* this needs to be fixed if we ever get more than 1 touchscreen on a target */
579 unsigned gui_synclist_do_touchpad(struct gui_synclist
* gui_list
, struct viewport
*parent
);
582 bool gui_synclist_do_button(struct gui_synclist
* lists
,
583 unsigned *actionptr
, enum list_wrap wrap
)
585 int action
= *actionptr
;
586 #ifdef HAVE_LCD_BITMAP
587 static bool scrolling_left
= false;
590 #ifdef HAVE_SCROLLWHEEL
591 int next_item_modifier
= button_apply_acceleration(get_action_data());
593 static int next_item_modifier
= 1;
594 static int last_accel_tick
= 0;
596 if (global_settings
.list_accel_start_delay
)
598 int start_delay
= global_settings
.list_accel_start_delay
* (HZ
/2);
599 int accel_wait
= global_settings
.list_accel_wait
* HZ
/2;
601 if (get_action_statuscode(NULL
)&ACTION_REPEAT
)
603 if (!last_accel_tick
)
604 last_accel_tick
= current_tick
+ start_delay
;
605 else if (current_tick
>=
606 last_accel_tick
+ accel_wait
)
608 last_accel_tick
= current_tick
;
609 next_item_modifier
++;
612 else if (last_accel_tick
)
614 next_item_modifier
= 1;
620 #if defined(HAVE_TOUCHPAD)
621 if (action
== ACTION_TOUCHPAD
)
622 action
= *actionptr
= gui_synclist_do_touchpad(lists
, &parent
[SCREEN_MAIN
]);
628 gui_synclist_limit_scroll(lists
, false);
631 gui_synclist_limit_scroll(lists
, true);
633 case LIST_WRAP_UNLESS_HELD
:
634 if (action
== ACTION_STD_PREVREPEAT
||
635 action
== ACTION_STD_NEXTREPEAT
||
636 action
== ACTION_LISTTREE_PGUP
||
637 action
== ACTION_LISTTREE_PGDOWN
)
638 gui_synclist_limit_scroll(lists
, true);
639 else gui_synclist_limit_scroll(lists
, false);
646 gui_synclist_draw(lists
);
649 #ifdef HAVE_VOLUME_IN_LIST
650 case ACTION_LIST_VOLUP
:
651 global_settings
.volume
+= 2;
652 /* up two because the falthrough brings it down one */
653 case ACTION_LIST_VOLDOWN
:
654 global_settings
.volume
--;
658 case ACTION_STD_PREV
:
659 case ACTION_STD_PREVREPEAT
:
660 gui_list_select_at_offset(lists
, -next_item_modifier
);
661 #ifndef HAVE_SCROLLWHEEL
662 if (button_queue_count() < FRAMEDROP_TRIGGER
)
664 gui_synclist_draw(lists
);
665 _gui_synclist_speak_item(lists
,
666 action
== ACTION_STD_PREVREPEAT
667 || next_item_modifier
>1);
669 *actionptr
= ACTION_STD_PREV
;
672 case ACTION_STD_NEXT
:
673 case ACTION_STD_NEXTREPEAT
:
674 gui_list_select_at_offset(lists
, next_item_modifier
);
675 #ifndef HAVE_SCROLLWHEEL
676 if (button_queue_count() < FRAMEDROP_TRIGGER
)
678 gui_synclist_draw(lists
);
679 _gui_synclist_speak_item(lists
,
680 action
== ACTION_STD_NEXTREPEAT
681 || next_item_modifier
>1);
683 *actionptr
= ACTION_STD_NEXT
;
686 #ifdef HAVE_LCD_BITMAP
687 case ACTION_TREE_PGRIGHT
:
688 gui_synclist_scroll_right(lists
);
689 gui_synclist_draw(lists
);
691 case ACTION_TREE_ROOT_INIT
:
692 /* After this button press ACTION_TREE_PGLEFT is allowed
693 to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
694 keymaps as a repeated button press (the same as the repeated
695 ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
697 if (lists
->offset_position
[0] == 0)
699 scrolling_left
= false;
700 *actionptr
= ACTION_STD_CANCEL
;
703 *actionptr
= ACTION_TREE_PGLEFT
;
704 case ACTION_TREE_PGLEFT
:
705 if(!scrolling_left
&& (lists
->offset_position
[0] == 0))
707 *actionptr
= ACTION_STD_CANCEL
;
710 gui_synclist_scroll_left(lists
);
711 gui_synclist_draw(lists
);
712 scrolling_left
= true; /* stop ACTION_TREE_PAGE_LEFT
716 /* for pgup / pgdown, we are obliged to have a different behaviour depending
717 * on the screen for which the user pressed the key since for example, remote
718 * and main screen doesn't have the same number of lines */
719 case ACTION_LISTTREE_PGUP
:
722 #ifdef HAVE_REMOTE_LCD
723 get_action_statuscode(NULL
)&ACTION_REMOTE
?
727 gui_synclist_select_previous_page(lists
, screen
);
728 gui_synclist_draw(lists
);
729 _gui_synclist_speak_item(lists
, false);
731 *actionptr
= ACTION_STD_NEXT
;
735 case ACTION_LISTTREE_PGDOWN
:
738 #ifdef HAVE_REMOTE_LCD
739 get_action_statuscode(NULL
)&ACTION_REMOTE
?
743 gui_synclist_select_next_page(lists
, screen
);
744 gui_synclist_draw(lists
);
745 _gui_synclist_speak_item(lists
, false);
747 *actionptr
= ACTION_STD_PREV
;
751 if(lists
->scheduled_talk_tick
752 && TIME_AFTER(current_tick
, lists
->scheduled_talk_tick
))
753 /* scheduled postponed item announcement is due */
754 _gui_synclist_speak_item(lists
, false);
758 int list_do_action_timeout(struct gui_synclist
*lists
, int timeout
)
759 /* Returns the lowest of timeout or the delay until a postponed
760 scheduled announcement is due (if any). */
762 if(lists
->scheduled_talk_tick
)
764 long delay
= lists
->scheduled_talk_tick
-current_tick
+1;
765 /* +1 because the trigger condition uses TIME_AFTER(), which
766 is implemented as strictly greater than. */
769 if(timeout
> delay
|| timeout
== TIMEOUT_BLOCK
)
775 bool list_do_action(int context
, int timeout
,
776 struct gui_synclist
*lists
, int *action
,
778 /* Combines the get_action() (with possibly overridden timeout) and
779 gui_synclist_do_button() calls. Returns the list action from
780 do_button, and places the action from get_action in *action. */
782 timeout
= list_do_action_timeout(lists
, timeout
);
783 *action
= get_action(context
, timeout
);
784 return gui_synclist_do_button(lists
, action
, wrap
);
787 /* Simple use list implementation */
788 static int simplelist_line_count
= 0;
789 static char simplelist_text
[SIMPLELIST_MAX_LINES
][SIMPLELIST_MAX_LINELENGTH
];
790 /* set the amount of lines shown in the list */
791 void simplelist_set_line_count(int lines
)
794 simplelist_line_count
= 0;
795 else if (lines
>= SIMPLELIST_MAX_LINES
)
796 simplelist_line_count
= SIMPLELIST_MAX_LINES
;
798 simplelist_line_count
= lines
;
800 /* get the current amount of lines shown */
801 int simplelist_get_line_count(void)
803 return simplelist_line_count
;
805 /* add/edit a line in the list.
806 if line_number > number of lines shown it adds the line, else it edits the line */
807 void simplelist_addline(int line_number
, const char *fmt
, ...)
811 if (line_number
> simplelist_line_count
)
813 if (simplelist_line_count
< SIMPLELIST_MAX_LINES
)
814 line_number
= simplelist_line_count
++;
819 vsnprintf(simplelist_text
[line_number
], SIMPLELIST_MAX_LINELENGTH
, fmt
, ap
);
823 static char* simplelist_static_getname(int item
,
828 (void)data
; (void)buffer
; (void)buffer_len
;
829 return simplelist_text
[item
];
832 bool simplelist_show_list(struct simplelist_info
*info
)
834 struct gui_synclist lists
;
835 struct viewport vp
[NB_SCREENS
];
836 int action
, old_line_count
= simplelist_line_count
,i
;
837 char* (*getname
)(int item
, void * data
, char *buffer
, size_t buffer_len
);
839 getname
= info
->get_name
;
841 getname
= simplelist_static_getname
;
844 viewport_set_defaults(&vp
[i
], i
);
846 gui_synclist_init(&lists
, getname
, info
->callback_data
,
847 info
->scroll_all
, info
->selection_size
, vp
);
850 gui_synclist_set_title(&lists
, info
->title
, NOICON
);
852 gui_synclist_set_icon_callback(&lists
, info
->get_icon
);
854 gui_synclist_set_voice_callback(&lists
, info
->get_talk
);
856 gui_synclist_hide_selection_marker(&lists
, info
->hide_selection
);
858 if (info
->action_callback
)
859 info
->action_callback(ACTION_REDRAW
, &lists
);
861 if (info
->get_name
== NULL
)
862 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
864 gui_synclist_set_nb_items(&lists
, info
->count
*info
->selection_size
);
866 gui_synclist_select_item(&lists
, info
->start_selection
);
868 gui_synclist_draw(&lists
);
869 gui_synclist_speak_item(&lists
);
873 gui_syncstatusbar_draw(&statusbars
, true);
874 list_do_action(CONTEXT_STD
, info
->timeout
,
875 &lists
, &action
, LIST_WRAP_UNLESS_HELD
);
877 /* We must yield in this case or no other thread can run */
878 if (info
->timeout
== TIMEOUT_NOBLOCK
)
881 if (info
->action_callback
)
883 action
= info
->action_callback(action
, &lists
);
884 if (info
->get_name
== NULL
)
885 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
887 if (action
== ACTION_STD_CANCEL
)
889 else if ((action
== ACTION_REDRAW
) ||
890 (old_line_count
!= simplelist_line_count
))
892 if (info
->get_name
== NULL
)
893 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
894 gui_synclist_draw(&lists
);
895 if (action
!= ACTION_NONE
)
896 gui_synclist_speak_item(&lists
);
897 old_line_count
= simplelist_line_count
;
899 else if(default_event_handler(action
) == SYS_USB_CONNECTED
)
906 void simplelist_info_init(struct simplelist_info
*info
, char* title
,
907 int count
, void* data
)
911 info
->selection_size
= 1;
912 info
->hide_selection
= false;
913 info
->scroll_all
= false;
914 info
->timeout
= HZ
/10;
915 info
->start_selection
= 0;
916 info
->action_callback
= NULL
;
917 info
->get_icon
= NULL
;
918 info
->get_name
= NULL
;
919 info
->get_talk
= NULL
;
920 info
->callback_data
= data
;