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
;
277 int top_of_screen
= gui_list
->selected_item
- SCROLL_LIMIT
+ 1;
278 int temp
= MIN(top_of_screen
, gui_list
->nb_items
- nb_lines
);
279 gui_list
->start_item
[screen
] = MAX(0, temp
);
282 else if (difference
> nb_lines
- SCROLL_LIMIT
) /* list moved down */
284 int bottom
= gui_list
->nb_items
- nb_lines
;
285 /* always move the screen if selection isnt "visible" */
286 if (gui_list
->show_selection_marker
== false)
290 gui_list
->start_item
[screen
] = MIN(bottom
, gui_list
->start_item
[screen
] +
291 2*gui_list
->selected_size
);
293 else if (global_settings
.scroll_paginated
)
295 if (gui_list
->start_item
[screen
] + nb_lines
<= gui_list
->selected_item
)
296 gui_list
->start_item
[screen
] = MIN(bottom
, gui_list
->selected_item
);
300 int top_of_screen
= gui_list
->selected_item
+ SCROLL_LIMIT
- nb_lines
;
301 int temp
= MAX(0, top_of_screen
);
302 gui_list
->start_item
[screen
] = MIN(bottom
, temp
);
307 * Selects an item in the list
308 * - gui_list : the list structure
309 * - item_number : the number of the item which will be selected
311 void gui_synclist_select_item(struct gui_synclist
* gui_list
, int item_number
)
314 if( item_number
> gui_list
->nb_items
-1 || item_number
< 0 )
316 gui_list
->selected_item
= item_number
;
318 gui_list_put_selection_on_screen(gui_list
, i
);
321 static void gui_list_select_at_offset(struct gui_synclist
* gui_list
,
325 if (gui_list
->selected_size
> 1)
327 offset
*= gui_list
->selected_size
;
328 /* always select the first item of multi-line lists */
329 offset
-= offset
%gui_list
->selected_size
;
331 new_selection
= gui_list
->selected_item
+ offset
;
332 if (new_selection
>= gui_list
->nb_items
)
334 gui_list
->selected_item
= gui_list
->limit_scroll
?
335 gui_list
->nb_items
- gui_list
->selected_size
: 0;
337 else if (new_selection
< 0)
339 gui_list
->selected_item
= gui_list
->limit_scroll
?
340 0 : gui_list
->nb_items
- gui_list
->selected_size
;
342 else if (gui_list
->show_selection_marker
== false)
344 /* NOTE: this part doesnt work as well as it used to, the problem is
345 we want to scroll the lists seperatly but we only have one
346 selected item now, I dont think this is such a big deal though */
347 int i
, nb_lines
, screen_top
;
350 struct viewport vp
= *gui_list
->parent
[i
];
351 #ifdef HAVE_LCD_BITMAP
352 if (list_display_title(gui_list
, gui_list
->parent
[i
]))
353 vp
.height
-= list_title_height(gui_list
,gui_list
->parent
[i
]);
355 nb_lines
= viewport_get_nb_lines(&vp
);
358 screen_top
= gui_list
->nb_items
-nb_lines
;
361 gui_list
->start_item
[i
] = MIN(screen_top
, gui_list
->start_item
[i
] +
362 gui_list
->selected_size
);
366 gui_list
->start_item
[i
] = MAX(0, gui_list
->start_item
[i
] -
367 gui_list
->selected_size
);
372 else gui_list
->selected_item
+= offset
;
373 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
377 * Adds an item to the list (the callback will be asked for one more item)
378 * - gui_list : the list structure
380 void gui_synclist_add_item(struct gui_synclist
* gui_list
)
382 gui_list
->nb_items
++;
383 /* if only one item in the list, select it */
384 if(gui_list
->nb_items
== 1)
385 gui_list
->selected_item
= 0;
389 * Removes an item to the list (the callback will be asked for one less item)
390 * - gui_list : the list structure
392 void gui_synclist_del_item(struct gui_synclist
* gui_list
)
394 if(gui_list
->nb_items
> 0)
396 if (gui_list
->selected_item
== gui_list
->nb_items
-1)
397 gui_list
->selected_item
--;
398 gui_list
->nb_items
--;
399 gui_synclist_select_item(gui_list
, gui_list
->selected_item
);
403 #ifdef HAVE_LCD_BITMAP
404 void gui_list_screen_scroll_step(int ofs
)
409 void gui_list_screen_scroll_out_of_view(bool enable
)
412 offset_out_of_view
= true;
414 offset_out_of_view
= false;
416 #endif /* HAVE_LCD_BITMAP */
419 * Set the title and title icon of the list. Setting title to NULL disables
420 * both the title and icon. Use NOICON if there is no icon.
422 void gui_synclist_set_title(struct gui_synclist
* gui_list
,
423 char * title
, enum themable_icons icon
)
425 gui_list
->title
= title
;
426 gui_list
->title_icon
= icon
;
428 #ifdef HAVE_LCD_BITMAP
431 screens
[i
].getstringsize(title
, &gui_list
->title_width
, NULL
);
433 gui_list
->title_width
= strlen(title
);
436 gui_list
->title_width
= 0;
438 force_list_reinit
= true;
442 void gui_synclist_set_nb_items(struct gui_synclist
* lists
, int nb_items
)
444 #ifdef HAVE_LCD_BITMAP
447 lists
->nb_items
= nb_items
;
448 #ifdef HAVE_LCD_BITMAP
451 lists
->offset_position
[i
] = 0;
455 int gui_synclist_get_nb_items(struct gui_synclist
* lists
)
457 return lists
->nb_items
;
459 int gui_synclist_get_sel_pos(struct gui_synclist
* lists
)
461 return lists
->selected_item
;
463 void gui_synclist_set_icon_callback(struct gui_synclist
* lists
,
464 list_get_icon icon_callback
)
466 lists
->callback_get_item_icon
= icon_callback
;
469 void gui_synclist_set_voice_callback(struct gui_synclist
* lists
,
470 list_speak_item voice_callback
)
472 lists
->callback_speak_item
= voice_callback
;
475 #ifdef HAVE_LCD_COLOR
476 void gui_synclist_set_color_callback(struct gui_synclist
* lists
,
477 list_get_color color_callback
)
479 lists
->callback_get_item_color
= color_callback
;
483 static void gui_synclist_select_next_page(struct gui_synclist
* lists
,
484 enum screen_type screen
)
486 int nb_lines
= viewport_get_nb_lines(lists
->parent
[screen
]);
487 gui_list_select_at_offset(lists
, nb_lines
);
490 static void gui_synclist_select_previous_page(struct gui_synclist
* lists
,
491 enum screen_type screen
)
493 int nb_lines
= viewport_get_nb_lines(lists
->parent
[screen
]);
494 gui_list_select_at_offset(lists
, -nb_lines
);
497 void gui_synclist_limit_scroll(struct gui_synclist
* lists
, bool scroll
)
499 lists
->limit_scroll
= scroll
;
502 #ifdef HAVE_LCD_BITMAP
504 * Makes all the item in the list scroll by one step to the right.
505 * Should stop increasing the value when reaching the widest item value
508 static void gui_synclist_scroll_right(struct gui_synclist
* lists
)
513 /* FIXME: This is a fake right boundry limiter. there should be some
514 * callback function to find the longest item on the list in pixels,
515 * to stop the list from scrolling past that point */
516 lists
->offset_position
[i
]+=offset_step
;
517 if (lists
->offset_position
[i
] > 1000)
518 lists
->offset_position
[i
] = 1000;
523 * Makes all the item in the list scroll by one step to the left.
524 * stops at starting position.
526 static void gui_synclist_scroll_left(struct gui_synclist
* lists
)
531 lists
->offset_position
[i
]-=offset_step
;
532 if (lists
->offset_position
[i
] < 0)
533 lists
->offset_position
[i
] = 0;
536 #endif /* HAVE_LCD_BITMAP */
538 static void _gui_synclist_speak_item(struct gui_synclist
*lists
, bool repeating
)
540 list_speak_item
*cb
= lists
->callback_speak_item
;
541 if(cb
&& gui_synclist_get_nb_items(lists
) != 0)
543 int sel
= gui_synclist_get_sel_pos(lists
);
545 /* If we got a repeating key action, or we have just very
546 recently started talking, then we want to stay silent for a
547 while until things settle. Likewise if we already had a
548 pending scheduled announcement not yet due: we need to
551 || (lists
->scheduled_talk_tick
552 && TIME_BEFORE(current_tick
, lists
->scheduled_talk_tick
))
553 || (lists
->last_talked_tick
554 && TIME_BEFORE(current_tick
, lists
->last_talked_tick
+HZ
/4)))
556 lists
->scheduled_talk_tick
= current_tick
+HZ
/4;
559 lists
->scheduled_talk_tick
= 0; /* work done */
560 cb(sel
, lists
->data
);
561 lists
->last_talked_tick
= current_tick
;
565 void gui_synclist_speak_item(struct gui_synclist
* lists
)
566 /* The list user should call this to speak the first item on entering
567 the list, and whenever the list is updated. */
569 if(gui_synclist_get_nb_items(lists
) == 0 && global_settings
.talk_menu
)
570 talk_id(VOICE_EMPTY_LIST
, true);
571 else _gui_synclist_speak_item(lists
, false);
574 extern intptr_t get_action_data(void);
575 #if defined(HAVE_TOUCHPAD)
576 /* this needs to be fixed if we ever get more than 1 touchscreen on a target */
577 unsigned gui_synclist_do_touchpad(struct gui_synclist
* gui_list
, struct viewport
*parent
);
580 bool gui_synclist_do_button(struct gui_synclist
* lists
,
581 unsigned *actionptr
, enum list_wrap wrap
)
583 int action
= *actionptr
;
584 #ifdef HAVE_LCD_BITMAP
585 static bool scrolling_left
= false;
588 #ifdef HAVE_SCROLLWHEEL
589 int next_item_modifier
= button_apply_acceleration(get_action_data());
591 static int next_item_modifier
= 1;
592 static int last_accel_tick
= 0;
594 if (global_settings
.list_accel_start_delay
)
596 int start_delay
= global_settings
.list_accel_start_delay
* (HZ
/2);
597 int accel_wait
= global_settings
.list_accel_wait
* HZ
/2;
599 if (get_action_statuscode(NULL
)&ACTION_REPEAT
)
601 if (!last_accel_tick
)
602 last_accel_tick
= current_tick
+ start_delay
;
603 else if (current_tick
>=
604 last_accel_tick
+ accel_wait
)
606 last_accel_tick
= current_tick
;
607 next_item_modifier
++;
610 else if (last_accel_tick
)
612 next_item_modifier
= 1;
618 #if defined(HAVE_TOUCHPAD)
619 if (action
== ACTION_TOUCHPAD
)
620 action
= *actionptr
= gui_synclist_do_touchpad(lists
, &parent
[SCREEN_MAIN
]);
626 gui_synclist_limit_scroll(lists
, false);
629 gui_synclist_limit_scroll(lists
, true);
631 case LIST_WRAP_UNLESS_HELD
:
632 if (action
== ACTION_STD_PREVREPEAT
||
633 action
== ACTION_STD_NEXTREPEAT
||
634 action
== ACTION_LISTTREE_PGUP
||
635 action
== ACTION_LISTTREE_PGDOWN
)
636 gui_synclist_limit_scroll(lists
, true);
637 else gui_synclist_limit_scroll(lists
, false);
644 gui_synclist_draw(lists
);
647 #ifdef HAVE_VOLUME_IN_LIST
648 case ACTION_LIST_VOLUP
:
649 global_settings
.volume
+= 2;
650 /* up two because the falthrough brings it down one */
651 case ACTION_LIST_VOLDOWN
:
652 global_settings
.volume
--;
656 case ACTION_STD_PREV
:
657 case ACTION_STD_PREVREPEAT
:
658 gui_list_select_at_offset(lists
, -next_item_modifier
);
659 #ifndef HAVE_SCROLLWHEEL
660 if (button_queue_count() < FRAMEDROP_TRIGGER
)
662 gui_synclist_draw(lists
);
663 _gui_synclist_speak_item(lists
,
664 action
== ACTION_STD_PREVREPEAT
665 || next_item_modifier
>1);
667 *actionptr
= ACTION_STD_PREV
;
670 case ACTION_STD_NEXT
:
671 case ACTION_STD_NEXTREPEAT
:
672 gui_list_select_at_offset(lists
, next_item_modifier
);
673 #ifndef HAVE_SCROLLWHEEL
674 if (button_queue_count() < FRAMEDROP_TRIGGER
)
676 gui_synclist_draw(lists
);
677 _gui_synclist_speak_item(lists
,
678 action
== ACTION_STD_NEXTREPEAT
679 || next_item_modifier
>1);
681 *actionptr
= ACTION_STD_NEXT
;
684 #ifdef HAVE_LCD_BITMAP
685 case ACTION_TREE_PGRIGHT
:
686 gui_synclist_scroll_right(lists
);
687 gui_synclist_draw(lists
);
689 case ACTION_TREE_ROOT_INIT
:
690 /* After this button press ACTION_TREE_PGLEFT is allowed
691 to skip to root. ACTION_TREE_ROOT_INIT must be defined in the
692 keymaps as a repeated button press (the same as the repeated
693 ACTION_TREE_PGLEFT) with the pre condition being the non-repeated
695 if (lists
->offset_position
[0] == 0)
697 scrolling_left
= false;
698 *actionptr
= ACTION_STD_CANCEL
;
701 *actionptr
= ACTION_TREE_PGLEFT
;
702 case ACTION_TREE_PGLEFT
:
703 if(!scrolling_left
&& (lists
->offset_position
[0] == 0))
705 *actionptr
= ACTION_STD_CANCEL
;
708 gui_synclist_scroll_left(lists
);
709 gui_synclist_draw(lists
);
710 scrolling_left
= true; /* stop ACTION_TREE_PAGE_LEFT
714 /* for pgup / pgdown, we are obliged to have a different behaviour depending
715 * on the screen for which the user pressed the key since for example, remote
716 * and main screen doesn't have the same number of lines */
717 case ACTION_LISTTREE_PGUP
:
720 #ifdef HAVE_REMOTE_LCD
721 get_action_statuscode(NULL
)&ACTION_REMOTE
?
725 gui_synclist_select_previous_page(lists
, screen
);
726 gui_synclist_draw(lists
);
727 _gui_synclist_speak_item(lists
, false);
729 *actionptr
= ACTION_STD_NEXT
;
733 case ACTION_LISTTREE_PGDOWN
:
736 #ifdef HAVE_REMOTE_LCD
737 get_action_statuscode(NULL
)&ACTION_REMOTE
?
741 gui_synclist_select_next_page(lists
, screen
);
742 gui_synclist_draw(lists
);
743 _gui_synclist_speak_item(lists
, false);
745 *actionptr
= ACTION_STD_PREV
;
749 if(lists
->scheduled_talk_tick
750 && TIME_AFTER(current_tick
, lists
->scheduled_talk_tick
))
751 /* scheduled postponed item announcement is due */
752 _gui_synclist_speak_item(lists
, false);
756 int list_do_action_timeout(struct gui_synclist
*lists
, int timeout
)
757 /* Returns the lowest of timeout or the delay until a postponed
758 scheduled announcement is due (if any). */
760 if(lists
->scheduled_talk_tick
)
762 long delay
= lists
->scheduled_talk_tick
-current_tick
+1;
763 /* +1 because the trigger condition uses TIME_AFTER(), which
764 is implemented as strictly greater than. */
767 if(timeout
> delay
|| timeout
== TIMEOUT_BLOCK
)
773 bool list_do_action(int context
, int timeout
,
774 struct gui_synclist
*lists
, int *action
,
776 /* Combines the get_action() (with possibly overridden timeout) and
777 gui_synclist_do_button() calls. Returns the list action from
778 do_button, and places the action from get_action in *action. */
780 timeout
= list_do_action_timeout(lists
, timeout
);
781 *action
= get_action(context
, timeout
);
782 return gui_synclist_do_button(lists
, action
, wrap
);
785 /* Simple use list implementation */
786 static int simplelist_line_count
= 0;
787 static char simplelist_text
[SIMPLELIST_MAX_LINES
][SIMPLELIST_MAX_LINELENGTH
];
788 /* set the amount of lines shown in the list */
789 void simplelist_set_line_count(int lines
)
792 simplelist_line_count
= 0;
793 else if (lines
>= SIMPLELIST_MAX_LINES
)
794 simplelist_line_count
= SIMPLELIST_MAX_LINES
;
796 simplelist_line_count
= lines
;
798 /* get the current amount of lines shown */
799 int simplelist_get_line_count(void)
801 return simplelist_line_count
;
803 /* add/edit a line in the list.
804 if line_number > number of lines shown it adds the line, else it edits the line */
805 void simplelist_addline(int line_number
, const char *fmt
, ...)
809 if (line_number
> simplelist_line_count
)
811 if (simplelist_line_count
< SIMPLELIST_MAX_LINES
)
812 line_number
= simplelist_line_count
++;
817 vsnprintf(simplelist_text
[line_number
], SIMPLELIST_MAX_LINELENGTH
, fmt
, ap
);
821 static char* simplelist_static_getname(int item
,
826 (void)data
; (void)buffer
; (void)buffer_len
;
827 return simplelist_text
[item
];
830 bool simplelist_show_list(struct simplelist_info
*info
)
832 struct gui_synclist lists
;
833 struct viewport vp
[NB_SCREENS
];
834 int action
, old_line_count
= simplelist_line_count
,i
;
835 char* (*getname
)(int item
, void * data
, char *buffer
, size_t buffer_len
);
837 getname
= info
->get_name
;
839 getname
= simplelist_static_getname
;
842 viewport_set_defaults(&vp
[i
], i
);
844 gui_synclist_init(&lists
, getname
, info
->callback_data
,
845 info
->scroll_all
, info
->selection_size
, vp
);
848 gui_synclist_set_title(&lists
, info
->title
, NOICON
);
850 gui_synclist_set_icon_callback(&lists
, info
->get_icon
);
852 gui_synclist_set_voice_callback(&lists
, info
->get_talk
);
854 gui_synclist_hide_selection_marker(&lists
, info
->hide_selection
);
856 if (info
->action_callback
)
857 info
->action_callback(ACTION_REDRAW
, &lists
);
859 if (info
->get_name
== NULL
)
860 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
862 gui_synclist_set_nb_items(&lists
, info
->count
*info
->selection_size
);
864 gui_synclist_select_item(&lists
, info
->start_selection
);
866 gui_synclist_draw(&lists
);
867 gui_synclist_speak_item(&lists
);
871 gui_syncstatusbar_draw(&statusbars
, true);
872 list_do_action(CONTEXT_STD
, info
->timeout
,
873 &lists
, &action
, LIST_WRAP_UNLESS_HELD
);
875 /* We must yield in this case or no other thread can run */
876 if (info
->timeout
== TIMEOUT_NOBLOCK
)
879 if (info
->action_callback
)
881 action
= info
->action_callback(action
, &lists
);
882 if (info
->get_name
== NULL
)
883 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
885 if (action
== ACTION_STD_CANCEL
)
887 else if ((action
== ACTION_REDRAW
) ||
888 (old_line_count
!= simplelist_line_count
))
890 if (info
->get_name
== NULL
)
891 gui_synclist_set_nb_items(&lists
, simplelist_line_count
*info
->selection_size
);
892 gui_synclist_draw(&lists
);
893 if (action
!= ACTION_NONE
)
894 gui_synclist_speak_item(&lists
);
895 old_line_count
= simplelist_line_count
;
897 else if(default_event_handler(action
) == SYS_USB_CONNECTED
)
904 void simplelist_info_init(struct simplelist_info
*info
, char* title
,
905 int count
, void* data
)
909 info
->selection_size
= 1;
910 info
->hide_selection
= false;
911 info
->scroll_all
= false;
912 info
->timeout
= HZ
/10;
913 info
->start_selection
= 0;
914 info
->action_callback
= NULL
;
915 info
->get_icon
= NULL
;
916 info
->get_name
= NULL
;
917 info
->get_talk
= NULL
;
918 info
->callback_data
= data
;