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