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