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