apps/menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Robert E. Hak
  11  *
  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.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 /*
  20 2005 Kevin Ferrare :
  21  - Multi screen support
  22  - Rewrote/removed a lot of code now useless with the new gui API
  23 */
  24 #include <stdbool.h>
  25 #include <stdlib.h>
  26 #include "config.h"
  27
  28 #include "lcd.h"
  29 #include "font.h"
  30 #include "backlight.h"
  31 #include "menu.h"
  32 #include "button.h"
  33 #include "kernel.h"
  34 #include "debug.h"
  35 #include "usb.h"
  36 #include "panic.h"
  37 #include "settings.h"
  38 #include "settings_list.h"
  39 #include "option_select.h"
  40 #include "status.h"
  41 #include "screens.h"
  42 #include "talk.h"
  43 #include "lang.h"
  44 #include "misc.h"
  45 #include "action.h"
  46 #include "menus/exported_menus.h"
  47 #include "string.h"
  48 #include "root_menu.h"
  49 #include "bookmark.h"
  50 #include "gwps-common.h" /* for fade() */
  51 #include "audio.h"
  52
  53 #ifdef HAVE_LCD_BITMAP
  54 #include "icons.h"
  55 #endif
  56
  57 /* gui api */
  58 #include "list.h"
  59 #include "statusbar.h"
  60 #include "buttonbar.h"
  61
  62 #define MAX_MENUS 8
  63 /* used to allow for dynamic menus */
  64 #define MAX_MENU_SUBITEMS 64
  65 static struct menu_item_ex *current_submenus_menu;
  66 static int current_subitems[MAX_MENU_SUBITEMS];
  67 static int current_subitems_count = 0;
  68
  69 static void get_menu_callback(const struct menu_item_ex *m,
  70                         menu_callback_type *menu_callback)
  71 {
  72     if (m->flags&(MENU_HAS_DESC|MENU_DYNAMIC_DESC))
  73         *menu_callback= m->callback_and_desc->menu_callback;
  74     else
  75         *menu_callback = m->menu_callback;
  76 }
  77
  78 static int get_menu_selection(int selected_item, const struct menu_item_ex *menu)
  79 {
  80     int type = (menu->flags&MENU_TYPE_MASK);
  81     if (type == MT_MENU && (selected_item<current_subitems_count))
  82         return current_subitems[selected_item];
  83     return selected_item;
  84 }
  85 static int find_menu_selection(int selected)
  86 {
  87     int i;
  88     for (i=0; i< current_subitems_count; i++)
  89         if (current_subitems[i] == selected)
  90             return i;
  91     return 0;
  92 }
  93 static char * get_menu_item_name(int selected_item,void * data, char *buffer)
  94 {
  95     const struct menu_item_ex *menu = (const struct menu_item_ex *)data;
  96     int type = (menu->flags&MENU_TYPE_MASK);
  97     selected_item = get_menu_selection(selected_item, menu);
  98
  99     (void)buffer;
 100     /* only MT_MENU or MT_RETURN_ID is allowed in here */
 101     if (type == MT_RETURN_ID)
 102     {
 103         if (menu->flags&MENU_DYNAMIC_DESC)
 104             return menu->menu_get_name_and_icon->list_get_name(selected_item,
 105                     menu->menu_get_name_and_icon->list_get_name_data, buffer);
 106         return (char*)menu->strings[selected_item];
 107     }
 108
 109     menu = menu->submenus[selected_item];
 110
 111     if ((menu->flags&MENU_DYNAMIC_DESC) && (type != MT_SETTING_W_TEXT))
 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);
 114
 115     type = (menu->flags&MENU_TYPE_MASK);
 116     if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT))
 117     {
 118         const struct settings_list *v
 119                 = find_setting(menu->variable, NULL);
 120         if (v)
 121             return str(v->lang_id);
 122         else return "Not Done yet!";
 123     }
 124     return P2STR(menu->callback_and_desc->desc);
 125 }
 126 #ifdef HAVE_LCD_BITMAP
 127 static int menu_get_icon(int selected_item, void * data)
 128 {
 129     const struct menu_item_ex *menu = (const struct menu_item_ex *)data;
 130     int menu_icon = Icon_NOICON;
 131     selected_item = get_menu_selection(selected_item, menu);
 132
 133     if ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID)
 134     {
 135         return Icon_Menu_functioncall;
 136     }
 137     menu = menu->submenus[selected_item];
 138     if (menu->flags&MENU_HAS_DESC)
 139         menu_icon = menu->callback_and_desc->icon_id;
 140     else if (menu->flags&MENU_DYNAMIC_DESC)
 141         menu_icon = menu->menu_get_name_and_icon->icon_id;
 142
 143     if (menu_icon == Icon_NOICON)
 144     {
 145         switch (menu->flags&MENU_TYPE_MASK)
 146         {
 147             case MT_SETTING:
 148             case MT_SETTING_W_TEXT:
 149                 menu_icon = Icon_Menu_setting;
 150                 break;
 151             case MT_MENU:
 152                     menu_icon = Icon_Submenu;
 153                 break;
 154             case MT_FUNCTION_CALL:
 155             case MT_RETURN_VALUE:
 156                 menu_icon = Icon_Menu_functioncall;
 157                 break;
 158         }
 159     }
 160     return menu_icon;
 161 }
 162 #endif
 163
 164 static void init_menu_lists(const struct menu_item_ex *menu,
 165                      struct gui_synclist *lists, int selected, bool callback)
 166 {
 167     int i, count = MENU_GET_COUNT(menu->flags);
 168     int type = (menu->flags&MENU_TYPE_MASK);
 169     menu_callback_type menu_callback = NULL;
 170     int icon;
 171     current_subitems_count = 0;
 172
 173     if (type == MT_RETURN_ID)
 174         get_menu_callback(menu, &menu_callback);
 175
 176     for (i=0; i<count; i++)
 177     {
 178         if (type != MT_RETURN_ID)
 179             get_menu_callback(menu->submenus[i],&menu_callback);
 180         if (menu_callback)
 181         {
 182             if (menu_callback(ACTION_REQUEST_MENUITEM,
 183                     type==MT_RETURN_ID ? (void*)(intptr_t)i: menu->submenus[i])
 184                     != ACTION_EXIT_MENUITEM)
 185             {
 186                 current_subitems[current_subitems_count] = i;
 187                 current_subitems_count++;
 188             }
 189         }
 190         else
 191         {
 192             current_subitems[current_subitems_count] = i;
 193             current_subitems_count++;
 194         }
 195     }
 196     current_submenus_menu = (struct menu_item_ex *)menu;
 197
 198     gui_synclist_init(lists,get_menu_item_name,(void*)menu,false,1);
 199 #ifdef HAVE_LCD_BITMAP
 200     if (menu->callback_and_desc->icon_id == Icon_NOICON)
 201         icon = Icon_Submenu_Entered;
 202     else
 203         icon = menu->callback_and_desc->icon_id;
 204     gui_synclist_set_title(lists, P2STR(menu->callback_and_desc->desc), icon);
 205     gui_synclist_set_icon_callback(lists, menu_get_icon);
 206 #else
 207     (void)icon;
 208     gui_synclist_set_icon_callback(lists, NULL);
 209 #endif
 210     gui_synclist_set_nb_items(lists,current_subitems_count);
 211     gui_synclist_limit_scroll(lists,true);
 212     gui_synclist_select_item(lists, find_menu_selection(selected));
 213
 214     get_menu_callback(menu,&menu_callback);
 215     if (callback && menu_callback)
 216         menu_callback(ACTION_ENTER_MENUITEM,menu);
 217     gui_synclist_draw(lists);
 218 }
 219
 220 static void talk_menu_item(const struct menu_item_ex *menu,
 221                     struct gui_synclist *lists)
 222 {
 223     int id = -1;
 224     int type;
 225     unsigned char *str;
 226     int sel;
 227
 228     if (global_settings.talk_menu)
 229     {
 230         sel = get_menu_selection(gui_synclist_get_sel_pos(lists),menu);
 231         if ((menu->flags&MENU_TYPE_MASK) == MT_MENU)
 232         {
 233             type = menu->submenus[sel]->flags&MENU_TYPE_MASK;
 234             if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT))
 235                 talk_setting(menu->submenus[sel]->variable);
 236             else
 237             {
 238                 if (menu->submenus[sel]->flags&(MENU_DYNAMIC_DESC))
 239                 {
 240                     int (*list_speak_item)(int selected_item, void * data)
 241                         = menu->submenus[sel]->menu_get_name_and_icon->
 242                         list_speak_item;
 243                     if(list_speak_item)
 244                         list_speak_item(sel, menu->submenus[sel]->
 245                                         menu_get_name_and_icon->
 246                                         list_get_name_data);
 247                     else
 248                     {
 249                         char buffer[80];
 250                         str = menu->submenus[sel]->menu_get_name_and_icon->
 251                             list_get_name(sel, menu->submenus[sel]->
 252                                           menu_get_name_and_icon->
 253                                           list_get_name_data, buffer);
 254                         id = P2ID(str);
 255                     }
 256                 }
 257                 else
 258                     id = P2ID(menu->submenus[sel]->callback_and_desc->desc);
 259                 if (id != -1)
 260                    talk_id(id,false);
 261             }
 262         }
 263         else if(((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID))
 264         {
 265             if ((menu->flags&MENU_DYNAMIC_DESC) == 0)
 266             {
 267                 unsigned char *s = (unsigned char *)menu->strings[sel];
 268                 /* string list, try to talk it if ID2P was used */
 269                 id = P2ID(s);
 270                 if (id != -1)
 271                     talk_id(id,false);
 272             }
 273         }
 274     }
 275 }
 276 #define MAX_OPTIONS 32
 277 bool do_setting_from_menu(const struct menu_item_ex *temp)
 278 {
 279     int setting_id;
 280     const struct settings_list *setting = find_setting(
 281                                                temp->variable,
 282                                                &setting_id);
 283     char *title;
 284     if ((temp->flags&MENU_TYPE_MASK) == MT_SETTING_W_TEXT)
 285         title = temp->callback_and_desc->desc;
 286     else
 287         title = ID2P(setting->lang_id);
 288     option_screen((struct settings_list *)setting,
 289                   setting->flags&F_TEMPVAR, title);
 290     return false;
 291 }
 292
 293 int do_menu(const struct menu_item_ex *start_menu, int *start_selected)
 294 {
 295     int selected = start_selected? *start_selected : 0;
 296     int action;
 297     struct gui_synclist lists;
 298     const struct menu_item_ex *temp, *menu;
 299     int ret = 0;
 300     bool redraw_lists;
 301 #ifdef HAS_BUTTONBAR
 302     struct gui_buttonbar buttonbar;
 303 #endif
 304
 305     const struct menu_item_ex *menu_stack[MAX_MENUS];
 306     int menu_stack_selected_item[MAX_MENUS];
 307     int stack_top = 0;
 308     bool in_stringlist, done = false;
 309     menu_callback_type menu_callback = NULL;
 310     bool talk_item = false;
 311     if (start_menu == NULL)
 312         menu = &main_menu_;
 313     else menu = start_menu;
 314 #ifdef HAS_BUTTONBAR
 315     gui_buttonbar_init(&buttonbar);
 316     gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
 317     gui_buttonbar_set(&buttonbar, "<<<", "", "");
 318     gui_buttonbar_draw(&buttonbar);
 319 #endif
 320     init_menu_lists(menu,&lists,selected,true);
 321     in_stringlist = ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID);
 322
 323     talk_menu_item(menu, &lists);
 324
 325     /* load the callback, and only reload it if menu changes */
 326     get_menu_callback(menu, &menu_callback);
 327     gui_synclist_draw(&lists);
 328
 329     while (!done)
 330     {
 331         talk_item = false;
 332         redraw_lists = false;
 333         gui_syncstatusbar_draw(&statusbars, true);
 334         action = get_action(CONTEXT_MAINMENU,HZ);
 335         /* HZ so the status bar redraws corectly */
 336         if (action == ACTION_NONE)
 337         {
 338             continue;
 339         }
 340
 341         if (menu_callback)
 342         {
 343             int old_action = action;
 344             action = menu_callback(action, menu);
 345             if (action == ACTION_EXIT_AFTER_THIS_MENUITEM)
 346             {
 347                 action = old_action;
 348                 ret = MENU_SELECTED_EXIT; /* will exit after returning
 349                                              from selection */
 350             }
 351             else if (action == ACTION_REDRAW)
 352             {
 353                 action = old_action;
 354                 redraw_lists = true;
 355             }
 356         }
 357
 358         if (gui_synclist_do_button(&lists, &action, LIST_WRAP_UNLESS_HELD))
 359         {
 360             talk_menu_item(menu, &lists);
 361             continue;
 362         }
 363
 364 #ifdef HAVE_RECORDING
 365         if (action == ACTION_STD_REC)
 366         {
 367             ret = GO_TO_RECSCREEN;
 368             done = true;
 369         }
 370         else
 371 #endif
 372         if (action == ACTION_TREE_WPS)
 373         {
 374             ret = GO_TO_PREVIOUS_MUSIC;
 375             done = true;
 376         }
 377         else if (action == ACTION_TREE_STOP)
 378         {
 379             redraw_lists = list_stop_handler();
 380         }
 381         else if (action == ACTION_STD_CONTEXT &&
 382                  menu == &root_menu_)
 383         {
 384             ret = GO_TO_ROOTITEM_CONTEXT;
 385             done = true;
 386         }
 387         else if (action == ACTION_STD_MENU)
 388         {
 389             if (menu != &root_menu_)
 390                 ret = GO_TO_ROOT;
 391             else
 392                 ret = GO_TO_PREVIOUS;
 393             done = true;
 394         }
 395         else if (action == ACTION_STD_CANCEL)
 396         {
 397             in_stringlist = false;
 398             if (menu_callback)
 399                 menu_callback(ACTION_EXIT_MENUITEM, menu);
 400
 401             if (menu->flags&MENU_EXITAFTERTHISMENU)
 402                 done = true;
 403             if (stack_top > 0)
 404             {
 405                 stack_top--;
 406                 menu = menu_stack[stack_top];
 407                 if (menu->flags&MENU_EXITAFTERTHISMENU)
 408                     done = true;
 409                 else
 410                     init_menu_lists(menu, &lists,
 411                                  menu_stack_selected_item[stack_top], false);
 412                 /* new menu, so reload the callback */
 413                 get_menu_callback(menu, &menu_callback);
 414                 talk_item = true;
 415             }
 416             else if (menu != &root_menu_)
 417             {
 418                 ret = GO_TO_PREVIOUS;
 419                 done = true;
 420             }
 421         }
 422         else if (action == ACTION_STD_OK)
 423         {
 424             int type;
 425 #ifdef HAS_BUTTONBAR
 426             gui_buttonbar_unset(&buttonbar);
 427             gui_buttonbar_draw(&buttonbar);
 428 #endif
 429             selected = get_menu_selection(gui_synclist_get_sel_pos(&lists), menu);
 430             temp = menu->submenus[selected];
 431             redraw_lists = true;
 432             if (in_stringlist)
 433                 type = (menu->flags&MENU_TYPE_MASK);
 434             else
 435             {
 436                 type = (temp->flags&MENU_TYPE_MASK);
 437                 get_menu_callback(temp, &menu_callback);
 438                 if (menu_callback)
 439                 {
 440                     action = menu_callback(ACTION_ENTER_MENUITEM,temp);
 441                     if (action == ACTION_EXIT_MENUITEM)
 442                         break;
 443                 }
 444             }
 445             switch (type)
 446             {
 447                 case MT_MENU:
 448                     if (stack_top < MAX_MENUS)
 449                     {
 450                         menu_stack[stack_top] = menu;
 451                         menu_stack_selected_item[stack_top] = selected;
 452                         stack_top++;
 453                         init_menu_lists(temp, &lists, 0, true);
 454                         redraw_lists = false; /* above does the redraw */
 455                         menu = temp;
 456                         talk_item = true;
 457                     }
 458                     break;
 459                 case MT_FUNCTION_CALL:
 460                 {
 461                     int return_value;
 462                     talk_item = true;
 463                     if (temp->flags&MENU_FUNC_USEPARAM)
 464                         return_value = temp->function->function_w_param(
 465                                     temp->function->param);
 466                     else
 467                         return_value = temp->function->function();
 468                     if (temp->flags&MENU_FUNC_CHECK_RETVAL)
 469                     {
 470                         if (return_value == 1)
 471                         {
 472                             done = true;
 473                             ret =  return_value;
 474                         }
 475                     }
 476                     break;
 477                 }
 478                 case MT_SETTING:
 479                 case MT_SETTING_W_TEXT:
 480                 {
 481                     if (do_setting_from_menu(temp))
 482                     {
 483                         init_menu_lists(menu, &lists, selected, true);
 484                         redraw_lists = false; /* above does the redraw */
 485                     }
 486                     talk_item = true;
 487                     break;
 488                 }
 489                 case MT_RETURN_ID:
 490                     if (in_stringlist)
 491                     {
 492                         done = true;
 493                         ret =  selected;
 494                     }
 495                     else if (stack_top < MAX_MENUS)
 496                     {
 497                         menu_stack[stack_top] = menu;
 498                         menu_stack_selected_item[stack_top] = selected;
 499                         stack_top++;
 500                         menu = temp;
 501                         init_menu_lists(menu,&lists,0,false);
 502                         redraw_lists = false; /* above does the redraw */
 503                         talk_item = true;
 504                         in_stringlist = true;
 505                     }
 506                     break;
 507                 case MT_RETURN_VALUE:
 508                     ret = temp->value;
 509                     done = true;
 510                     break;
 511             }
 512             if (type != MT_MENU)
 513             {
 514                 if (menu_callback)
 515                     menu_callback(ACTION_EXIT_MENUITEM,temp);
 516             }
 517             if (current_submenus_menu != menu)
 518                 init_menu_lists(menu,&lists,selected,true);
 519             /* callback was changed, so reload the menu's callback */
 520             get_menu_callback(menu, &menu_callback);
 521             if ((menu->flags&MENU_EXITAFTERTHISMENU) &&
 522                 !(temp->flags&MENU_EXITAFTERTHISMENU))
 523             {
 524                 done = true;
 525                 break;
 526             }
 527 #ifdef HAS_BUTTONBAR
 528             gui_buttonbar_set(&buttonbar, "<<<", "", "");
 529             gui_buttonbar_draw(&buttonbar);
 530 #endif
 531         }
 532         else if(default_event_handler(action) == SYS_USB_CONNECTED)
 533         {
 534             ret = MENU_ATTACHED_USB;
 535             done = true;
 536         }
 537         if (talk_item && !done)
 538             talk_menu_item(menu, &lists);
 539
 540         if (redraw_lists)
 541             gui_synclist_draw(&lists);
 542     }
 543     if (start_selected)
 544     {
 545         /* make sure the start_selected variable is set to
 546            the selected item from the menu do_menu() was called from */
 547         if (stack_top > 0)
 548         {
 549             menu = menu_stack[0];
 550             init_menu_lists(menu,&lists,menu_stack_selected_item[0],true);
 551         }
 552         *start_selected = get_menu_selection(
 553                             gui_synclist_get_sel_pos(&lists), menu);
 554     }
 555     return ret;
 556 }
 557