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