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