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