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