Daniel Stenberg | 1c0c861 | 2002-05-17 12:22:24 +0000 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * __________ __ ___. |
| 3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ |
| 4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / |
| 5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
| 6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
| 7 | * \/ \/ \/ \/ \/ |
| 8 | * $Id$ |
| 9 | * |
| 10 | * Copyright (C) 2002 Robert E. Hak |
| 11 | * |
Daniel Stenberg | 2acc0ac | 2008-06-28 18:10:04 +0000 | [diff] [blame] | 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. |
Daniel Stenberg | 1c0c861 | 2002-05-17 12:22:24 +0000 | [diff] [blame] | 16 | * |
| 17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| 18 | * KIND, either express or implied. |
| 19 | * |
| 20 | ****************************************************************************/ |
Kevin Ferrare | db8415c | 2005-10-30 22:34:51 +0000 | [diff] [blame] | 21 | /* |
| 22 | 2005 Kevin Ferrare : |
| 23 | - Multi screen support |
| 24 | - Rewrote/removed a lot of code now useless with the new gui API |
| 25 | */ |
Björn Stenberg | 2ac0572 | 2002-05-26 17:03:17 +0000 | [diff] [blame] | 26 | #include <stdbool.h> |
Linus Nielsen Feltzing | 10b92c4 | 2004-03-12 10:20:33 +0000 | [diff] [blame] | 27 | #include <stdlib.h> |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 28 | #include "config.h" |
Linus Nielsen Feltzing | 34d08b2 | 2007-11-16 08:18:08 +0000 | [diff] [blame] | 29 | #include "system.h" |
Justin Heiner | b5025a8 | 2002-08-31 04:58:35 +0000 | [diff] [blame] | 30 | |
Daniel Stenberg | 1c0c861 | 2002-05-17 12:22:24 +0000 | [diff] [blame] | 31 | #include "lcd.h" |
Daniel Stenberg | 93b231c | 2002-09-12 13:33:59 +0000 | [diff] [blame] | 32 | #include "font.h" |
Justin Heiner | b5025a8 | 2002-08-31 04:58:35 +0000 | [diff] [blame] | 33 | #include "backlight.h" |
Daniel Stenberg | 1c0c861 | 2002-05-17 12:22:24 +0000 | [diff] [blame] | 34 | #include "menu.h" |
Björn Stenberg | b21a3bd | 2002-05-21 14:25:45 +0000 | [diff] [blame] | 35 | #include "button.h" |
| 36 | #include "kernel.h" |
| 37 | #include "debug.h" |
Justin Heiner | 2630245 | 2002-08-23 02:17:00 +0000 | [diff] [blame] | 38 | #include "usb.h" |
Björn Stenberg | cd22573 | 2002-08-11 09:17:47 +0000 | [diff] [blame] | 39 | #include "panic.h" |
Markus Braun | 5e4c1d2 | 2002-08-20 19:37:00 +0000 | [diff] [blame] | 40 | #include "settings.h" |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 41 | #include "settings_list.h" |
Jonathan Gordon | a5278fa | 2007-07-11 05:41:23 +0000 | [diff] [blame] | 42 | #include "option_select.h" |
Björn Stenberg | a4c3b03 | 2002-09-24 18:04:15 +0000 | [diff] [blame] | 43 | #include "screens.h" |
Jörg Hohensohn | 4f36ea8 | 2004-03-14 21:33:53 +0000 | [diff] [blame] | 44 | #include "talk.h" |
Jörg Hohensohn | b1403ee | 2004-07-23 23:01:20 +0000 | [diff] [blame] | 45 | #include "lang.h" |
Linus Nielsen Feltzing | ade5d7b | 2004-07-26 16:06:59 +0000 | [diff] [blame] | 46 | #include "misc.h" |
Linus Nielsen Feltzing | 224c0a1 | 2006-08-15 12:27:07 +0000 | [diff] [blame] | 47 | #include "action.h" |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 48 | #include "menus/exported_menus.h" |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 49 | #include "string.h" |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 50 | #include "root_menu.h" |
| 51 | #include "bookmark.h" |
| 52 | #include "gwps-common.h" /* for fade() */ |
| 53 | #include "audio.h" |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 54 | #include "viewport.h" |
Jonathan Gordon | ea664e0 | 2008-05-03 12:30:40 +0000 | [diff] [blame] | 55 | #include "quickscreen.h" |
Markus Braun | 000c2db | 2002-08-30 13:49:32 +0000 | [diff] [blame] | 56 | |
Daniel Stenberg | bf603f9 | 2002-06-14 08:47:44 +0000 | [diff] [blame] | 57 | #ifdef HAVE_LCD_BITMAP |
| 58 | #include "icons.h" |
| 59 | #endif |
Markus Braun | 000c2db | 2002-08-30 13:49:32 +0000 | [diff] [blame] | 60 | |
Kevin Ferrare | db8415c | 2005-10-30 22:34:51 +0000 | [diff] [blame] | 61 | /* gui api */ |
| 62 | #include "list.h" |
| 63 | #include "statusbar.h" |
| 64 | #include "buttonbar.h" |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 65 | |
Jonathan Gordon | 77a458a | 2007-05-08 11:55:43 +0000 | [diff] [blame] | 66 | #define MAX_MENUS 8 |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 67 | /* used to allow for dynamic menus */ |
| 68 | #define MAX_MENU_SUBITEMS 64 |
Jonathan Gordon | 208136d | 2007-03-17 14:10:51 +0000 | [diff] [blame] | 69 | static struct menu_item_ex *current_submenus_menu; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 70 | static int current_subitems[MAX_MENU_SUBITEMS]; |
| 71 | static int current_subitems_count = 0; |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 72 | static int talk_menu_item(int selected_item, void *data); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 73 | |
Nils Wallménius | f31e123 | 2007-05-19 19:54:11 +0000 | [diff] [blame] | 74 | static void get_menu_callback(const struct menu_item_ex *m, |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 75 | menu_callback_type *menu_callback) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 76 | { |
Jonathan Gordon | 2801a87 | 2007-02-19 02:14:51 +0000 | [diff] [blame] | 77 | if (m->flags&(MENU_HAS_DESC|MENU_DYNAMIC_DESC)) |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 78 | *menu_callback= m->callback_and_desc->menu_callback; |
| 79 | else |
| 80 | *menu_callback = m->menu_callback; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | static int get_menu_selection(int selected_item, const struct menu_item_ex *menu) |
| 84 | { |
| 85 | int type = (menu->flags&MENU_TYPE_MASK); |
| 86 | if (type == MT_MENU && (selected_item<current_subitems_count)) |
| 87 | return current_subitems[selected_item]; |
| 88 | return selected_item; |
| 89 | } |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 90 | static int find_menu_selection(int selected) |
| 91 | { |
| 92 | int i; |
| 93 | for (i=0; i< current_subitems_count; i++) |
| 94 | if (current_subitems[i] == selected) |
| 95 | return i; |
| 96 | return 0; |
| 97 | } |
Nils Wallménius | 6848961 | 2008-04-09 15:25:17 +0000 | [diff] [blame] | 98 | static char * get_menu_item_name(int selected_item, |
| 99 | void * data, |
| 100 | char *buffer, |
| 101 | size_t buffer_len) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 102 | { |
| 103 | const struct menu_item_ex *menu = (const struct menu_item_ex *)data; |
| 104 | int type = (menu->flags&MENU_TYPE_MASK); |
| 105 | selected_item = get_menu_selection(selected_item, menu); |
| 106 | |
Nils Wallménius | 6848961 | 2008-04-09 15:25:17 +0000 | [diff] [blame] | 107 | (void)buffer_len; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 108 | /* only MT_MENU or MT_RETURN_ID is allowed in here */ |
| 109 | if (type == MT_RETURN_ID) |
| 110 | { |
Jonathan Gordon | 2816dc9 | 2007-02-27 09:06:30 +0000 | [diff] [blame] | 111 | if (menu->flags&MENU_DYNAMIC_DESC) |
| 112 | return menu->menu_get_name_and_icon->list_get_name(selected_item, |
| 113 | menu->menu_get_name_and_icon->list_get_name_data, buffer); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 114 | return (char*)menu->strings[selected_item]; |
| 115 | } |
| 116 | |
| 117 | menu = menu->submenus[selected_item]; |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 118 | |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 119 | if ((menu->flags&MENU_DYNAMIC_DESC) && (type != MT_SETTING_W_TEXT)) |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 120 | return menu->menu_get_name_and_icon->list_get_name(selected_item, |
| 121 | menu->menu_get_name_and_icon->list_get_name_data, buffer); |
| 122 | |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 123 | type = (menu->flags&MENU_TYPE_MASK); |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 124 | if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT)) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 125 | { |
| 126 | const struct settings_list *v |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 127 | = find_setting(menu->variable, NULL); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 128 | if (v) |
| 129 | return str(v->lang_id); |
| 130 | else return "Not Done yet!"; |
| 131 | } |
| 132 | return P2STR(menu->callback_and_desc->desc); |
| 133 | } |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 134 | #ifdef HAVE_LCD_BITMAP |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 135 | static int menu_get_icon(int selected_item, void * data) |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 136 | { |
| 137 | const struct menu_item_ex *menu = (const struct menu_item_ex *)data; |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 138 | int menu_icon = Icon_NOICON; |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 139 | selected_item = get_menu_selection(selected_item, menu); |
| 140 | |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 141 | if ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID) |
| 142 | { |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 143 | return Icon_Menu_functioncall; |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 144 | } |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 145 | menu = menu->submenus[selected_item]; |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 146 | if (menu->flags&MENU_HAS_DESC) |
Jonathan Gordon | 02a8717 | 2007-03-03 13:52:14 +0000 | [diff] [blame] | 147 | menu_icon = menu->callback_and_desc->icon_id; |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 148 | else if (menu->flags&MENU_DYNAMIC_DESC) |
Jonathan Gordon | 02a8717 | 2007-03-03 13:52:14 +0000 | [diff] [blame] | 149 | menu_icon = menu->menu_get_name_and_icon->icon_id; |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 150 | |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 151 | if (menu_icon == Icon_NOICON) |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 152 | { |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 153 | switch (menu->flags&MENU_TYPE_MASK) |
| 154 | { |
| 155 | case MT_SETTING: |
| 156 | case MT_SETTING_W_TEXT: |
| 157 | menu_icon = Icon_Menu_setting; |
| 158 | break; |
| 159 | case MT_MENU: |
| 160 | menu_icon = Icon_Submenu; |
| 161 | break; |
| 162 | case MT_FUNCTION_CALL: |
| 163 | case MT_RETURN_VALUE: |
| 164 | menu_icon = Icon_Menu_functioncall; |
| 165 | break; |
| 166 | } |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 167 | } |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 168 | return menu_icon; |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 169 | } |
| 170 | #endif |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 171 | |
| 172 | static void init_menu_lists(const struct menu_item_ex *menu, |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 173 | struct gui_synclist *lists, int selected, bool callback, |
| 174 | struct viewport parent[NB_SCREENS]) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 175 | { |
Jonathan Gordon | b5e587c | 2007-03-18 06:31:33 +0000 | [diff] [blame] | 176 | int i, count = MENU_GET_COUNT(menu->flags); |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 177 | int type = (menu->flags&MENU_TYPE_MASK); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 178 | menu_callback_type menu_callback = NULL; |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 179 | int icon; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 180 | current_subitems_count = 0; |
Jonathan Gordon | 3452146 | 2007-03-07 13:00:46 +0000 | [diff] [blame] | 181 | |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 182 | if (type == MT_RETURN_ID) |
| 183 | get_menu_callback(menu, &menu_callback); |
| 184 | |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 185 | for (i=0; i<count; i++) |
| 186 | { |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 187 | if (type != MT_RETURN_ID) |
| 188 | get_menu_callback(menu->submenus[i],&menu_callback); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 189 | if (menu_callback) |
| 190 | { |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 191 | if (menu_callback(ACTION_REQUEST_MENUITEM, |
| 192 | type==MT_RETURN_ID ? (void*)(intptr_t)i: menu->submenus[i]) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 193 | != ACTION_EXIT_MENUITEM) |
| 194 | { |
| 195 | current_subitems[current_subitems_count] = i; |
| 196 | current_subitems_count++; |
| 197 | } |
| 198 | } |
| 199 | else |
| 200 | { |
| 201 | current_subitems[current_subitems_count] = i; |
| 202 | current_subitems_count++; |
| 203 | } |
| 204 | } |
Jonathan Gordon | 3d39c4d | 2007-03-17 14:16:11 +0000 | [diff] [blame] | 205 | current_submenus_menu = (struct menu_item_ex *)menu; |
Jonathan Gordon | 208136d | 2007-03-17 14:10:51 +0000 | [diff] [blame] | 206 | |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 207 | gui_synclist_init(lists,get_menu_item_name,(void*)menu,false,1, parent); |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 208 | #ifdef HAVE_LCD_BITMAP |
Jonathan Gordon | 02a8717 | 2007-03-03 13:52:14 +0000 | [diff] [blame] | 209 | if (menu->callback_and_desc->icon_id == Icon_NOICON) |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 210 | icon = Icon_Submenu_Entered; |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 211 | else |
Jonathan Gordon | 6a5cc0b | 2007-04-16 09:14:36 +0000 | [diff] [blame] | 212 | icon = menu->callback_and_desc->icon_id; |
Jonathan Gordon | f8e08f0 | 2007-02-15 23:27:57 +0000 | [diff] [blame] | 213 | gui_synclist_set_title(lists, P2STR(menu->callback_and_desc->desc), icon); |
Steve Bavin | 361a60c | 2007-03-01 18:25:13 +0000 | [diff] [blame] | 214 | gui_synclist_set_icon_callback(lists, menu_get_icon); |
Jonathan Gordon | f8e08f0 | 2007-02-15 23:27:57 +0000 | [diff] [blame] | 215 | #else |
| 216 | (void)icon; |
Steve Bavin | 361a60c | 2007-03-01 18:25:13 +0000 | [diff] [blame] | 217 | gui_synclist_set_icon_callback(lists, NULL); |
Jonathan Gordon | 5599d68 | 2007-02-14 06:58:30 +0000 | [diff] [blame] | 218 | #endif |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 219 | if(global_settings.talk_menu) |
| 220 | gui_synclist_set_voice_callback(lists, talk_menu_item); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 221 | gui_synclist_set_nb_items(lists,current_subitems_count); |
| 222 | gui_synclist_limit_scroll(lists,true); |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 223 | gui_synclist_select_item(lists, find_menu_selection(selected)); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 224 | |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 225 | get_menu_callback(menu,&menu_callback); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 226 | if (callback && menu_callback) |
| 227 | menu_callback(ACTION_ENTER_MENUITEM,menu); |
Jonathan Gordon | baf9cf6 | 2007-05-07 08:50:47 +0000 | [diff] [blame] | 228 | gui_synclist_draw(lists); |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 229 | gui_synclist_speak_item(lists); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 230 | } |
| 231 | |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 232 | static int talk_menu_item(int selected_item, void *data) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 233 | { |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 234 | const struct menu_item_ex *menu = (const struct menu_item_ex *)data; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 235 | int id = -1; |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 236 | int type; |
Linus Nielsen Feltzing | 298c2bb | 2007-03-05 00:32:33 +0000 | [diff] [blame] | 237 | unsigned char *str; |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 238 | int sel = get_menu_selection(selected_item, menu); |
Linus Nielsen Feltzing | 298c2bb | 2007-03-05 00:32:33 +0000 | [diff] [blame] | 239 | |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 240 | if ((menu->flags&MENU_TYPE_MASK) == MT_MENU) |
| 241 | { |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 242 | type = menu->submenus[sel]->flags&MENU_TYPE_MASK; |
| 243 | if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT)) |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 244 | talk_setting(menu->submenus[sel]->variable); |
| 245 | else |
| 246 | { |
Linus Nielsen Feltzing | 298c2bb | 2007-03-05 00:32:33 +0000 | [diff] [blame] | 247 | if (menu->submenus[sel]->flags&(MENU_DYNAMIC_DESC)) |
| 248 | { |
Stéphane Doyon | 5acf091 | 2007-10-09 03:48:56 +0000 | [diff] [blame] | 249 | int (*list_speak_item)(int selected_item, void * data) |
| 250 | = menu->submenus[sel]->menu_get_name_and_icon-> |
| 251 | list_speak_item; |
| 252 | if(list_speak_item) |
| 253 | list_speak_item(sel, menu->submenus[sel]-> |
| 254 | menu_get_name_and_icon-> |
| 255 | list_get_name_data); |
| 256 | else |
| 257 | { |
| 258 | char buffer[80]; |
| 259 | str = menu->submenus[sel]->menu_get_name_and_icon-> |
| 260 | list_get_name(sel, menu->submenus[sel]-> |
| 261 | menu_get_name_and_icon-> |
| 262 | list_get_name_data, buffer); |
| 263 | id = P2ID(str); |
| 264 | } |
Linus Nielsen Feltzing | 298c2bb | 2007-03-05 00:32:33 +0000 | [diff] [blame] | 265 | } |
| 266 | else |
| 267 | id = P2ID(menu->submenus[sel]->callback_and_desc->desc); |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 268 | if (id != -1) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 269 | talk_id(id,false); |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 270 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 271 | } |
Jonathan Gordon | 94b9804 | 2007-08-20 09:11:05 +0000 | [diff] [blame] | 272 | else if(((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID)) |
| 273 | { |
| 274 | if ((menu->flags&MENU_DYNAMIC_DESC) == 0) |
| 275 | { |
| 276 | unsigned char *s = (unsigned char *)menu->strings[sel]; |
| 277 | /* string list, try to talk it if ID2P was used */ |
| 278 | id = P2ID(s); |
| 279 | if (id != -1) |
| 280 | talk_id(id,false); |
| 281 | } |
| 282 | } |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 283 | return 0; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 284 | } |
Steve Bavin | cd88e2a | 2008-03-25 15:24:03 +0000 | [diff] [blame] | 285 | |
Steve Bavin | f14999e | 2009-03-10 07:27:13 +0000 | [diff] [blame] | 286 | void do_setting_from_menu(const struct menu_item_ex *temp, |
Jonathan Gordon | fe9dca3 | 2008-04-23 11:07:40 +0000 | [diff] [blame] | 287 | struct viewport parent[NB_SCREENS]) |
Jonathan Gordon | 2801a87 | 2007-02-19 02:14:51 +0000 | [diff] [blame] | 288 | { |
Jonathan Gordon | be185a1 | 2008-03-26 09:05:42 +0000 | [diff] [blame] | 289 | int setting_id, oldval; |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 290 | const struct settings_list *setting = find_setting( |
| 291 | temp->variable, |
| 292 | &setting_id); |
Jonathan Gordon | fe2b376 | 2007-07-23 05:40:45 +0000 | [diff] [blame] | 293 | char *title; |
Jonathan Gordon | 91ccc01 | 2007-11-05 13:15:35 +0000 | [diff] [blame] | 294 | char padded_title[MAX_PATH]; |
Jonathan Gordon | be185a1 | 2008-03-26 09:05:42 +0000 | [diff] [blame] | 295 | int var_type = setting->flags&F_T_MASK; |
| 296 | if (var_type == F_T_INT || var_type == F_T_UINT) |
| 297 | { |
| 298 | oldval = *(int*)setting->setting; |
| 299 | } |
| 300 | else if (var_type == F_T_BOOL) |
| 301 | { |
| 302 | oldval = *(bool*)setting->setting; |
| 303 | } |
| 304 | else |
| 305 | oldval = 0; |
Jonathan Gordon | fe2b376 | 2007-07-23 05:40:45 +0000 | [diff] [blame] | 306 | if ((temp->flags&MENU_TYPE_MASK) == MT_SETTING_W_TEXT) |
| 307 | title = temp->callback_and_desc->desc; |
| 308 | else |
| 309 | title = ID2P(setting->lang_id); |
Jonathan Gordon | 91ccc01 | 2007-11-05 13:15:35 +0000 | [diff] [blame] | 310 | |
Linus Nielsen Feltzing | 34d08b2 | 2007-11-16 08:18:08 +0000 | [diff] [blame] | 311 | /* Pad the title string by repeating it. This is needed |
| 312 | so the scroll settings title can actually be used to |
| 313 | test the setting */ |
Jonathan Gordon | 91ccc01 | 2007-11-05 13:15:35 +0000 | [diff] [blame] | 314 | if (setting->flags&F_PADTITLE) |
| 315 | { |
| 316 | int i = 0, len; |
| 317 | if (setting->lang_id == -1) |
| 318 | title = (char*)setting->cfg_vals; |
| 319 | else |
| 320 | title = P2STR((unsigned char*)title); |
| 321 | len = strlen(title); |
Linus Nielsen Feltzing | 34d08b2 | 2007-11-16 08:18:08 +0000 | [diff] [blame] | 322 | while (i < MAX_PATH-1) |
Jonathan Gordon | 91ccc01 | 2007-11-05 13:15:35 +0000 | [diff] [blame] | 323 | { |
Linus Nielsen Feltzing | 34d08b2 | 2007-11-16 08:18:08 +0000 | [diff] [blame] | 324 | int padlen = MIN(len, MAX_PATH-1-i); |
| 325 | strncpy(&padded_title[i], title, padlen); |
| 326 | i += padlen; |
Jonathan Gordon | 91ccc01 | 2007-11-05 13:15:35 +0000 | [diff] [blame] | 327 | if (i<MAX_PATH-1) |
| 328 | padded_title[i++] = ' '; |
| 329 | } |
| 330 | padded_title[i] = '\0'; |
| 331 | title = padded_title; |
| 332 | } |
| 333 | |
Jonathan Gordon | fe9dca3 | 2008-04-23 11:07:40 +0000 | [diff] [blame] | 334 | option_screen((struct settings_list *)setting, parent, |
Jonathan Gordon | fe2b376 | 2007-07-23 05:40:45 +0000 | [diff] [blame] | 335 | setting->flags&F_TEMPVAR, title); |
Jonathan Gordon | 2801a87 | 2007-02-19 02:14:51 +0000 | [diff] [blame] | 336 | } |
| 337 | |
Jonathan Gordon | 62decc4 | 2007-11-04 12:10:41 +0000 | [diff] [blame] | 338 | /* display a menu */ |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 339 | int do_menu(const struct menu_item_ex *start_menu, int *start_selected, |
| 340 | struct viewport parent[NB_SCREENS], bool hide_bars) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 341 | { |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 342 | int selected = start_selected? *start_selected : 0; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 343 | int action; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 344 | struct gui_synclist lists; |
| 345 | const struct menu_item_ex *temp, *menu; |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 346 | int ret = 0, i; |
Jonathan Gordon | 411f3e2 | 2007-07-11 02:22:03 +0000 | [diff] [blame] | 347 | bool redraw_lists; |
Jonathan Gordon | 036fb05 | 2009-02-01 13:43:08 +0000 | [diff] [blame] | 348 | int oldbars = viewportmanager_set_statusbar( |
| 349 | hide_bars ? VP_SB_HIDE_ALL : VP_SB_ALLSCREENS); |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 350 | |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 351 | const struct menu_item_ex *menu_stack[MAX_MENUS]; |
| 352 | int menu_stack_selected_item[MAX_MENUS]; |
| 353 | int stack_top = 0; |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 354 | bool in_stringlist, done = false; |
Jonathan Gordon | e385ee1 | 2008-12-31 05:59:26 +0000 | [diff] [blame] | 355 | struct viewport *vps = NULL; |
Peter D'Hoye | f76122f | 2008-05-29 20:32:39 +0000 | [diff] [blame] | 356 | #ifdef HAVE_BUTTONBAR |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 357 | struct gui_buttonbar buttonbar; |
| 358 | gui_buttonbar_init(&buttonbar); |
| 359 | gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) ); |
| 360 | gui_buttonbar_set(&buttonbar, "<<<", "", ""); |
| 361 | #endif |
| 362 | |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 363 | menu_callback_type menu_callback = NULL; |
| 364 | if (start_menu == NULL) |
| 365 | menu = &main_menu_; |
| 366 | else menu = start_menu; |
Jonathan Gordon | e385ee1 | 2008-12-31 05:59:26 +0000 | [diff] [blame] | 367 | |
| 368 | /* if hide_bars is true, assume parent has been fixed before passed into |
| 369 | * this function, e.g. with viewport_set_defaults(parent, screen, true) */ |
| 370 | init_menu_lists(menu, &lists, selected, true, parent); |
| 371 | vps = *(lists.parent); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 372 | in_stringlist = ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID); |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 373 | /* load the callback, and only reload it if menu changes */ |
| 374 | get_menu_callback(menu, &menu_callback); |
| 375 | |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 376 | |
Peter D'Hoye | f76122f | 2008-05-29 20:32:39 +0000 | [diff] [blame] | 377 | #ifdef HAVE_BUTTONBAR |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 378 | if (!hide_bars) |
| 379 | { |
| 380 | gui_buttonbar_set(&buttonbar, "<<<", "", ""); |
| 381 | gui_buttonbar_draw(&buttonbar); |
| 382 | } |
| 383 | #endif |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 384 | while (!done) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 385 | { |
Jonathan Gordon | 411f3e2 | 2007-07-11 02:22:03 +0000 | [diff] [blame] | 386 | redraw_lists = false; |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 387 | if (!hide_bars) |
| 388 | { |
Jonathan Gordon | c7fec13 | 2008-12-01 09:28:14 +0000 | [diff] [blame] | 389 | #ifdef HAVE_BUTTONBAR |
| 390 | gui_buttonbar_draw(&buttonbar); |
| 391 | #endif |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 392 | } |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 393 | action = get_action(CONTEXT_MAINMENU, |
| 394 | list_do_action_timeout(&lists, HZ)); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 395 | /* HZ so the status bar redraws corectly */ |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 396 | |
Jonathan Gordon | fdd4050 | 2008-10-30 07:07:45 +0000 | [diff] [blame] | 397 | if (menu_callback) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 398 | { |
Jonathan Gordon | 9144be5 | 2007-02-27 09:16:47 +0000 | [diff] [blame] | 399 | int old_action = action; |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 400 | action = menu_callback(action, menu); |
Jonathan Gordon | 9144be5 | 2007-02-27 09:16:47 +0000 | [diff] [blame] | 401 | if (action == ACTION_EXIT_AFTER_THIS_MENUITEM) |
| 402 | { |
| 403 | action = old_action; |
| 404 | ret = MENU_SELECTED_EXIT; /* will exit after returning |
| 405 | from selection */ |
| 406 | } |
Jonathan Gordon | 411f3e2 | 2007-07-11 02:22:03 +0000 | [diff] [blame] | 407 | else if (action == ACTION_REDRAW) |
| 408 | { |
| 409 | action = old_action; |
| 410 | redraw_lists = true; |
| 411 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 412 | } |
| 413 | |
Jonathan Gordon | cf1cef5 | 2007-09-17 10:08:50 +0000 | [diff] [blame] | 414 | if (gui_synclist_do_button(&lists, &action, LIST_WRAP_UNLESS_HELD)) |
Jonathan Gordon | b9f22af | 2007-07-11 01:23:57 +0000 | [diff] [blame] | 415 | continue; |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 416 | if (action == ACTION_NONE) |
| 417 | continue; |
Jonathan Gordon | 286d48f | 2008-04-23 10:33:46 +0000 | [diff] [blame] | 418 | #ifdef HAVE_QUICKSCREEN |
| 419 | else if (action == ACTION_STD_QUICKSCREEN) |
| 420 | { |
| 421 | quick_screen_quick(action); |
| 422 | redraw_lists = true; |
| 423 | } |
| 424 | #endif |
Jonathan Gordon | 73336e9 | 2007-08-02 12:13:20 +0000 | [diff] [blame] | 425 | #ifdef HAVE_RECORDING |
Jonathan Gordon | 286d48f | 2008-04-23 10:33:46 +0000 | [diff] [blame] | 426 | else if (action == ACTION_STD_REC) |
Jonathan Gordon | 73336e9 | 2007-08-02 12:13:20 +0000 | [diff] [blame] | 427 | { |
| 428 | ret = GO_TO_RECSCREEN; |
| 429 | done = true; |
| 430 | } |
Jonathan Gordon | 73336e9 | 2007-08-02 12:13:20 +0000 | [diff] [blame] | 431 | #endif |
Jonathan Gordon | 286d48f | 2008-04-23 10:33:46 +0000 | [diff] [blame] | 432 | else if (action == ACTION_TREE_WPS) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 433 | { |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 434 | ret = GO_TO_PREVIOUS_MUSIC; |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 435 | done = true; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 436 | } |
Jonathan Gordon | a053e58 | 2007-04-08 01:33:01 +0000 | [diff] [blame] | 437 | else if (action == ACTION_TREE_STOP) |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 438 | { |
Magnus Holmgren | 1d9f693 | 2007-08-05 15:21:47 +0000 | [diff] [blame] | 439 | redraw_lists = list_stop_handler(); |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 440 | } |
Jonathan Gordon | a22749b | 2008-11-05 09:30:20 +0000 | [diff] [blame] | 441 | else if (action == ACTION_STD_CONTEXT) |
Jonathan Gordon | f9fb492 | 2007-04-12 15:28:51 +0000 | [diff] [blame] | 442 | { |
Jonathan Gordon | a22749b | 2008-11-05 09:30:20 +0000 | [diff] [blame] | 443 | if (menu == &root_menu_) |
| 444 | { |
| 445 | ret = GO_TO_ROOTITEM_CONTEXT; |
| 446 | done = true; |
| 447 | } |
| 448 | else if (!in_stringlist) |
| 449 | { |
| 450 | int type; |
Jonathan Gordon | e385ee1 | 2008-12-31 05:59:26 +0000 | [diff] [blame] | 451 | selected = get_menu_selection(gui_synclist_get_sel_pos(&lists),menu); |
Jonathan Gordon | a22749b | 2008-11-05 09:30:20 +0000 | [diff] [blame] | 452 | temp = menu->submenus[selected]; |
| 453 | type = (temp->flags&MENU_TYPE_MASK); |
| 454 | if ((type == MT_SETTING_W_TEXT || type == MT_SETTING)) |
| 455 | { |
| 456 | #ifdef HAVE_QUICKSCREEN |
| 457 | MENUITEM_STRINGLIST(quickscreen_able_option, |
| 458 | ID2P(LANG_ONPLAY_MENU_TITLE), NULL, |
| 459 | ID2P(LANG_RESET_SETTING), |
| 460 | ID2P(LANG_LEFT_QS_ITEM), |
| 461 | ID2P(LANG_BOTTOM_QS_ITEM), |
| 462 | ID2P(LANG_RIGHT_QS_ITEM)); |
| 463 | #endif |
| 464 | MENUITEM_STRINGLIST(notquickscreen_able_option, |
| 465 | ID2P(LANG_ONPLAY_MENU_TITLE), NULL, |
| 466 | ID2P(LANG_RESET_SETTING)); |
| 467 | const struct menu_item_ex *menu; |
| 468 | int menu_selection = 0; |
| 469 | const struct settings_list *setting = |
| 470 | find_setting(temp->variable, NULL); |
| 471 | #ifdef HAVE_QUICKSCREEN |
| 472 | if (is_setting_quickscreenable(setting)) |
| 473 | menu = &quickscreen_able_option; |
| 474 | else |
| 475 | #endif |
| 476 | menu = ¬quickscreen_able_option; |
| 477 | switch (do_menu(menu, &menu_selection, NULL, false)) |
| 478 | { |
| 479 | case GO_TO_PREVIOUS: |
| 480 | break; |
| 481 | case 0: /* reset setting */ |
| 482 | reset_setting(setting, setting->setting); |
| 483 | break; |
| 484 | #ifdef HAVE_QUICKSCREEN |
| 485 | break; |
| 486 | case 1: /* set as left QS item */ |
| 487 | set_as_qs_item(setting, QUICKSCREEN_LEFT); |
| 488 | break; |
| 489 | case 2: /* set as bottom QS item */ |
| 490 | set_as_qs_item(setting, QUICKSCREEN_BOTTOM); |
| 491 | break; |
| 492 | case 3: /* set as right QS item */ |
| 493 | set_as_qs_item(setting, QUICKSCREEN_RIGHT); |
| 494 | break; |
| 495 | #endif |
| 496 | } /* swicth(do_menu()) */ |
| 497 | redraw_lists = true; |
| 498 | } |
| 499 | } /* else if (!in_stringlist) */ |
| 500 | } |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 501 | else if (action == ACTION_STD_MENU) |
| 502 | { |
| 503 | if (menu != &root_menu_) |
| 504 | ret = GO_TO_ROOT; |
Jonathan Gordon | a74eefe | 2007-03-06 13:35:15 +0000 | [diff] [blame] | 505 | else |
| 506 | ret = GO_TO_PREVIOUS; |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 507 | done = true; |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 508 | } |
| 509 | else if (action == ACTION_STD_CANCEL) |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 510 | { |
Jonathan Gordon | 5cab5da | 2007-11-07 10:06:21 +0000 | [diff] [blame] | 511 | bool exiting_menu = false; |
Linus Nielsen Feltzing | 6ffd804 | 2007-02-16 10:40:59 +0000 | [diff] [blame] | 512 | in_stringlist = false; |
Peter D'Hoye | c5383c1 | 2008-10-13 22:08:01 +0000 | [diff] [blame] | 513 | /* might be leaving list, so stop scrolling */ |
| 514 | FOR_NB_SCREENS(i) |
| 515 | { |
| 516 | screens[i].stop_scroll(); |
| 517 | } |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 518 | if (menu_callback) |
| 519 | menu_callback(ACTION_EXIT_MENUITEM, menu); |
Peter D'Hoye | c5383c1 | 2008-10-13 22:08:01 +0000 | [diff] [blame] | 520 | |
Jonathan Gordon | 3a7760c | 2007-04-30 13:41:33 +0000 | [diff] [blame] | 521 | if (menu->flags&MENU_EXITAFTERTHISMENU) |
| 522 | done = true; |
Jonathan Gordon | 5cab5da | 2007-11-07 10:06:21 +0000 | [diff] [blame] | 523 | else if ((menu->flags&MENU_TYPE_MASK) == MT_MENU) |
| 524 | exiting_menu = true; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 525 | if (stack_top > 0) |
| 526 | { |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 527 | stack_top--; |
| 528 | menu = menu_stack[stack_top]; |
Jonathan Gordon | 5cab5da | 2007-11-07 10:06:21 +0000 | [diff] [blame] | 529 | if (!exiting_menu && (menu->flags&MENU_EXITAFTERTHISMENU)) |
Jonathan Gordon | 3a7760c | 2007-04-30 13:41:33 +0000 | [diff] [blame] | 530 | done = true; |
Jonathan Gordon | 75e2f19 | 2007-08-04 09:47:17 +0000 | [diff] [blame] | 531 | else |
| 532 | init_menu_lists(menu, &lists, |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 533 | menu_stack_selected_item[stack_top], false, vps); |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 534 | /* new menu, so reload the callback */ |
Jonathan Gordon | 1ea4f0d | 2007-02-16 00:55:52 +0000 | [diff] [blame] | 535 | get_menu_callback(menu, &menu_callback); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 536 | } |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 537 | else if (menu != &root_menu_) |
| 538 | { |
| 539 | ret = GO_TO_PREVIOUS; |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 540 | done = true; |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 541 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 542 | } |
| 543 | else if (action == ACTION_STD_OK) |
| 544 | { |
| 545 | int type; |
Peter D'Hoye | c5383c1 | 2008-10-13 22:08:01 +0000 | [diff] [blame] | 546 | /* entering an item that may not be a list, so stop scrolling */ |
| 547 | FOR_NB_SCREENS(i) |
| 548 | { |
| 549 | screens[i].stop_scroll(); |
| 550 | } |
Peter D'Hoye | f76122f | 2008-05-29 20:32:39 +0000 | [diff] [blame] | 551 | #ifdef HAVE_BUTTONBAR |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 552 | if (!hide_bars) |
| 553 | { |
| 554 | gui_buttonbar_unset(&buttonbar); |
| 555 | gui_buttonbar_draw(&buttonbar); |
| 556 | } |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 557 | #endif |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 558 | selected = get_menu_selection(gui_synclist_get_sel_pos(&lists), menu); |
| 559 | temp = menu->submenus[selected]; |
Jonathan Gordon | 50dc0ca | 2007-07-11 04:17:43 +0000 | [diff] [blame] | 560 | redraw_lists = true; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 561 | if (in_stringlist) |
| 562 | type = (menu->flags&MENU_TYPE_MASK); |
Jonathan Gordon | fe3cfcc | 2007-02-08 10:28:42 +0000 | [diff] [blame] | 563 | else |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 564 | { |
Jonathan Gordon | 1f5ee2a | 2007-03-25 14:31:56 +0000 | [diff] [blame] | 565 | type = (temp->flags&MENU_TYPE_MASK); |
| 566 | get_menu_callback(temp, &menu_callback); |
| 567 | if (menu_callback) |
| 568 | { |
| 569 | action = menu_callback(ACTION_ENTER_MENUITEM,temp); |
| 570 | if (action == ACTION_EXIT_MENUITEM) |
| 571 | break; |
| 572 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 573 | } |
| 574 | switch (type) |
| 575 | { |
| 576 | case MT_MENU: |
| 577 | if (stack_top < MAX_MENUS) |
| 578 | { |
| 579 | menu_stack[stack_top] = menu; |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 580 | menu_stack_selected_item[stack_top] = selected; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 581 | stack_top++; |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 582 | init_menu_lists(temp, &lists, 0, true, vps); |
Jonathan Gordon | 50dc0ca | 2007-07-11 04:17:43 +0000 | [diff] [blame] | 583 | redraw_lists = false; /* above does the redraw */ |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 584 | menu = temp; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 585 | } |
| 586 | break; |
| 587 | case MT_FUNCTION_CALL: |
Jonathan Gordon | daf6694 | 2007-03-17 12:33:34 +0000 | [diff] [blame] | 588 | { |
| 589 | int return_value; |
Jonathan Gordon | daf6694 | 2007-03-17 12:33:34 +0000 | [diff] [blame] | 590 | if (temp->flags&MENU_FUNC_USEPARAM) |
| 591 | return_value = temp->function->function_w_param( |
| 592 | temp->function->param); |
| 593 | else |
| 594 | return_value = temp->function->function(); |
Jonathan Gordon | e385ee1 | 2008-12-31 05:59:26 +0000 | [diff] [blame] | 595 | if (!(menu->flags&MENU_EXITAFTERTHISMENU) || |
| 596 | (temp->flags&MENU_EXITAFTERTHISMENU)) |
Jonathan Gordon | 6d20795 | 2008-04-30 10:22:39 +0000 | [diff] [blame] | 597 | { |
Jonathan Gordon | 6d20795 | 2008-04-30 10:22:39 +0000 | [diff] [blame] | 598 | init_menu_lists(menu, &lists, selected, true, vps); |
| 599 | } |
Jonathan Gordon | daf6694 | 2007-03-17 12:33:34 +0000 | [diff] [blame] | 600 | if (temp->flags&MENU_FUNC_CHECK_RETVAL) |
| 601 | { |
Jonathan Gordon | fdd4050 | 2008-10-30 07:07:45 +0000 | [diff] [blame] | 602 | if (return_value != 0) |
Jonathan Gordon | b5e587c | 2007-03-18 06:31:33 +0000 | [diff] [blame] | 603 | { |
| 604 | done = true; |
| 605 | ret = return_value; |
| 606 | } |
Jonathan Gordon | daf6694 | 2007-03-17 12:33:34 +0000 | [diff] [blame] | 607 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 608 | break; |
Jonathan Gordon | daf6694 | 2007-03-17 12:33:34 +0000 | [diff] [blame] | 609 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 610 | case MT_SETTING: |
Jonathan Gordon | 9709086 | 2007-03-03 14:23:03 +0000 | [diff] [blame] | 611 | case MT_SETTING_W_TEXT: |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 612 | { |
Steve Bavin | f14999e | 2009-03-10 07:27:13 +0000 | [diff] [blame] | 613 | do_setting_from_menu(temp, vps); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 614 | break; |
| 615 | } |
| 616 | case MT_RETURN_ID: |
| 617 | if (in_stringlist) |
| 618 | { |
Jonathan Gordon | b5e587c | 2007-03-18 06:31:33 +0000 | [diff] [blame] | 619 | done = true; |
| 620 | ret = selected; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 621 | } |
| 622 | else if (stack_top < MAX_MENUS) |
| 623 | { |
| 624 | menu_stack[stack_top] = menu; |
| 625 | menu_stack_selected_item[stack_top] = selected; |
| 626 | stack_top++; |
| 627 | menu = temp; |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 628 | init_menu_lists(menu,&lists,0,false, vps); |
Jonathan Gordon | 50dc0ca | 2007-07-11 04:17:43 +0000 | [diff] [blame] | 629 | redraw_lists = false; /* above does the redraw */ |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 630 | in_stringlist = true; |
| 631 | } |
| 632 | break; |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 633 | case MT_RETURN_VALUE: |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 634 | ret = temp->value; |
| 635 | done = true; |
| 636 | break; |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 637 | } |
Jonathan Gordon | 3a7760c | 2007-04-30 13:41:33 +0000 | [diff] [blame] | 638 | if (type != MT_MENU) |
| 639 | { |
| 640 | if (menu_callback) |
| 641 | menu_callback(ACTION_EXIT_MENUITEM,temp); |
| 642 | } |
Jonathan Gordon | 208136d | 2007-03-17 14:10:51 +0000 | [diff] [blame] | 643 | if (current_submenus_menu != menu) |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 644 | init_menu_lists(menu,&lists,selected,true,vps); |
Jonathan Gordon | d563cb2 | 2007-02-21 12:22:07 +0000 | [diff] [blame] | 645 | /* callback was changed, so reload the menu's callback */ |
| 646 | get_menu_callback(menu, &menu_callback); |
Jonathan Gordon | 3a7760c | 2007-04-30 13:41:33 +0000 | [diff] [blame] | 647 | if ((menu->flags&MENU_EXITAFTERTHISMENU) && |
| 648 | !(temp->flags&MENU_EXITAFTERTHISMENU)) |
| 649 | { |
| 650 | done = true; |
| 651 | break; |
| 652 | } |
Peter D'Hoye | f76122f | 2008-05-29 20:32:39 +0000 | [diff] [blame] | 653 | #ifdef HAVE_BUTTONBAR |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 654 | if (!hide_bars) |
| 655 | { |
| 656 | gui_buttonbar_set(&buttonbar, "<<<", "", ""); |
| 657 | gui_buttonbar_draw(&buttonbar); |
| 658 | } |
Jonathan Gordon | 1ba493e | 2007-02-26 08:17:07 +0000 | [diff] [blame] | 659 | #endif |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 660 | } |
| 661 | else if(default_event_handler(action) == SYS_USB_CONNECTED) |
Peter D'Hoye | d2b3055 | 2007-03-30 21:54:48 +0000 | [diff] [blame] | 662 | { |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 663 | ret = MENU_ATTACHED_USB; |
Peter D'Hoye | d2b3055 | 2007-03-30 21:54:48 +0000 | [diff] [blame] | 664 | done = true; |
| 665 | } |
Jonathan Gordon | 411f3e2 | 2007-07-11 02:22:03 +0000 | [diff] [blame] | 666 | |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 667 | if (redraw_lists && !done) |
| 668 | { |
Jonathan Gordon | fdd4050 | 2008-10-30 07:07:45 +0000 | [diff] [blame] | 669 | if (menu_callback) |
| 670 | menu_callback(ACTION_REDRAW, menu); |
Jonathan Gordon | 411f3e2 | 2007-07-11 02:22:03 +0000 | [diff] [blame] | 671 | gui_synclist_draw(&lists); |
Stéphane Doyon | 4e09b78 | 2007-10-21 00:23:23 +0000 | [diff] [blame] | 672 | gui_synclist_speak_item(&lists); |
| 673 | } |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 674 | } |
Jonathan Gordon | 91cb68a | 2007-03-01 11:14:46 +0000 | [diff] [blame] | 675 | if (start_selected) |
Jonathan Gordon | fd9d140 | 2007-05-20 14:24:02 +0000 | [diff] [blame] | 676 | { |
| 677 | /* make sure the start_selected variable is set to |
| 678 | the selected item from the menu do_menu() was called from */ |
| 679 | if (stack_top > 0) |
| 680 | { |
| 681 | menu = menu_stack[0]; |
Jonathan Gordon | 5ca1539 | 2008-03-26 03:35:24 +0000 | [diff] [blame] | 682 | init_menu_lists(menu,&lists,menu_stack_selected_item[0],true, vps); |
Jonathan Gordon | fd9d140 | 2007-05-20 14:24:02 +0000 | [diff] [blame] | 683 | } |
Jonathan Gordon | 43b2d09 | 2007-03-07 10:13:07 +0000 | [diff] [blame] | 684 | *start_selected = get_menu_selection( |
| 685 | gui_synclist_get_sel_pos(&lists), menu); |
Jonathan Gordon | fd9d140 | 2007-05-20 14:24:02 +0000 | [diff] [blame] | 686 | } |
Jonathan Gordon | 4b472de | 2009-01-03 13:27:19 +0000 | [diff] [blame] | 687 | viewportmanager_set_statusbar(oldbars); |
Jonathan Gordon | 4718a1e | 2007-02-08 04:33:41 +0000 | [diff] [blame] | 688 | return ret; |
| 689 | } |
| 690 | |