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 <stdlib.h>
  23 #include <stdbool.h>
  24 #include "string-extra.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 "shortcuts.h"
  41
  42 #ifdef HAVE_HOTSWAP
  43 #include "storage.h"
  44 #include "dir.h"
  45 #endif
  46 /* gui api */
  47 #include "list.h"
  48 #include "splash.h"
  49 #include "action.h"
  50 #include "yesno.h"
  51 #include "viewport.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 "wps.h"
  61 #include "bookmark.h"
  62 #include "playlist.h"
  63 #include "playlist_viewer.h"
  64 #include "playlist_catalog.h"
  65 #include "menus/exported_menus.h"
  66 #ifdef HAVE_RTC_ALARM
  67 #include "rtc.h"
  68 #endif
  69 #ifdef HAVE_TAGCACHE
  70 #include "tagcache.h"
  71 #endif
  72 #include "language.h"
  73 #include "plugin.h"
  74
  75 struct root_items {
  76     int (*function)(void* param);
  77     void* param;
  78     const struct menu_item_ex *context_menu;
  79 };
  80 static int next_screen = GO_TO_ROOT; /* holding info about the upcoming screen
  81                                         * which is the current screen for the
  82                                         * rest of the code after load_screen
  83                                         * is called */
  84 static int last_screen = GO_TO_ROOT; /* unfortunatly needed so we can resume
  85                                         or goto current track based on previous
  86                                         screen */
  87
  88
  89 static char current_track_path[MAX_PATH];
  90 static void rootmenu_track_changed_callback(void* param)
  91 {
  92     struct mp3entry *id3 = (struct mp3entry *)param;
  93     strlcpy(current_track_path, id3->path, MAX_PATH);
  94 }
  95 static int browser(void* param)
  96 {
  97     int ret_val;
  98 #ifdef HAVE_TAGCACHE
  99     struct tree_context* tc = tree_get_context();
 100 #endif
 101     struct browse_context browse;
 102     int filter = SHOW_SUPPORTED;
 103     char folder[MAX_PATH] = "/";
 104     /* stuff needed to remember position in file browser */
 105     static char last_folder[MAX_PATH] = "/";
 106     /* and stuff for the database browser */
 107 #ifdef HAVE_TAGCACHE
 108     static int last_db_dirlevel = 0, last_db_selection = 0;
 109 #endif
 110
 111     switch ((intptr_t)param)
 112     {
 113         case GO_TO_FILEBROWSER:
 114             filter = global_settings.dirfilter;
 115             if (global_settings.browse_current &&
 116                     last_screen == GO_TO_WPS &&
 117                     current_track_path[0])
 118             {
 119                 strcpy(folder, current_track_path);
 120             }
 121             else if (!strcmp(last_folder, "/"))
 122             {
 123                 strcpy(folder, global_settings.start_directory);
 124             }
 125             else
 126             {
 127 #ifdef HAVE_HOTSWAP
 128                 bool in_hotswap = false;
 129                 /* handle entering an ejected drive */
 130                 int i;
 131                 for (i = 0; i < NUM_VOLUMES; i++)
 132                 {
 133                     char vol_string[VOL_ENUM_POS + 8];
 134                     if (!storage_removable(i))
 135                         continue;
 136                     /* VOL_NAMES contains a %d */
 137                     snprintf(vol_string, sizeof(vol_string), "/"VOL_NAMES, i);
 138                     /* test whether we would browse the external card */
 139                     if (!storage_present(i) &&
 140                             (strstr(last_folder, vol_string)
 141 #ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
 142                                                                 || (i == 0)
 143 #endif
 144                                                                 ))
 145                     {   /* leave folder as "/" to avoid crash when trying
 146                          * to access an ejected drive */
 147                         strcpy(folder, "/");
 148                         in_hotswap = true;
 149                         break;
 150                     }
 151                 }
 152                 if (!in_hotswap)
 153 #endif
 154                     strcpy(folder, last_folder);
 155             }
 156             push_current_activity(ACTIVITY_FILEBROWSER);
 157         break;
 158 #ifdef HAVE_TAGCACHE
 159         case GO_TO_DBBROWSER:
 160             if (!tagcache_is_usable())
 161             {
 162                 bool reinit_attempted = false;
 163
 164                 /* Now display progress until it's ready or the user exits */
 165                 while(!tagcache_is_usable())
 166                 {
 167                     struct tagcache_stat *stat = tagcache_get_stat();
 168
 169                     /* Allow user to exit */
 170                     if (action_userabort(HZ/2))
 171                         break;
 172
 173                     /* Maybe just needs to reboot due to delayed commit */
 174                     if (stat->commit_delayed)
 175                     {
 176                         splash(HZ*2, ID2P(LANG_PLEASE_REBOOT));
 177                         break;
 178                     }
 179
 180                     /* Check if ready status is known */
 181                     if (!stat->readyvalid)
 182                     {
 183                         splash(0, str(LANG_TAGCACHE_BUSY));
 184                         continue;
 185                     }
 186
 187                     /* Re-init if required */
 188                     if (!reinit_attempted && !stat->ready &&
 189                         stat->processed_entries == 0 && stat->commit_step == 0)
 190                     {
 191                         /* Prompt the user */
 192                         reinit_attempted = true;
 193                         static const char *lines[]={
 194                             ID2P(LANG_TAGCACHE_BUSY), ID2P(LANG_TAGCACHE_FORCE_UPDATE)};
 195                         static const struct text_message message={lines, 2};
 196                         if(gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)
 197                             break;
 198                         FOR_NB_SCREENS(i)
 199                             screens[i].clear_display();
 200
 201                         /* Start initialisation */
 202                         tagcache_rebuild();
 203                     }
 204
 205                     /* Display building progress */
 206                     static long talked_tick = 0;
 207                     if(global_settings.talk_menu &&
 208                        (talked_tick == 0
 209                         || TIME_AFTER(current_tick, talked_tick+7*HZ)))
 210                     {
 211                         talked_tick = current_tick;
 212                         if (stat->commit_step > 0)
 213                         {
 214                             talk_id(LANG_TAGCACHE_INIT, false);
 215                             talk_number(stat->commit_step, true);
 216                             talk_id(VOICE_OF, true);
 217                             talk_number(tagcache_get_max_commit_step(), true);
 218                         } else if(stat->processed_entries)
 219                         {
 220                             talk_number(stat->processed_entries, false);
 221                             talk_id(LANG_BUILDING_DATABASE, true);
 222                         }
 223                     }
 224                     if (stat->commit_step > 0)
 225                     {
 226                         if (lang_is_rtl())
 227                         {
 228                             splashf(0, "[%d/%d] %s", stat->commit_step,
 229                                 tagcache_get_max_commit_step(),
 230                                 str(LANG_TAGCACHE_INIT));
 231                         }
 232                         else
 233                         {
 234                             splashf(0, "%s [%d/%d]", str(LANG_TAGCACHE_INIT),
 235                                 stat->commit_step,
 236                                 tagcache_get_max_commit_step());
 237                         }
 238                     }
 239                     else
 240                     {
 241                         splashf(0, str(LANG_BUILDING_DATABASE),
 242                                    stat->processed_entries);
 243                     }
 244                 }
 245             }
 246             if (!tagcache_is_usable())
 247                 return GO_TO_PREVIOUS;
 248             filter = SHOW_ID3DB;
 249             tc->dirlevel = last_db_dirlevel;
 250             tc->selected_item = last_db_selection;
 251             push_current_activity(ACTIVITY_DATABASEBROWSER);
 252         break;
 253 #endif
 254     }
 255
 256     browse_context_init(&browse, filter, 0, NULL, NOICON, folder, NULL);
 257     ret_val = rockbox_browse(&browse);
 258     pop_current_activity();
 259     switch ((intptr_t)param)
 260     {
 261         case GO_TO_FILEBROWSER:
 262             if (!get_current_file(last_folder, MAX_PATH) ||
 263                 (!strchr(&last_folder[1], '/') &&
 264                  global_settings.start_directory[1] != '\0'))
 265             {
 266                 last_folder[0] = '/';
 267                 last_folder[1] = '\0';
 268             }
 269         break;
 270 #ifdef HAVE_TAGCACHE
 271         case GO_TO_DBBROWSER:
 272             last_db_dirlevel = tc->dirlevel;
 273             last_db_selection = tc->selected_item;
 274         break;
 275 #endif
 276     }
 277     return ret_val;
 278 }
 279
 280 #ifdef HAVE_RECORDING
 281 static int recscrn(void* param)
 282 {
 283     (void)param;
 284     recording_screen(false);
 285     return GO_TO_ROOT;
 286 }
 287 #endif
 288 static int wpsscrn(void* param)
 289 {
 290     int ret_val = GO_TO_PREVIOUS;
 291     (void)param;
 292     push_current_activity(ACTIVITY_WPS);
 293     if (audio_status())
 294     {
 295         talk_shutup();
 296         ret_val = gui_wps_show();
 297     }
 298     else if ( global_status.resume_index != -1 )
 299     {
 300         DEBUGF("Resume index %X crc32 %lX offset %lX\n",
 301                global_status.resume_index,
 302                (unsigned long)global_status.resume_crc32,
 303                (unsigned long)global_status.resume_offset);
 304         if (playlist_resume() != -1)
 305         {
 306             playlist_resume_track(global_status.resume_index,
 307                 global_status.resume_crc32,
 308                 global_status.resume_offset);
 309             ret_val = gui_wps_show();
 310         }
 311     }
 312     else
 313     {
 314         splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME));
 315     }
 316     pop_current_activity();
 317     return ret_val;
 318 }
 319 #if CONFIG_TUNER
 320 static int radio(void* param)
 321 {
 322     (void)param;
 323     radio_screen();
 324     return GO_TO_ROOT;
 325 }
 326 #endif
 327
 328 static int miscscrn(void * param)
 329 {
 330     const struct menu_item_ex *menu = (const struct menu_item_ex*)param;
 331     int result = do_menu(menu, NULL, NULL, false);
 332     switch (result)
 333     {
 334         case GO_TO_PLAYLIST_VIEWER:
 335         case GO_TO_WPS:
 336             return result;
 337         default:
 338             return GO_TO_ROOT;
 339     }
 340 }
 341
 342
 343 static int playlist_view_catalog(void * param)
 344 {
 345     /* kludge untill catalog_view_playlists() returns something useful */
 346     int old_playstatus = audio_status();
 347     (void)param;
 348     push_current_activity(ACTIVITY_PLAYLISTBROWSER);
 349     catalog_view_playlists();
 350     pop_current_activity();
 351     if (!old_playstatus && audio_status())
 352         return GO_TO_WPS;
 353     return GO_TO_PREVIOUS;
 354 }
 355
 356 static int playlist_view(void * param)
 357 {
 358     (void)param;
 359     int val;
 360
 361     push_current_activity(ACTIVITY_PLAYLISTVIEWER);
 362     val = playlist_viewer();
 363     pop_current_activity();
 364     switch (val)
 365     {
 366         case PLAYLIST_VIEWER_MAINMENU:
 367         case PLAYLIST_VIEWER_USB:
 368             return GO_TO_ROOT;
 369         case PLAYLIST_VIEWER_OK:
 370             return GO_TO_PREVIOUS;
 371     }
 372     return GO_TO_PREVIOUS;
 373 }
 374
 375 static int load_bmarks(void* param)
 376 {
 377     (void)param;
 378     if(bookmark_mrb_load())
 379         return GO_TO_WPS;
 380     return GO_TO_PREVIOUS;
 381 }
 382
 383 /* These are all static const'd from apps/menus/ *.c
 384    so little hack so we can use them */
 385 extern struct menu_item_ex
 386         file_menu,
 387 #ifdef HAVE_TAGCACHE
 388         tagcache_menu,
 389 #endif
 390         main_menu_,
 391         manage_settings,
 392         plugin_menu,
 393         playlist_options,
 394         info_menu,
 395         system_menu;
 396 static const struct root_items items[] = {
 397     [GO_TO_FILEBROWSER] =   { browser, (void*)GO_TO_FILEBROWSER, &file_menu},
 398 #ifdef HAVE_TAGCACHE
 399     [GO_TO_DBBROWSER] =     { browser, (void*)GO_TO_DBBROWSER, &tagcache_menu },
 400 #endif
 401     [GO_TO_WPS] =           { wpsscrn, NULL, &playback_settings },
 402     [GO_TO_MAINMENU] =      { miscscrn, (struct menu_item_ex*)&main_menu_,
 403                                                             &manage_settings },
 404
 405 #ifdef HAVE_RECORDING
 406     [GO_TO_RECSCREEN] =     {  recscrn, NULL, &recording_settings_menu },
 407 #endif
 408
 409 #if CONFIG_TUNER
 410     [GO_TO_FM] =            { radio, NULL, &radio_settings_menu },
 411 #endif
 412
 413     [GO_TO_RECENTBMARKS] =  { load_bmarks, NULL, &bookmark_settings_menu },
 414     [GO_TO_BROWSEPLUGINS] = { miscscrn, &plugin_menu, NULL },
 415     [GO_TO_PLAYLISTS_SCREEN] = { playlist_view_catalog, NULL,
 416                                                         &playlist_options },
 417     [GO_TO_PLAYLIST_VIEWER] = { playlist_view, NULL, &playlist_options },
 418     [GO_TO_SYSTEM_SCREEN] = { miscscrn, &info_menu, &system_menu },
 419     [GO_TO_SHORTCUTMENU] = { do_shortcut_menu, NULL, NULL },
 420
 421 };
 422 static const int nb_items = sizeof(items)/sizeof(*items);
 423
 424 static int item_callback(int action, const struct menu_item_ex *this_item) ;
 425
 426 MENUITEM_RETURNVALUE(shortcut_menu, ID2P(LANG_SHORTCUTS), GO_TO_SHORTCUTMENU,
 427                         NULL, Icon_Bookmark);
 428
 429 MENUITEM_RETURNVALUE(file_browser, ID2P(LANG_DIR_BROWSER), GO_TO_FILEBROWSER,
 430                         NULL, Icon_file_view_menu);
 431 #ifdef HAVE_TAGCACHE
 432 MENUITEM_RETURNVALUE(db_browser, ID2P(LANG_TAGCACHE), GO_TO_DBBROWSER,
 433                         NULL, Icon_Audio);
 434 #endif
 435 MENUITEM_RETURNVALUE(rocks_browser, ID2P(LANG_PLUGINS), GO_TO_BROWSEPLUGINS,
 436                         NULL, Icon_Plugin);
 437
 438 MENUITEM_RETURNVALUE(playlist_browser, ID2P(LANG_CATALOG), GO_TO_PLAYLIST_VIEWER,
 439                         NULL, Icon_Playlist);
 440
 441 static char *get_wps_item_name(int selected_item, void * data, char *buffer)
 442 {
 443     (void)selected_item; (void)data; (void)buffer;
 444     if (audio_status())
 445         return ID2P(LANG_NOW_PLAYING);
 446     return ID2P(LANG_RESUME_PLAYBACK);
 447 }
 448 MENUITEM_RETURNVALUE_DYNTEXT(wps_item, GO_TO_WPS, NULL, get_wps_item_name,
 449                                 NULL, NULL, Icon_Playback_menu);
 450 #ifdef HAVE_RECORDING
 451 MENUITEM_RETURNVALUE(rec, ID2P(LANG_RECORDING), GO_TO_RECSCREEN,
 452                         NULL, Icon_Recording);
 453 #endif
 454 #if CONFIG_TUNER
 455 MENUITEM_RETURNVALUE(fm, ID2P(LANG_FM_RADIO), GO_TO_FM,
 456                         item_callback, Icon_Radio_screen);
 457 #endif
 458 MENUITEM_RETURNVALUE(menu_, ID2P(LANG_SETTINGS), GO_TO_MAINMENU,
 459                         NULL, Icon_Submenu_Entered);
 460 MENUITEM_RETURNVALUE(bookmarks, ID2P(LANG_BOOKMARK_MENU_RECENT_BOOKMARKS),
 461                         GO_TO_RECENTBMARKS,  item_callback,
 462                         Icon_Bookmark);
 463 MENUITEM_RETURNVALUE(playlists, ID2P(LANG_CATALOG), GO_TO_PLAYLISTS_SCREEN,
 464                      NULL, Icon_Playlist);
 465 MENUITEM_RETURNVALUE(system_menu_, ID2P(LANG_SYSTEM), GO_TO_SYSTEM_SCREEN,
 466                      NULL, Icon_System_menu);
 467
 468 #if CONFIG_KEYPAD == PLAYER_PAD
 469 static int do_shutdown(void)
 470 {
 471 #if CONFIG_CHARGING
 472     if (charger_inserted())
 473         charging_splash();
 474     else
 475 #endif
 476         sys_poweroff();
 477     return 0;
 478 }
 479 MENUITEM_FUNCTION(do_shutdown_item, 0, ID2P(LANG_SHUTDOWN),
 480                   do_shutdown, NULL, NULL, Icon_NOICON);
 481 #endif
 482
 483 struct menu_item_ex root_menu_;
 484 static struct menu_callback_with_desc root_menu_desc = {
 485         item_callback, ID2P(LANG_ROCKBOX_TITLE), Icon_Rockbox };
 486 struct menu_table {
 487     char *string;
 488     const struct menu_item_ex *item;
 489 };
 490 static struct menu_table menu_table[] = {
 491     /* Order here represents the default ordering */
 492     { "bookmarks", &bookmarks },
 493     { "files", &file_browser },
 494 #ifdef HAVE_TAGCACHE
 495     { "database", &db_browser },
 496 #endif
 497     { "wps", &wps_item },
 498     { "settings", &menu_ },
 499 #ifdef HAVE_RECORDING
 500     { "recording", &rec },
 501 #endif
 502 #if CONFIG_TUNER
 503     { "radio", &fm },
 504 #endif
 505     { "playlists", &playlists },
 506     { "plugins", &rocks_browser },
 507     { "system_menu", &system_menu_ },
 508 #if CONFIG_KEYPAD == PLAYER_PAD
 509     { "shutdown", &do_shutdown_item },
 510 #endif
 511     { "shortcuts", &shortcut_menu },
 512 };
 513 #define MAX_MENU_ITEMS (sizeof(menu_table) / sizeof(struct menu_table))
 514 static struct menu_item_ex *root_menu__[MAX_MENU_ITEMS];
 515
 516 void root_menu_load_from_cfg(void* setting, char *value)
 517 {
 518     char *next = value, *start, *end;
 519     unsigned int menu_item_count = 0, i;
 520     bool main_menu_added = false;
 521
 522     if (*value == '-')
 523     {
 524         root_menu_set_default(setting, NULL);
 525         return;
 526     }
 527     root_menu_.flags = MENU_HAS_DESC | MT_MENU;
 528     root_menu_.submenus = (const struct menu_item_ex **)&root_menu__;
 529     root_menu_.callback_and_desc = &root_menu_desc;
 530
 531     while (next && menu_item_count < MAX_MENU_ITEMS)
 532     {
 533         start = next;
 534         next = strchr(next, ',');
 535         if (next)
 536         {
 537             *next = '\0';
 538             next++;
 539         }
 540         start = skip_whitespace(start);
 541         if ((end = strchr(start, ' ')))
 542             *end = '\0';
 543         for (i=0; i<MAX_MENU_ITEMS; i++)
 544         {
 545             if (*start && !strcmp(start, menu_table[i].string))
 546             {
 547                 root_menu__[menu_item_count++] = (struct menu_item_ex *)menu_table[i].item;
 548                 if (menu_table[i].item == &menu_)
 549                     main_menu_added = true;
 550                 break;
 551             }
 552         }
 553     }
 554     if (!main_menu_added)
 555         root_menu__[menu_item_count++] = (struct menu_item_ex *)&menu_;
 556     root_menu_.flags |= MENU_ITEM_COUNT(menu_item_count);
 557     *(bool*)setting = true;
 558 }
 559
 560 char* root_menu_write_to_cfg(void* setting, char*buf, int buf_len)
 561 {
 562     (void)setting;
 563     unsigned i, written, j;
 564     for (i = 0; i < MENU_GET_COUNT(root_menu_.flags); i++)
 565     {
 566         for (j=0; j<MAX_MENU_ITEMS; j++)
 567         {
 568             if (menu_table[j].item == root_menu__[i])
 569             {
 570                 written = snprintf(buf, buf_len, "%s, ", menu_table[j].string);
 571                 buf_len -= written;
 572                 buf += written;
 573                 break;
 574             }
 575         }
 576     }
 577     return buf;
 578 }
 579
 580 void root_menu_set_default(void* setting, void* defaultval)
 581 {
 582     unsigned i;
 583     (void)defaultval;
 584
 585     root_menu_.flags = MENU_HAS_DESC | MT_MENU;
 586     root_menu_.submenus = (const struct menu_item_ex **)&root_menu__;
 587     root_menu_.callback_and_desc = &root_menu_desc;
 588
 589     for (i=0; i<MAX_MENU_ITEMS; i++)
 590     {
 591         root_menu__[i] = (struct menu_item_ex *)menu_table[i].item;
 592     }
 593     root_menu_.flags |= MENU_ITEM_COUNT(MAX_MENU_ITEMS);
 594     *(bool*)setting = false;
 595 }
 596
 597 bool root_menu_is_changed(void* setting, void* defaultval)
 598 {
 599     (void)defaultval;
 600     return *(bool*)setting;
 601 }
 602
 603 static int item_callback(int action, const struct menu_item_ex *this_item)
 604 {
 605     switch (action)
 606     {
 607         case ACTION_TREE_STOP:
 608             return ACTION_REDRAW;
 609         case ACTION_REQUEST_MENUITEM:
 610 #if CONFIG_TUNER
 611             if (this_item == &fm)
 612             {
 613                 if (radio_hardware_present() == 0)
 614                     return ACTION_EXIT_MENUITEM;
 615             }
 616             else
 617 #endif
 618                 if (this_item == &bookmarks)
 619             {
 620                 if (global_settings.usemrb == 0)
 621                     return ACTION_EXIT_MENUITEM;
 622             }
 623         break;
 624     }
 625     return action;
 626 }
 627 static int get_selection(int last_screen)
 628 {
 629     int i;
 630     int len = ARRAYLEN(root_menu__);
 631     for(i=0; i < len; i++)
 632     {
 633         if (((root_menu__[i]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE) &&
 634             (root_menu__[i]->value == last_screen))
 635         {
 636             return i;
 637         }
 638     }
 639     return 0;
 640 }
 641
 642 static inline int load_screen(int screen)
 643 {
 644     /* set the global_status.last_screen before entering,
 645         if we dont we will always return to the wrong screen on boot */
 646     int old_previous = last_screen;
 647     int ret_val;
 648     enum current_activity activity = ACTIVITY_UNKNOWN;
 649     if (screen <= GO_TO_ROOT)
 650         return screen;
 651     if (screen == old_previous)
 652         old_previous = GO_TO_ROOT;
 653     global_status.last_screen = (char)screen;
 654     status_save();
 655
 656     if (screen == GO_TO_BROWSEPLUGINS)
 657         activity = ACTIVITY_PLUGINBROWSER;
 658     else if (screen == GO_TO_MAINMENU)
 659         activity = ACTIVITY_SETTINGS;
 660     else if (screen == GO_TO_SYSTEM_SCREEN)
 661         activity =  ACTIVITY_SYSTEMSCREEN;
 662
 663     if (activity != ACTIVITY_UNKNOWN)
 664         push_current_activity(activity);
 665
 666     ret_val = items[screen].function(items[screen].param);
 667
 668     if (activity != ACTIVITY_UNKNOWN)
 669         pop_current_activity();
 670
 671     last_screen = screen;
 672     if (ret_val == GO_TO_PREVIOUS)
 673         last_screen = old_previous;
 674     return ret_val;
 675 }
 676 static int load_context_screen(int selection)
 677 {
 678     const struct menu_item_ex *context_menu = NULL;
 679     int retval = GO_TO_PREVIOUS;
 680     push_current_activity(ACTIVITY_CONTEXTMENU);
 681     if ((root_menu__[selection]->flags&MENU_TYPE_MASK) == MT_RETURN_VALUE)
 682     {
 683         int item = root_menu__[selection]->value;
 684         context_menu = items[item].context_menu;
 685     }
 686     /* special cases */
 687     else if (root_menu__[selection] == &info_menu)
 688     {
 689         context_menu = &system_menu;
 690     }
 691
 692     if (context_menu)
 693         retval = do_menu(context_menu, NULL, NULL, false);
 694     pop_current_activity();
 695     return retval;
 696 }
 697
 698 #ifdef HAVE_PICTUREFLOW_INTEGRATION
 699 static int load_plugin_screen(char *plug_path)
 700 {
 701     int ret_val;
 702     int old_previous = last_screen;
 703     last_screen = next_screen;
 704     global_status.last_screen = (char)next_screen;
 705     status_save();
 706
 707     switch (plugin_load(plug_path, NULL))
 708     {
 709     case PLUGIN_GOTO_WPS:
 710         ret_val = GO_TO_WPS;
 711         break;
 712     case PLUGIN_OK:
 713         ret_val = audio_status() ? GO_TO_PREVIOUS : GO_TO_ROOT;
 714         break;
 715     default:
 716         ret_val = GO_TO_PREVIOUS;
 717         break;
 718     }
 719
 720     if (ret_val == GO_TO_PREVIOUS)
 721         last_screen = (old_previous == next_screen) ? GO_TO_ROOT : old_previous;
 722     return ret_val;
 723 }
 724 #endif
 725
 726 static int previous_music = GO_TO_WPS;
 727
 728 void previous_music_is_wps(void)
 729 {
 730     previous_music = GO_TO_WPS;
 731 }
 732
 733 void root_menu(void)
 734 {
 735     int previous_browser = GO_TO_FILEBROWSER;
 736     int selected = 0;
 737
 738     push_current_activity(ACTIVITY_MAINMENU);
 739
 740     if (global_settings.start_in_screen == 0)
 741         next_screen = (int)global_status.last_screen;
 742     else next_screen = global_settings.start_in_screen - 2;
 743     add_event(PLAYBACK_EVENT_TRACK_CHANGE, false, rootmenu_track_changed_callback);
 744 #ifdef HAVE_RTC_ALARM
 745     if ( rtc_check_alarm_started(true) )
 746     {
 747         rtc_enable_alarm(false);
 748         next_screen = GO_TO_WPS;
 749 #if CONFIG_TUNER
 750         if (global_settings.alarm_wake_up_screen == ALARM_START_FM)
 751             next_screen = GO_TO_FM;
 752 #endif
 753 #ifdef HAVE_RECORDING
 754         if (global_settings.alarm_wake_up_screen == ALARM_START_REC)
 755         {
 756             recording_start_automatic = true;
 757             next_screen = GO_TO_RECSCREEN;
 758         }
 759 #endif
 760     }
 761 #endif /* HAVE_RTC_ALARM */
 762
 763 #ifdef HAVE_HEADPHONE_DETECTION
 764     if (next_screen == GO_TO_WPS &&
 765         (global_settings.unplug_autoresume && !headphones_inserted() ))
 766             next_screen = GO_TO_ROOT;
 767 #endif
 768
 769     while (true)
 770     {
 771         switch (next_screen)
 772         {
 773             case MENU_ATTACHED_USB:
 774             case MENU_SELECTED_EXIT:
 775                 /* fall through */
 776             case GO_TO_ROOT:
 777                 if (last_screen != GO_TO_ROOT)
 778                     selected = get_selection(last_screen);
 779 #if (CONFIG_PLATFORM&PLATFORM_ANDROID)
 780                 /* When we are in the main menu we want the hardware BACK
 781                  * button to be handled by Android instead of rockbox */
 782                 android_ignore_back_button(true);
 783 #endif
 784                 next_screen = do_menu(&root_menu_, &selected, NULL, false);
 785 #if (CONFIG_PLATFORM&PLATFORM_ANDROID)
 786                 android_ignore_back_button(false);
 787 #endif
 788                 if (next_screen != GO_TO_PREVIOUS)
 789                     last_screen = GO_TO_ROOT;
 790                 break;
 791
 792             case GO_TO_PREVIOUS:
 793                 next_screen = last_screen;
 794                 break;
 795
 796             case GO_TO_PREVIOUS_BROWSER:
 797                 next_screen = previous_browser;
 798                 break;
 799
 800             case GO_TO_PREVIOUS_MUSIC:
 801                 next_screen = previous_music;
 802                 break;
 803             case GO_TO_ROOTITEM_CONTEXT:
 804                 next_screen = load_context_screen(selected);
 805                 break;
 806 #ifdef HAVE_PICTUREFLOW_INTEGRATION
 807             case GO_TO_PICTUREFLOW:
 808                 while ( !tagcache_is_usable() )
 809                 {
 810                     splash(0, str(LANG_TAGCACHE_BUSY));
 811                     if ( action_userabort(HZ/5) )
 812                         break;
 813                 }
 814                 {
 815                     char pf_path[MAX_PATH];
 816                     snprintf(pf_path, sizeof(pf_path),
 817                             "%s/pictureflow.rock",
 818                             PLUGIN_DEMOS_DIR);
 819                     next_screen = load_plugin_screen(pf_path);
 820                 }
 821                 previous_browser = GO_TO_PICTUREFLOW;
 822                 break;
 823 #endif
 824             default:
 825                 if (next_screen == GO_TO_FILEBROWSER
 826 #ifdef HAVE_TAGCACHE
 827                     || next_screen == GO_TO_DBBROWSER
 828 #endif
 829                    )
 830                     previous_browser = next_screen;
 831                 if (next_screen == GO_TO_WPS
 832 #if CONFIG_TUNER
 833                     || next_screen == GO_TO_FM
 834 #endif
 835                    )
 836                     previous_music = next_screen;
 837                 next_screen = load_screen(next_screen);
 838                 break;
 839         } /* switch() */
 840     }
 841 }