apps/root_menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  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 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <stdbool.h>
  23 #include "config.h"
  24 #include "menu.h"
  25 #include "root_menu.h"
  26 #include "lang.h"
  27 #include "settings.h"
  28 #include "screens.h"
  29 #include "kernel.h"
  30 #include "debug.h"
  31 #include "misc.h"
  32 #include "rolo.h"
  33 #include "powermgmt.h"
  34 #include "power.h"
  35 #include "talk.h"
  36 #include "audio.h"
  37 #include "hotswap.h"
  38
  39 #if (LCD_DEPTH > 1) || (defined(HAVE_LCD_REMOTE) && (LCD_REMOTE_DEPTH > 1))
  40 #include "backdrop.h"
  41 #endif
  42
  43
  44 /* gui api */
  45 #include "list.h"
  46 #include "statusbar.h"
  47 #include "splash.h"
  48 #include "buttonbar.h"
  49 #include "textarea.h"
  50 #include "action.h"
  51 #include "yesno.h"
  52
  53 #include "tree.h"
  54 #if CONFIG_TUNER
  55 #include "radio.h"
  56 #endif
  57 #ifdef HAVE_RECORDING
  58 #include "recording.h"
  59 #endif
  60 #include "gwps-common.h"
  61 #include "bookmark.h"
  62 #include "playlist.h"
  63 #include "tagtree.h"
  64 #include "menus/exported_menus.h"
  65 #ifdef HAVE_RTC_ALARM
  66 #include "rtc.h"
  67 #endif
  68 #ifdef HAVE_TAGCACHE
  69 #include "tagcache.h"
  70 #endif
  71
  72 struct root_items {
  73     int (*function)(void* param);
  74     void* param;
  75     const struct menu_item_ex *context_menu;
  76 };
  77 static int last_screen = GO_TO_ROOT; /* unfortunatly needed so we can resume
  78                                         or goto current track based on previous
  79                                         screen */
  80 static int browser(void* param)
  81 {
  82     int ret_val;
  83 #ifdef HAVE_TAGCACHE
  84     struct tree_context* tc = tree_get_context();
  85 #endif
  86     int filter = SHOW_SUPPORTED;
  87     char folder[MAX_PATH] = "/";
  88     /* stuff needed to remember position in file browser */
  89     static char last_folder[MAX_PATH] = "/";
  90     /* and stuff for the database browser */
  91 #ifdef HAVE_TAGCACHE
  92     static int last_db_dirlevel = 0, last_db_selection = 0;
  93 #endif
  94
  95     switch ((intptr_t)param)
  96     {
  97         case GO_TO_FILEBROWSER:
  98             filter = global_settings.dirfilter;
  99             if (global_settings.browse_current &&
 100                     last_screen == GO_TO_WPS &&
 101                     wps_state.current_track_path[0] != '\0')
 102             {
 103                 strcpy(folder, wps_state.current_track_path);
 104             }
 105 #ifdef HAVE_HOTSWAP /* quick hack to stop crashing if you try entering
 106                      the browser from the menu when you were in the card
 107                      and it was removed */
 108             else if (strchr(last_folder, '<') && (card_detect() == false))
 109                 strcpy(folder, "/");
 110 #endif
 111             else
 112                 strcpy(folder, last_folder);
 113         break;
 114 #ifdef HAVE_TAGCACHE
 115         case GO_TO_DBBROWSER:
 116             if (!tagcache_is_usable())
 117             {
 118                 bool reinit_attempted = false;
 119
 120                 /* Now display progress until it's ready or the user exits */
 121                 while(!tagcache_is_usable())
 122                 {
 123                     gui_syncstatusbar_draw(&statusbars, false);
 124                     struct tagcache_stat *stat = tagcache_get_stat();
 125
 126                     /* Allow user to exit */
 127                     if (action_userabort(HZ/2))
 128                         break;
 129
 130                     /* Maybe just needs to reboot due to delayed commit */
 131                     if (stat->commit_delayed)
 132                     {
 133                         gui_syncsplash(HZ*2, ID2P(LANG_PLEASE_REBOOT));
 134                         break;
 135                     }
 136
 137                     /* Check if ready status is known */
 138                     if (!stat->readyvalid)
 139                     {
 140                         gui_syncsplash(0, str(LANG_TAGCACHE_BUSY));
 141                         continue;
 142                     }
 143
 144                     /* Re-init if required */
 145                     if (!reinit_attempted && !stat->ready &&
 146                         stat->processed_entries == 0 && stat->commit_step == 0)
 147                     {
 148                         /* Prompt the user */
 149                         reinit_attempted = true;
 150                         char *lines[]={ID2P(LANG_TAGCACHE_BUSY), ID2P(LANG_TAGCACHE_FORCE_UPDATE)};
 151                         struct text_message message={lines, 2};
 152                         if(gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)
 153                             break;
 154                         int i;
 155                         FOR_NB_SCREENS(i)
 156                             screens[i].clear_display();
 157
 158                         /* Start initialisation */
 159                         tagcache_rebuild();
 160                     }
 161
 162                     /* Display building progress */
 163                     static long talked_tick = 0;
 164                     if(global_settings.talk_menu &&
 165                        (talked_tick == 0
 166                         || TIME_AFTER(current_tick, talked_tick+7*HZ)))
 167                     {
 168                         talked_tick = current_tick;
 169                         if (stat->commit_step > 0)
 170                         {
 171                             talk_id(LANG_TAGCACHE_INIT, false);
 172                             talk_number(stat->commit_step, true);
 173                             talk_id(VOICE_OF, true);
 174                             talk_number(tagcache_get_max_commit_step(), true);
 175                         } else if(stat->processed_entries)
 176                         {
 177                             talk_number(stat->processed_entries, false);
 178                             talk_id(LANG_BUILDING_DATABASE, true);
 179                         }
 180                     }
 181                     if (stat->commit_step > 0)
 182                     {
 183                         gui_syncsplash(0, "%s [%d/%d]",
 184                             str(LANG_TAGCACHE_INIT), stat->commit_step,
 185                             tagcache_get_max_commit_step());
 186                     }
 187                     else
 188                     {
 189                         gui_syncsplash(0, str(LANG_BUILDING_DATABASE),
 190                             stat->processed_entries);
 191                     }
 192                 }
 193             }
 194             if (!tagcache_is_usable())
 195                 return GO_TO_PREVIOUS;
 196             filter = SHOW_ID3DB;
 197             tc->dirlevel = last_db_dirlevel;
 198             tc->selected_item = last_db_selection;
 199         break;
 200 #endif
 201         case GO_TO_BROWSEPLUGINS:
 202             filter = SHOW_PLUGINS;
 203             snprintf(folder, MAX_PATH, "%s", PLUGIN_DIR);
 204         break;
 205     }
 206     ret_val = rockbox_browse(folder, filter);
 207     switch ((intptr_t)param)
 208     {
 209         case GO_TO_FILEBROWSER:
 210             get_current_file(last_folder, MAX_PATH);
 211         break;
 212 #ifdef HAVE_TAGCACHE
 213         case GO_TO_DBBROWSER:
 214             last_db_dirlevel = tc->dirlevel;
 215             last_db_selection = tc->selected_item;
 216         break;
 217 #endif
 218     }
 219     return ret_val;
 220 }
 221
 222 static int menu(void* param)
 223 {
 224     (void)param;
 225     return do_menu(NULL, 0, NULL, false);
 226
 227 }
 228 #ifdef HAVE_RECORDING
 229 static int recscrn(void* param)
 230 {
 231     (void)param;
 232     recording_screen(false);
 233     return GO_TO_ROOT;
 234 }
 235 #endif
 236 static int wpsscrn(void* param)
 237 {
 238     int ret_val = GO_TO_PREVIOUS;
 239     (void)param;
 240     if (audio_status())
 241     {
 242         talk_shutup();
 243         ret_val = gui_wps_show();
 244     }
 245     else if ( global_status.resume_index != -1 )
 246     {
 247         DEBUGF("Resume index %X offset %lX\n",
 248                global_status.resume_index,
 249                (unsigned long)global_status.resume_offset);
 250         if (playlist_resume() != -1)
 251         {
 252             playlist_start(global_status.resume_index,
 253                 global_status.resume_offset);
 254             ret_val = gui_wps_show();
 255         }
 256     }
 257     else
 258     {
 259         gui_syncsplash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME));
 260     }
 261 #if LCD_DEPTH > 1
 262     show_main_backdrop();
 263 #endif
 264 #if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
 265     show_remote_main_backdrop();
 266 #endif
 267     return ret_val;
 268 }
 269 #if CONFIG_TUNER
 270 static int radio(void* param)
 271 {
 272     (void)param;
 273     radio_screen();
 274     return GO_TO_ROOT;
 275 }
 276 #endif
 277
 278 static int load_bmarks(void* param)
 279 {
 280     (void)param;
 281     if(bookmark_mrb_load())
 282         return GO_TO_WPS;
 283     return GO_TO_PREVIOUS;
 284 }
 285 static int plugins_menu(void* param)
 286 {
 287     (void)param;
 288     MENUITEM_STRINGLIST(plugins_menu_items, ID2P(LANG_PLUGINS), NULL,
 289                         ID2P(LANG_PLUGIN_GAMES),
 290                         ID2P(LANG_PLUGIN_APPS), ID2P(LANG_PLUGIN_DEMOS));
 291     char *folder;
 292     int retval = GO_TO_PREVIOUS;
 293     int selection = 0, current = 0;
 294     while (retval == GO_TO_PREVIOUS)
 295     {
 296         selection = do_menu(&plugins_menu_items, &current, NULL, false);
 297         switch (selection)
 298         {
 299             case 0:
 300                 folder = PLUGIN_GAMES_DIR;
 301                 break;
 302             case 1:
 303                 folder = PLUGIN_APPS_DIR;
 304                 break;
 305             case 2:
 306                 folder = PLUGIN_DEMOS_DIR;
 307                 break;
 308             default:
 309                 return selection;
 310         }
 311         retval = rockbox_browse(folder, SHOW_PLUGINS);
 312     }
 313     return retval;
 314 }
 315
 316 /* These are all static const'd from apps/menus/ *.c
 317    so little hack so we can use them */
 318 extern struct menu_item_ex
 319         file_menu,
 320 #ifdef HAVE_TAGCACHE
 321         tagcache_menu,
 322 #endif
 323         manage_settings,
 324         recording_settings_menu,
 325         radio_settings_menu,
 326         bookmark_settings_menu,
 327         system_menu;
 328 static const struct root_items items[] = {
 329     [GO_TO_FILEBROWSER] =   { browser, (void*)GO_TO_FILEBROWSER, &file_menu},
 330 #ifdef HAVE_TAGCACHE
 331     [GO_TO_DBBROWSER] =     { browser, (void*)GO_TO_DBBROWSER, &tagcache_menu },
 332 #endif
 333     [GO_TO_WPS] =           { wpsscrn, NULL, &playback_menu_item },
 334     [GO_TO_MAINMENU] =      { menu, NULL, &manage_settings },
 335
 336 #ifdef HAVE_RECORDING
 337     [GO_TO_RECSCREEN] =     {  recscrn, NULL, &recording_settings_menu },
 338 #endif
 339
 340 #if CONFIG_TUNER
 341     [GO_TO_FM] =            { radio, NULL, &radio_settings_menu },
 342 #endif
 343
 344     [GO_TO_RECENTBMARKS] =  { load_bmarks, NULL, &bookmark_settings_menu },
 345     [GO_TO_BROWSEPLUGINS] = { plugins_menu, NULL, NULL },
 346
 347 };
 348 static const int nb_items = sizeof(items)/sizeof(*items);
 349
 350 int item_callback(int action, const struct menu_item_ex *this_item) ;
 351
 352 MENUITEM_RETURNVALUE(file_browser, ID2P(LANG_DIR_BROWSER), GO_TO_FILEBROWSER,
 353                         NULL, Icon_file_view_menu);
 354 #ifdef HAVE_TAGCACHE
 355 MENUITEM_RETURNVALUE(db_browser, ID2P(LANG_TAGCACHE), GO_TO_DBBROWSER,
 356                         NULL, Icon_Audio);
 357 #endif
 358 MENUITEM_RETURNVALUE(rocks_browser, ID2P(LANG_PLUGINS), GO_TO_BROWSEPLUGINS,
 359                         NULL, Icon_Plugin);
 360 char *get_wps_item_name(int selected_item, void * data, char *buffer)
 361 {
 362     (void)selected_item; (void)data; (void)buffer;
 363     if (audio_status())
 364         return ID2P(LANG_NOW_PLAYING);
 365     return ID2P(LANG_RESUME_PLAYBACK);
 366 }
 367 MENUITEM_RETURNVALUE_DYNTEXT(wps_item, GO_TO_WPS, NULL, get_wps_item_name,
 368                                 NULL, NULL, Icon_Playback_menu);
 369 #ifdef HAVE_RECORDING
 370 MENUITEM_RETURNVALUE(rec, ID2P(LANG_RECORDING), GO_TO_RECSCREEN,
 371                         NULL, Icon_Recording);
 372 #endif
 373 #if CONFIG_TUNER
 374 MENUITEM_RETURNVALUE(fm, ID2P(LANG_FM_RADIO), GO_TO_FM,
 375                         item_callback, Icon_Radio_screen);
 376 #endif
 377 MENUITEM_RETURNVALUE(menu_, ID2P(LANG_SETTINGS), GO_TO_MAINMENU,
 378                         NULL, Icon_Submenu_Entered);
 379 MENUITEM_RETURNVALUE(bookmarks, ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
 380                         GO_TO_RECENTBMARKS,  item_callback,
 381                         Icon_Bookmark);
 382 #ifdef HAVE_LCD_CHARCELLS
 383 static int do_shutdown(void)
 384 {
 385 #if CONFIG_CHARGING
 386     if (charger_inserted())
 387         charging_splash();
 388     else
 389 #endif
 390         sys_poweroff();
 391     return 0;
 392 }
 393 MENUITEM_FUNCTION(do_shutdown_item, 0, ID2P(LANG_SHUTDOWN),
 394                   do_shutdown, NULL, NULL, Icon_NOICON);
 395 #endif
 396 MAKE_MENU(root_menu_, ID2P(LANG_ROCKBOX_TITLE),
 397             item_callback, Icon_Rockbox,
 398             &bookmarks, &file_browser,
 399 #ifdef HAVE_TAGCACHE
 400             &db_browser,
 401 #endif
 402             &wps_item, &menu_,
 403 #ifdef HAVE_RECORDING
 404             &rec,
 405 #endif
 406 #if CONFIG_TUNER
 407             &fm,
 408 #endif
 409             &playlist_options, &rocks_browser,  &info_menu
 410
 411 #ifdef HAVE_LCD_CHARCELLS
 412             ,&do_shutdown_item
 413 #endif
 414         );
 415
 416 int item_callback(int action, const struct menu_item_ex *this_item)
 417 {
 418     switch (action)
 419     {
 420         case ACTION_TREE_STOP:
 421             return ACTION_REDRAW;
 422         case ACTION_REQUEST_MENUITEM:
 423 #if CONFIG_TUNER
 424             if (this_item == &fm)
 425             {
 426                 if (radio_hardware_present() == 0)
 427                     return ACTION_EXIT_MENUITEM;
 428             }
 429             else
 430 #endif
 431                 if (this_item == &bookmarks)
 432             {
 433                 if (global_settings.usemrb == 0)
 434                     return ACTION_EXIT_MENUITEM;
 435             }
 436         break;
 437     }
 438     return action;
 439 }
 440 static int get_selection(int last_screen)
 441 {
 442     unsigned int i;
 443     for(i=0; i< sizeof(root_menu__)/sizeof(*root_menu__); i++)
 444     {
 445         if (((root_menu__[i]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE) &&
 446             (root_menu__[i]->value == last_screen))
 447         {
 448             return i;
 449         }
 450     }
 451     return 0;
 452 }
 453
 454 static inline int load_screen(int screen)
 455 {
 456     /* set the global_status.last_screen before entering,
 457         if we dont we will always return to the wrong screen on boot */
 458     int old_previous = last_screen;
 459     int ret_val;
 460     if (screen <= GO_TO_ROOT)
 461         return screen;
 462     if (screen == old_previous)
 463         old_previous = GO_TO_ROOT;
 464     global_status.last_screen = (char)screen;
 465     status_save();
 466     ret_val = items[screen].function(items[screen].param);
 467     last_screen = screen;
 468     if (ret_val == GO_TO_PREVIOUS)
 469         last_screen = old_previous;
 470     return ret_val;
 471 }
 472 static int load_context_screen(int selection)
 473 {
 474     const struct menu_item_ex *context_menu = NULL;
 475     if ((root_menu__[selection]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE)
 476     {
 477         int item = root_menu__[selection]->value;
 478         context_menu = items[item].context_menu;
 479     }
 480     /* special cases */
 481     else if (root_menu__[selection] == &info_menu)
 482     {
 483         context_menu = &system_menu;
 484     }
 485
 486     if (context_menu)
 487         return do_menu(context_menu, NULL, NULL, false);
 488     else
 489         return GO_TO_PREVIOUS;
 490 }
 491
 492 static int previous_music = GO_TO_WPS;
 493
 494 void previous_music_is_wps(void)
 495 {
 496     previous_music = GO_TO_WPS;
 497 }
 498
 499 void root_menu(void)
 500 {
 501     int previous_browser = GO_TO_FILEBROWSER;
 502     int next_screen = GO_TO_ROOT;
 503     int selected = 0;
 504
 505     if (global_settings.start_in_screen == 0)
 506         next_screen = (int)global_status.last_screen;
 507     else next_screen = global_settings.start_in_screen - 2;
 508
 509 #ifdef HAVE_RTC_ALARM
 510     if ( rtc_check_alarm_started(true) )
 511     {
 512         rtc_enable_alarm(false);
 513         next_screen = GO_TO_WPS;
 514 #if CONFIG_TUNER
 515         if (global_settings.alarm_wake_up_screen == ALARM_START_FM)
 516             next_screen = GO_TO_FM;
 517 #endif
 518 #ifdef HAVE_RECORDING
 519         if (global_settings.alarm_wake_up_screen == ALARM_START_REC)
 520         {
 521             recording_start_automatic = true;
 522             next_screen = GO_TO_RECSCREEN;
 523         }
 524 #endif
 525     }
 526 #endif /* HAVE_RTC_ALARM */
 527
 528 #ifdef HAVE_HEADPHONE_DETECTION
 529     if (next_screen == GO_TO_WPS &&
 530         (global_settings.unplug_autoresume && !headphones_inserted() ))
 531             next_screen = GO_TO_ROOT;
 532 #endif
 533
 534     while (true)
 535     {
 536         switch (next_screen)
 537         {
 538             case MENU_ATTACHED_USB:
 539             case MENU_SELECTED_EXIT:
 540                 /* fall through */
 541             case GO_TO_ROOT:
 542                 if (last_screen != GO_TO_ROOT)
 543                     selected = get_selection(last_screen);
 544                 next_screen = do_menu(&root_menu_, &selected, NULL, false);
 545                 if (next_screen != GO_TO_PREVIOUS)
 546                     last_screen = GO_TO_ROOT;
 547                 break;
 548
 549             case GO_TO_PREVIOUS:
 550                 next_screen = last_screen;
 551                 break;
 552
 553             case GO_TO_PREVIOUS_BROWSER:
 554                 next_screen = previous_browser;
 555                 break;
 556
 557             case GO_TO_PREVIOUS_MUSIC:
 558                 next_screen = previous_music;
 559                 break;
 560             case GO_TO_ROOTITEM_CONTEXT:
 561                 next_screen = load_context_screen(selected);
 562                 break;
 563             default:
 564                 if (next_screen == GO_TO_FILEBROWSER
 565 #ifdef HAVE_TAGCACHE
 566                     || next_screen == GO_TO_DBBROWSER
 567 #endif
 568                    )
 569                     previous_browser = next_screen;
 570                 if (next_screen == GO_TO_WPS
 571 #if CONFIG_TUNER
 572                     || next_screen == GO_TO_FM
 573 #endif
 574                    )
 575                     previous_music = next_screen;
 576                 next_screen = load_screen(next_screen);
 577                 break;
 578         } /* switch() */
 579     }
 580     return;
 581 }