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