apps/onplay.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Björn Stenberg
  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 <errno.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <stdbool.h>
  26
  27 #include "debug.h"
  28 #include "sprintf.h"
  29 #include "lcd.h"
  30 #include "dir.h"
  31 #include "file.h"
  32 #include "audio.h"
  33 #include "menu.h"
  34 #include "lang.h"
  35 #include "playlist.h"
  36 #include "button.h"
  37 #include "kernel.h"
  38 #include "keyboard.h"
  39 #include "mp3data.h"
  40 #include "metadata.h"
  41 #include "screens.h"
  42 #include "tree.h"
  43 #include "settings.h"
  44 #include "playlist_viewer.h"
  45 #include "talk.h"
  46 #include "onplay.h"
  47 #include "filetypes.h"
  48 #include "plugin.h"
  49 #include "bookmark.h"
  50 #include "action.h"
  51 #include "splash.h"
  52 #include "yesno.h"
  53 #include "menus/exported_menus.h"
  54 #ifdef HAVE_LCD_BITMAP
  55 #include "icons.h"
  56 #endif
  57 #include "sound_menu.h"
  58 #include "playlist_menu.h"
  59 #include "playlist_catalog.h"
  60 #ifdef HAVE_TAGCACHE
  61 #include "tagtree.h"
  62 #endif
  63 #include "cuesheet.h"
  64 #include "statusbar-skinned.h"
  65 #include "pitchscreen.h"
  66 #include "viewport.h"
  67
  68 static int context;
  69 static char* selected_file = NULL;
  70 static int selected_file_attr = 0;
  71 static int onplay_result = ONPLAY_OK;
  72 static char clipboard_selection[MAX_PATH];
  73 static int clipboard_selection_attr = 0;
  74 static bool clipboard_is_copy = false;
  75
  76 /* redefine MAKE_MENU so the MENU_EXITAFTERTHISMENU flag can be added easily */
  77 #define MAKE_ONPLAYMENU( name, str, callback, icon, ... )               \
  78     static const struct menu_item_ex *name##_[]  = {__VA_ARGS__};       \
  79     static const struct menu_callback_with_desc name##__ = {callback,str,icon};\
  80     static const struct menu_item_ex name =                             \
  81         {MT_MENU|MENU_HAS_DESC|MENU_EXITAFTERTHISMENU|                  \
  82          MENU_ITEM_COUNT(sizeof( name##_)/sizeof(*name##_)),            \
  83             { (void*)name##_},{.callback_and_desc = & name##__}};
  84
  85 /* ----------------------------------------------------------------------- */
  86 /* Displays the bookmark menu options for the user to decide.  This is an  */
  87 /* interface function.                                                     */
  88 /* ----------------------------------------------------------------------- */
  89
  90 static int bookmark_menu_callback(int action,
  91                                   const struct menu_item_ex *this_item);
  92 MENUITEM_FUNCTION(bookmark_create_menu_item, 0,
  93                   ID2P(LANG_BOOKMARK_MENU_CREATE),
  94                   bookmark_create_menu, NULL, NULL, Icon_Bookmark);
  95 MENUITEM_FUNCTION(bookmark_load_menu_item, 0,
  96                   ID2P(LANG_BOOKMARK_MENU_LIST),
  97                   bookmark_load_menu, NULL,
  98                   bookmark_menu_callback, Icon_Bookmark);
  99 MAKE_ONPLAYMENU(bookmark_menu, ID2P(LANG_BOOKMARK_MENU),
 100                 bookmark_menu_callback, Icon_Bookmark,
 101                 &bookmark_create_menu_item, &bookmark_load_menu_item);
 102 static int bookmark_menu_callback(int action,
 103                                   const struct menu_item_ex *this_item)
 104 {
 105     switch (action)
 106     {
 107         case ACTION_REQUEST_MENUITEM:
 108             if (this_item == &bookmark_load_menu_item)
 109             {
 110                 if (bookmark_exist() == 0)
 111                     return ACTION_EXIT_MENUITEM;
 112             }
 113             /* hide the bookmark menu if there is no playback */
 114             else if ((audio_status() & AUDIO_STATUS_PLAY) == 0)
 115                 return ACTION_EXIT_MENUITEM;
 116             break;
 117 #ifdef HAVE_LCD_CHARCELLS
 118         case ACTION_ENTER_MENUITEM:
 119             status_set_param(true);
 120             break;
 121 #endif
 122         case ACTION_EXIT_MENUITEM:
 123 #ifdef HAVE_LCD_CHARCELLS
 124             status_set_param(false);
 125 #endif
 126             settings_save();
 127             break;
 128     }
 129     return action;
 130 }
 131
 132 /* CONTEXT_WPS playlist options */
 133 static bool shuffle_playlist(void)
 134 {
 135     playlist_sort(NULL, true);
 136     playlist_randomise(NULL, current_tick, true);
 137
 138     return false;
 139 }
 140 static bool save_playlist(void)
 141 {
 142     save_playlist_screen(NULL);
 143     return false;
 144 }
 145
 146 extern struct menu_item_ex view_cur_playlist; /* from playlist_menu.c */
 147 MENUITEM_FUNCTION(search_playlist_item, 0, ID2P(LANG_SEARCH_IN_PLAYLIST),
 148                   search_playlist, NULL, NULL, Icon_Playlist);
 149 MENUITEM_FUNCTION(playlist_save_item, 0, ID2P(LANG_SAVE_DYNAMIC_PLAYLIST),
 150                   save_playlist, NULL, NULL, Icon_Playlist);
 151 MENUITEM_FUNCTION(reshuffle_item, 0, ID2P(LANG_SHUFFLE_PLAYLIST),
 152                   shuffle_playlist, NULL, NULL, Icon_Playlist);
 153 MAKE_ONPLAYMENU( wps_playlist_menu, ID2P(LANG_PLAYLIST),
 154                  NULL, Icon_Playlist,
 155                  &view_cur_playlist, &search_playlist_item,
 156                  &playlist_save_item, &reshuffle_item
 157                );
 158
 159 /* CONTEXT_[TREE|ID3DB] playlist options */
 160 static bool add_to_playlist(int position, bool queue)
 161 {
 162     bool new_playlist = !(audio_status() & AUDIO_STATUS_PLAY);
 163     const char *lines[] = {
 164         ID2P(LANG_RECURSE_DIRECTORY_QUESTION),
 165         selected_file
 166     };
 167     const struct text_message message={lines, 2};
 168
 169     splash(0, ID2P(LANG_WAIT));
 170
 171     if (new_playlist)
 172         playlist_create(NULL, NULL);
 173
 174     /* always set seed before inserting shuffled */
 175     if (position == PLAYLIST_INSERT_SHUFFLED ||
 176         position == PLAYLIST_INSERT_LAST_SHUFFLED)
 177     {
 178         srand(current_tick);
 179         if (position == PLAYLIST_INSERT_LAST_SHUFFLED)
 180             playlist_set_last_shuffled_start();
 181     }
 182
 183 #ifdef HAVE_TAGCACHE
 184     if (context == CONTEXT_ID3DB)
 185     {
 186         tagtree_insert_selection_playlist(position, queue);
 187     }
 188     else
 189 #endif
 190     {
 191         if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
 192             playlist_insert_track(NULL, selected_file, position, queue, true);
 193         else if (selected_file_attr & ATTR_DIRECTORY)
 194         {
 195             bool recurse = false;
 196
 197             if (global_settings.recursive_dir_insert != RECURSE_ASK)
 198                 recurse = (bool)global_settings.recursive_dir_insert;
 199             else
 200             {
 201                 /* Ask if user wants to recurse directory */
 202                 recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES);
 203             }
 204
 205             playlist_insert_directory(NULL, selected_file, position, queue,
 206                                       recurse);
 207         }
 208         else if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)
 209             playlist_insert_playlist(NULL, selected_file, position, queue);
 210     }
 211
 212     if (new_playlist && (playlist_amount() > 0))
 213     {
 214         /* nothing is currently playing so begin playing what we just
 215            inserted */
 216         if (global_settings.playlist_shuffle)
 217             playlist_shuffle(current_tick, -1);
 218         playlist_start(0,0);
 219         onplay_result = ONPLAY_START_PLAY;
 220     }
 221
 222     return false;
 223 }
 224
 225 static bool view_playlist(void)
 226 {
 227     bool was_playing = audio_status() & AUDIO_STATUS_PLAY;
 228     bool result;
 229
 230     result = playlist_viewer_ex(selected_file);
 231
 232     if (!was_playing && (audio_status() & AUDIO_STATUS_PLAY) &&
 233         onplay_result == ONPLAY_OK)
 234         /* playlist was started from viewer */
 235         onplay_result = ONPLAY_START_PLAY;
 236
 237     return result;
 238 }
 239
 240 static int playlist_insert_func(void *param)
 241 {
 242     if (((intptr_t)param == PLAYLIST_REPLACE) && !warn_on_pl_erase())
 243         return 0;
 244     add_to_playlist((intptr_t)param, false);
 245     return 0;
 246 }
 247
 248 static int playlist_queue_func(void *param)
 249 {
 250     add_to_playlist((intptr_t)param, true);
 251     return 0;
 252 }
 253
 254 static int treeplaylist_wplayback_callback(int action,
 255                                         const struct menu_item_ex* this_item)
 256 {
 257     (void)this_item;
 258     switch (action)
 259     {
 260         case ACTION_REQUEST_MENUITEM:
 261             if (audio_status() & AUDIO_STATUS_PLAY)
 262                 return action;
 263             else
 264                 return ACTION_EXIT_MENUITEM;
 265             break;
 266     }
 267     return action;
 268 }
 269
 270 static int treeplaylist_callback(int action,
 271                                  const struct menu_item_ex *this_item);
 272
 273 /* insert items */
 274 MENUITEM_FUNCTION(i_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT),
 275                   playlist_insert_func, (intptr_t*)PLAYLIST_INSERT,
 276                   NULL, Icon_Playlist);
 277 MENUITEM_FUNCTION(i_first_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT_FIRST),
 278                   playlist_insert_func, (intptr_t*)PLAYLIST_INSERT_FIRST,
 279                   treeplaylist_wplayback_callback, Icon_Playlist);
 280 MENUITEM_FUNCTION(i_last_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT_LAST),
 281                   playlist_insert_func, (intptr_t*)PLAYLIST_INSERT_LAST,
 282                   treeplaylist_wplayback_callback, Icon_Playlist);
 283 MENUITEM_FUNCTION(i_shuf_pl_item, MENU_FUNC_USEPARAM,
 284                   ID2P(LANG_INSERT_SHUFFLED), playlist_insert_func,
 285                   (intptr_t*)PLAYLIST_INSERT_SHUFFLED,
 286                   treeplaylist_callback, Icon_Playlist);
 287 MENUITEM_FUNCTION(i_last_shuf_pl_item, MENU_FUNC_USEPARAM,
 288                   ID2P(LANG_INSERT_LAST_SHUFFLED), playlist_insert_func,
 289                   (intptr_t*)PLAYLIST_INSERT_LAST_SHUFFLED,
 290                   treeplaylist_callback, Icon_Playlist);
 291 /* queue items */
 292 MENUITEM_FUNCTION(q_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE),
 293                   playlist_queue_func, (intptr_t*)PLAYLIST_INSERT,
 294                   treeplaylist_wplayback_callback, Icon_Playlist);
 295 MENUITEM_FUNCTION(q_first_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE_FIRST),
 296                   playlist_queue_func, (intptr_t*)PLAYLIST_INSERT_FIRST,
 297                   treeplaylist_wplayback_callback, Icon_Playlist);
 298 MENUITEM_FUNCTION(q_last_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE_LAST),
 299                   playlist_queue_func, (intptr_t*)PLAYLIST_INSERT_LAST,
 300                   treeplaylist_wplayback_callback, Icon_Playlist);
 301 MENUITEM_FUNCTION(q_shuf_pl_item, MENU_FUNC_USEPARAM,
 302                   ID2P(LANG_QUEUE_SHUFFLED), playlist_queue_func,
 303                   (intptr_t*)PLAYLIST_INSERT_SHUFFLED,
 304                   treeplaylist_wplayback_callback, Icon_Playlist);
 305 MENUITEM_FUNCTION(q_last_shuf_pl_item, MENU_FUNC_USEPARAM,
 306                   ID2P(LANG_QUEUE_LAST_SHUFFLED), playlist_queue_func,
 307                   (intptr_t*)PLAYLIST_INSERT_LAST_SHUFFLED,
 308                   treeplaylist_callback, Icon_Playlist);
 309 /* replace playlist */
 310 MENUITEM_FUNCTION(replace_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_REPLACE),
 311                   playlist_insert_func, (intptr_t*)PLAYLIST_REPLACE,
 312                   treeplaylist_wplayback_callback, Icon_Playlist);
 313
 314 /* others */
 315 MENUITEM_FUNCTION(view_playlist_item, 0, ID2P(LANG_VIEW),
 316                   view_playlist, NULL,
 317                   treeplaylist_callback, Icon_Playlist);
 318
 319 MAKE_ONPLAYMENU( tree_playlist_menu, ID2P(LANG_PLAYLIST),
 320                  treeplaylist_callback, Icon_Playlist,
 321
 322                  /* view */
 323                  &view_playlist_item,
 324
 325                  /* insert */
 326                  &i_pl_item, &i_first_pl_item, &i_last_pl_item,
 327                  &i_shuf_pl_item, &i_last_shuf_pl_item,
 328                  /* queue */
 329
 330                  &q_pl_item, &q_first_pl_item, &q_last_pl_item,
 331                  &q_shuf_pl_item, &q_last_shuf_pl_item,
 332
 333                  /* replace */
 334                  &replace_pl_item
 335                );
 336 static int treeplaylist_callback(int action,
 337                                  const struct menu_item_ex *this_item)
 338 {
 339     switch (action)
 340     {
 341         case ACTION_REQUEST_MENUITEM:
 342             if (this_item == &tree_playlist_menu)
 343             {
 344                 if (((selected_file_attr & FILE_ATTR_MASK) ==
 345                         FILE_ATTR_AUDIO) ||
 346                     ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)||
 347                      (selected_file_attr & ATTR_DIRECTORY))
 348                 {
 349                     return action;
 350                 }
 351             }
 352             else if (this_item == &view_playlist_item)
 353             {
 354                 if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U &&
 355                         context == CONTEXT_TREE)
 356                 {
 357                     return action;
 358                 }
 359             }
 360             else if (this_item == &i_shuf_pl_item)
 361             {
 362                 if ((audio_status() & AUDIO_STATUS_PLAY) ||
 363                     (selected_file_attr & ATTR_DIRECTORY) ||
 364                     ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U))
 365                 {
 366                     return action;
 367                 }
 368             }
 369             else if (this_item == &i_last_shuf_pl_item ||
 370                      this_item == &q_last_shuf_pl_item)
 371             {
 372                 if ((playlist_amount() > 0) &&
 373                     (audio_status() & AUDIO_STATUS_PLAY) &&
 374                     ((selected_file_attr & ATTR_DIRECTORY) ||
 375                     ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)))
 376                 {
 377                     return action;
 378                 }
 379             }
 380             return ACTION_EXIT_MENUITEM;
 381             break;
 382     }
 383     return action;
 384 }
 385
 386
 387 /* playlist catalog options */
 388 static bool cat_add_to_a_playlist(void)
 389 {
 390     return catalog_add_to_a_playlist(selected_file, selected_file_attr,
 391                                      false, NULL);
 392 }
 393
 394 static bool cat_add_to_a_new_playlist(void)
 395 {
 396     return catalog_add_to_a_playlist(selected_file, selected_file_attr,
 397                                      true, NULL);
 398 }
 399
 400 static int cat_playlist_callback(int action,
 401                                  const struct menu_item_ex *this_item);
 402 MENUITEM_FUNCTION(cat_view_lists, 0, ID2P(LANG_CATALOG_VIEW),
 403                   catalog_view_playlists, 0,
 404                   cat_playlist_callback, Icon_Playlist);
 405 MENUITEM_FUNCTION(cat_add_to_list, 0, ID2P(LANG_CATALOG_ADD_TO),
 406                   cat_add_to_a_playlist, 0, NULL, Icon_Playlist);
 407 MENUITEM_FUNCTION(cat_add_to_new, 0, ID2P(LANG_CATALOG_ADD_TO_NEW),
 408                   cat_add_to_a_new_playlist, 0, NULL, Icon_Playlist);
 409 MAKE_ONPLAYMENU(cat_playlist_menu, ID2P(LANG_CATALOG),
 410                 cat_playlist_callback, Icon_Playlist,
 411                 &cat_view_lists, &cat_add_to_list, &cat_add_to_new);
 412
 413 static int cat_playlist_callback(int action,
 414                                  const struct menu_item_ex *this_item)
 415 {
 416     if (!selected_file ||
 417         (((selected_file_attr & FILE_ATTR_MASK) != FILE_ATTR_AUDIO) &&
 418          ((selected_file_attr & FILE_ATTR_MASK) != FILE_ATTR_M3U) &&
 419          ((selected_file_attr & ATTR_DIRECTORY) == 0)))
 420     {
 421         return ACTION_EXIT_MENUITEM;
 422     }
 423 #ifdef HAVE_TAGCACHE
 424     if (context == CONTEXT_ID3DB &&
 425         ((selected_file_attr & FILE_ATTR_MASK) != FILE_ATTR_AUDIO))
 426     {
 427         return ACTION_EXIT_MENUITEM;
 428     }
 429 #endif
 430
 431     switch (action)
 432     {
 433         case ACTION_REQUEST_MENUITEM:
 434             if (this_item == &cat_view_lists)
 435             {
 436                 return action;
 437             }
 438             else if ((audio_status() & AUDIO_STATUS_PLAY) ||
 439                      context != CONTEXT_WPS)
 440             {
 441                 return action;
 442             }
 443             else
 444                 return ACTION_EXIT_MENUITEM;
 445             break;
 446     }
 447     return action;
 448 }
 449
 450 #ifdef HAVE_LCD_BITMAP
 451 static void draw_slider(void)
 452 {
 453     int i;
 454     FOR_NB_SCREENS(i)
 455     {
 456         struct viewport vp;
 457         int slider_height = 2*screens[i].getcharheight();
 458         viewport_set_defaults(&vp, i);
 459         screens[i].set_viewport(&vp);
 460         show_busy_slider(&screens[i], 1, vp.height - slider_height,
 461                          vp.width-2, slider_height-1);
 462         screens[i].update_viewport();
 463         screens[i].set_viewport(NULL);
 464     }
 465 }
 466 #else
 467 #define draw_slider()
 468 #endif
 469
 470 /* helper function to remove a non-empty directory */
 471 static int remove_dir(char* dirname, int len)
 472 {
 473     int result = 0;
 474     DIR* dir;
 475     int dirlen = strlen(dirname);
 476
 477     dir = opendir(dirname);
 478     if (!dir)
 479         return -1; /* open error */
 480
 481     while(true)
 482     {
 483         struct dirent* entry;
 484         /* walk through the directory content */
 485         entry = readdir(dir);
 486         if (!entry)
 487             break;
 488
 489         dirname[dirlen] ='\0';
 490         /* inform the user which dir we're deleting */
 491         splash(0, dirname);
 492
 493         /* append name to current directory */
 494         snprintf(dirname+dirlen, len-dirlen, "/%s", entry->d_name);
 495         if (entry->attribute & ATTR_DIRECTORY)
 496         {   /* remove a subdirectory */
 497             if (!strcmp((char *)entry->d_name, ".") ||
 498                 !strcmp((char *)entry->d_name, ".."))
 499                 continue; /* skip these */
 500
 501             result = remove_dir(dirname, len); /* recursion */
 502             if (result)
 503                 break; /* or better continue, delete what we can? */
 504         }
 505         else
 506         {   /* remove a file */
 507             draw_slider();
 508             result = remove(dirname);
 509         }
 510         if(ACTION_STD_CANCEL == get_action(CONTEXT_STD,TIMEOUT_NOBLOCK))
 511         {
 512             splash(HZ, ID2P(LANG_CANCEL));
 513             result = -1;
 514             break;
 515         }
 516     }
 517     closedir(dir);
 518
 519     if (!result)
 520     {   /* remove the now empty directory */
 521         dirname[dirlen] = '\0'; /* terminate to original length */
 522
 523         result = rmdir(dirname);
 524     }
 525
 526     return result;
 527 }
 528
 529
 530 /* share code for file and directory deletion, saves space */
 531 static bool delete_file_dir(void)
 532 {
 533     char file_to_delete[MAX_PATH];
 534     strcpy(file_to_delete, selected_file);
 535
 536     const char *lines[]={
 537         ID2P(LANG_REALLY_DELETE),
 538         file_to_delete
 539     };
 540     const char *yes_lines[]={
 541         ID2P(LANG_DELETING),
 542         file_to_delete
 543     };
 544
 545     const struct text_message message={lines, 2};
 546     const struct text_message yes_message={yes_lines, 2};
 547
 548     if(gui_syncyesno_run(&message, &yes_message, NULL)!=YESNO_YES)
 549         return false;
 550
 551     splash(0, str(LANG_DELETING));
 552
 553     int res;
 554     if (selected_file_attr & ATTR_DIRECTORY) /* true if directory */
 555     {
 556         char pathname[MAX_PATH]; /* space to go deep */
 557         cpu_boost(true);
 558         strlcpy(pathname, file_to_delete, sizeof(pathname));
 559         res = remove_dir(pathname, sizeof(pathname));
 560         cpu_boost(false);
 561     }
 562     else
 563         res = remove(file_to_delete);
 564
 565     if (!res)
 566         onplay_result = ONPLAY_RELOAD_DIR;
 567
 568     return (res == 0);
 569 }
 570
 571 static bool rename_file(void)
 572 {
 573     char newname[MAX_PATH];
 574     char* ptr = strrchr(selected_file, '/') + 1;
 575     int pathlen = (ptr - selected_file);
 576     strlcpy(newname, selected_file, sizeof(newname));
 577     if (!kbd_input(newname + pathlen, (sizeof newname)-pathlen)) {
 578         if (!strlen(newname + pathlen) ||
 579             (rename(selected_file, newname) < 0)) {
 580             cond_talk_ids_fq(LANG_RENAME, LANG_FAILED);
 581             splashf(HZ*2, "%s %s", str(LANG_RENAME), str(LANG_FAILED));
 582         }
 583         else
 584             onplay_result = ONPLAY_RELOAD_DIR;
 585     }
 586
 587     return false;
 588 }
 589
 590 static bool create_dir(void)
 591 {
 592     char dirname[MAX_PATH];
 593     char *cwd;
 594     int rc;
 595     int pathlen;
 596
 597     cwd = getcwd(NULL, 0);
 598     memset(dirname, 0, sizeof dirname);
 599
 600     snprintf(dirname, sizeof dirname, "%s/", cwd[1] ? cwd : "");
 601
 602     pathlen = strlen(dirname);
 603     rc = kbd_input(dirname + pathlen, (sizeof dirname)-pathlen);
 604     if (rc < 0)
 605         return false;
 606
 607     rc = mkdir(dirname);
 608     if (rc < 0) {
 609         cond_talk_ids_fq(LANG_CREATE_DIR, LANG_FAILED);
 610         splashf(HZ, (unsigned char *)"%s %s", str(LANG_CREATE_DIR),
 611                                               str(LANG_FAILED));
 612     } else {
 613         onplay_result = ONPLAY_RELOAD_DIR;
 614     }
 615
 616     return true;
 617 }
 618
 619 /* Store the current selection in the clipboard */
 620 static bool clipboard_clip(bool copy)
 621 {
 622     clipboard_selection[0] = 0;
 623     strlcpy(clipboard_selection, selected_file, sizeof(clipboard_selection));
 624     clipboard_selection_attr = selected_file_attr;
 625     clipboard_is_copy = copy;
 626
 627     return true;
 628 }
 629
 630 static bool clipboard_cut(void)
 631 {
 632     return clipboard_clip(false);
 633 }
 634
 635 static bool clipboard_copy(void)
 636 {
 637     return clipboard_clip(true);
 638 }
 639
 640 /* Paste a file to a new directory. Will overwrite always. */
 641 static bool clipboard_pastefile(const char *src, const char *target, bool copy)
 642 {
 643     int src_fd, target_fd;
 644     size_t buffersize;
 645     ssize_t size, bytesread, byteswritten;
 646     char *buffer;
 647     bool result = false;
 648
 649     if (copy) {
 650         /* See if we can get the plugin buffer for the file copy buffer */
 651         buffer = (char *) plugin_get_buffer(&buffersize);
 652         if (buffer == NULL || buffersize < 512) {
 653             /* Not large enough, try for a disk sector worth of stack
 654                instead */
 655             buffersize = 512;
 656             buffer = (char *) __builtin_alloca(buffersize);
 657         }
 658
 659         if (buffer == NULL) {
 660             return false;
 661         }
 662
 663         buffersize &= ~0x1ff;  /* Round buffer size to multiple of sector
 664                                   size */
 665
 666         src_fd = open(src, O_RDONLY);
 667
 668         if (src_fd >= 0) {
 669             target_fd = creat(target);
 670
 671             if (target_fd >= 0) {
 672                 result = true;
 673
 674                 size = filesize(src_fd);
 675
 676                 if (size == -1) {
 677                     result = false;
 678                 }
 679
 680                 while(size > 0) {
 681                     bytesread = read(src_fd, buffer, buffersize);
 682
 683                     if (bytesread == -1) {
 684                         result = false;
 685                         break;
 686                     }
 687
 688                     size -= bytesread;
 689
 690                     while(bytesread > 0) {
 691                         byteswritten = write(target_fd, buffer, bytesread);
 692
 693                         if (byteswritten < 0) {
 694                             result = false;
 695                             size = 0;
 696                             break;
 697                         }
 698
 699                         bytesread -= byteswritten;
 700                         draw_slider();
 701                     }
 702                 }
 703
 704                 close(target_fd);
 705
 706                 /* Copy failed. Cleanup. */
 707                 if (!result) {
 708                     remove(target);
 709                 }
 710             }
 711
 712             close(src_fd);
 713         }
 714     } else {
 715         result = rename(src, target) == 0;
 716 #ifdef HAVE_MULTIVOLUME
 717         if (!result) {
 718             if (errno == EXDEV) {
 719                 /* Failed because cross volume rename doesn't work. Copy
 720                    instead */
 721                 result = clipboard_pastefile(src, target, true);
 722
 723                 if (result) {
 724                     result = remove(src) == 0;
 725                 }
 726             }
 727         }
 728 #endif
 729     }
 730
 731     return result;
 732 }
 733
 734 /* Paste a directory to a new location. Designed to be called by
 735    clipboard_paste */
 736 static bool clipboard_pastedirectory(char *src, int srclen, char *target,
 737                                      int targetlen, bool copy)
 738 {
 739     DIR *srcdir;
 740     int srcdirlen = strlen(src);
 741     int targetdirlen = strlen(target);
 742     bool result = true;
 743
 744     if (!file_exists(target)) {
 745         if (!copy) {
 746             /* Just move the directory */
 747             result = rename(src, target) == 0;
 748
 749 #ifdef HAVE_MULTIVOLUME
 750             if (!result && errno == EXDEV) {
 751                 /* Try a copy as we're going across devices */
 752                 result = clipboard_pastedirectory(src, srclen, target,
 753                     targetlen, true);
 754
 755                 /* If it worked, remove the source directory */
 756                 if (result) {
 757                     remove_dir(src, srclen);
 758                 }
 759             }
 760 #endif
 761             return result;
 762         } else {
 763             /* Make a directory to copy things to */
 764             result = mkdir(target) == 0;
 765         }
 766     }
 767
 768     /* Check if something went wrong already */
 769     if (!result) {
 770         return result;
 771     }
 772
 773     srcdir = opendir(src);
 774     if (!srcdir) {
 775         return false;
 776     }
 777
 778     /* This loop will exit as soon as there's a problem */
 779     while(result)
 780     {
 781         struct dirent* entry;
 782         /* walk through the directory content */
 783         entry = readdir(srcdir);
 784         if (!entry)
 785             break;
 786
 787         /* append name to current directory */
 788         snprintf(src+srcdirlen, srclen-srcdirlen, "/%s", entry->d_name);
 789         snprintf(target+targetdirlen, targetlen-targetdirlen, "/%s",
 790             entry->d_name);
 791
 792         DEBUGF("Copy %s to %s\n", src, target);
 793
 794         if (entry->attribute & ATTR_DIRECTORY)
 795         {   /* copy/move a subdirectory */
 796             if (!strcmp((char *)entry->d_name, ".") ||
 797                 !strcmp((char *)entry->d_name, ".."))
 798                 continue; /* skip these */
 799
 800             result = clipboard_pastedirectory(src, srclen, target, targetlen,
 801                 copy); /* recursion */
 802         }
 803         else
 804         {   /* copy/move a file */
 805             draw_slider();
 806             result = clipboard_pastefile(src, target, copy);
 807         }
 808     }
 809
 810     closedir(srcdir);
 811
 812     if (result) {
 813         src[srcdirlen] = '\0'; /* terminate to original length */
 814         target[targetdirlen] = '\0'; /* terminate to original length */
 815     }
 816
 817     return result;
 818 }
 819
 820 /* Paste the clipboard to the current directory */
 821 static bool clipboard_paste(void)
 822 {
 823     char target[MAX_PATH];
 824     char *cwd, *nameptr;
 825     bool success;
 826
 827     static const char *lines[]={ID2P(LANG_REALLY_OVERWRITE)};
 828     static const struct text_message message={lines, 1};
 829
 830     /* Get the name of the current directory */
 831     cwd = getcwd(NULL, 0);
 832
 833     /* Figure out the name of the selection */
 834     nameptr = strrchr(clipboard_selection, '/');
 835
 836     /* Final target is current directory plus name of selection  */
 837     snprintf(target, sizeof(target), "%s%s", cwd[1] ? cwd : "", nameptr);
 838
 839     /* If the target existed but they choose not to overwite, exit */
 840     if (file_exists(target) &&
 841         (gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)) {
 842         return false;
 843     }
 844
 845     if (clipboard_is_copy) {
 846         splash(0, ID2P(LANG_COPYING));
 847     }
 848     else
 849     {
 850         splash(0, ID2P(LANG_MOVING));
 851     }
 852
 853     /* Now figure out what we're doing */
 854     cpu_boost(true);
 855     if (clipboard_selection_attr & ATTR_DIRECTORY) {
 856         /* Recursion. Set up external stack */
 857         char srcpath[MAX_PATH];
 858         char targetpath[MAX_PATH];
 859         if (!strncmp(clipboard_selection, target, strlen(clipboard_selection)))
 860         {
 861             /* Do not allow the user to paste a directory into a dir they are
 862                copying */
 863             success = 0;
 864         }
 865         else
 866         {
 867             strlcpy(srcpath, clipboard_selection, sizeof(srcpath));
 868             strlcpy(targetpath, target, sizeof(targetpath));
 869
 870             success = clipboard_pastedirectory(srcpath, sizeof(srcpath),
 871                              target, sizeof(targetpath), clipboard_is_copy);
 872
 873             if (success && !clipboard_is_copy)
 874             {
 875                 strlcpy(srcpath, clipboard_selection, sizeof(srcpath));
 876                 remove_dir(srcpath, sizeof(srcpath));
 877             }
 878         }
 879     } else {
 880         success = clipboard_pastefile(clipboard_selection, target,
 881             clipboard_is_copy);
 882     }
 883     cpu_boost(false);
 884
 885     /* Did it work? */
 886     if (success) {
 887         /* Reset everything */
 888         clipboard_selection[0] = 0;
 889         clipboard_selection_attr = 0;
 890         clipboard_is_copy = false;
 891
 892         /* Force reload of the current directory */
 893         onplay_result = ONPLAY_RELOAD_DIR;
 894     } else {
 895         cond_talk_ids_fq(LANG_PASTE, LANG_FAILED);
 896         splashf(HZ, (unsigned char *)"%s %s", str(LANG_PASTE),
 897                                               str(LANG_FAILED));
 898     }
 899
 900     return true;
 901 }
 902
 903 #ifdef HAVE_TAGCACHE
 904 static int set_rating_inline(void)
 905 {
 906     struct mp3entry* id3 = audio_current_track();
 907     if (id3 && id3->tagcache_idx && global_settings.runtimedb)
 908     {
 909         set_int_ex(str(LANG_MENU_SET_RATING), "", UNIT_INT, (void*)(&id3->rating),
 910                    NULL, 1, 0, 10, NULL, NULL);
 911         tagcache_update_numeric(id3->tagcache_idx-1, tag_rating, id3->rating);
 912     }
 913     else
 914         splash(HZ*2, ID2P(LANG_ID3_NO_INFO));
 915     return 0;
 916 }
 917 static int ratingitem_callback(int action,const struct menu_item_ex *this_item)
 918 {
 919     (void)this_item;
 920     switch (action)
 921     {
 922         case ACTION_REQUEST_MENUITEM:
 923             if (!selected_file || !global_settings.runtimedb ||
 924                 !tagcache_is_usable())
 925                 return ACTION_EXIT_MENUITEM;
 926             break;
 927     }
 928     return action;
 929 }
 930 MENUITEM_FUNCTION(rating_item, 0, ID2P(LANG_MENU_SET_RATING),
 931                   set_rating_inline, NULL,
 932                   ratingitem_callback, Icon_Questionmark);
 933 #endif
 934
 935 static bool view_cue(void)
 936 {
 937     struct mp3entry* id3 = audio_current_track();
 938     if(id3 && id3->cuesheet)
 939     {
 940         browse_cuesheet(id3->cuesheet);
 941     }
 942     return false;
 943 }
 944 static int view_cue_item_callback(int action,
 945                                   const struct menu_item_ex *this_item)
 946 {
 947     (void)this_item;
 948     struct mp3entry* id3 = audio_current_track();
 949     switch (action)
 950     {
 951         case ACTION_REQUEST_MENUITEM:
 952             if (!selected_file
 953                 || !id3 || !id3->cuesheet)
 954                 return ACTION_EXIT_MENUITEM;
 955             break;
 956     }
 957     return action;
 958 }
 959 MENUITEM_FUNCTION(view_cue_item, 0, ID2P(LANG_BROWSE_CUESHEET),
 960                   view_cue, NULL, view_cue_item_callback, Icon_NOICON);
 961
 962 /* CONTEXT_WPS items */
 963 MENUITEM_FUNCTION(browse_id3_item, 0, ID2P(LANG_MENU_SHOW_ID3_INFO),
 964                   browse_id3, NULL, NULL, Icon_NOICON);
 965 #ifdef HAVE_PITCHSCREEN
 966 MENUITEM_FUNCTION(pitch_screen_item, 0, ID2P(LANG_PITCH),
 967                   gui_syncpitchscreen_run, NULL, NULL, Icon_Audio);
 968 #endif
 969
 970 /* CONTEXT_[TREE|ID3DB] items */
 971 static int clipboard_callback(int action,const struct menu_item_ex *this_item);
 972 MENUITEM_FUNCTION(rename_file_item, 0, ID2P(LANG_RENAME),
 973                   rename_file, NULL, clipboard_callback, Icon_NOICON);
 974 MENUITEM_FUNCTION(clipboard_cut_item, 0, ID2P(LANG_CUT),
 975                   clipboard_cut, NULL, clipboard_callback, Icon_NOICON);
 976 MENUITEM_FUNCTION(clipboard_copy_item, 0, ID2P(LANG_COPY),
 977                   clipboard_copy, NULL, clipboard_callback, Icon_NOICON);
 978 MENUITEM_FUNCTION(clipboard_paste_item, 0, ID2P(LANG_PASTE),
 979                   clipboard_paste, NULL, clipboard_callback, Icon_NOICON);
 980 MENUITEM_FUNCTION(delete_file_item, 0, ID2P(LANG_DELETE),
 981                   delete_file_dir, NULL, clipboard_callback, Icon_NOICON);
 982 MENUITEM_FUNCTION(delete_dir_item, 0, ID2P(LANG_DELETE_DIR),
 983                   delete_file_dir, NULL, clipboard_callback, Icon_NOICON);
 984 MENUITEM_FUNCTION(create_dir_item, 0, ID2P(LANG_CREATE_DIR),
 985                   create_dir, NULL, clipboard_callback, Icon_NOICON);
 986
 987 /* other items */
 988 static bool list_viewers(void)
 989 {
 990     int ret = filetype_list_viewers(selected_file);
 991     if (ret == PLUGIN_USB_CONNECTED)
 992         onplay_result = ONPLAY_RELOAD_DIR;
 993     return false;
 994 }
 995
 996 static bool onplay_load_plugin(void *param)
 997 {
 998     int ret = filetype_load_plugin((const char*)param, selected_file);
 999     if (ret == PLUGIN_USB_CONNECTED)
1000         onplay_result = ONPLAY_RELOAD_DIR;
1001     return false;
1002 }
1003
1004 MENUITEM_FUNCTION(list_viewers_item, 0, ID2P(LANG_ONPLAY_OPEN_WITH),
1005                   list_viewers, NULL, clipboard_callback, Icon_NOICON);
1006 MENUITEM_FUNCTION(properties_item, MENU_FUNC_USEPARAM, ID2P(LANG_PROPERTIES),
1007                   onplay_load_plugin, (void *)"properties",
1008                   clipboard_callback, Icon_NOICON);
1009 MENUITEM_FUNCTION(add_to_faves_item, MENU_FUNC_USEPARAM, ID2P(LANG_ADD_TO_FAVES),
1010                   onplay_load_plugin, (void *)"shortcuts_append",
1011                   clipboard_callback, Icon_NOICON);
1012
1013 #if LCD_DEPTH > 1
1014 static bool set_backdrop(void)
1015 {
1016     /* load the image */
1017     if(sb_set_backdrop(SCREEN_MAIN, selected_file)) {
1018         splash(HZ, str(LANG_BACKDROP_LOADED));
1019         set_file(selected_file, (char *)global_settings.backdrop_file,
1020             MAX_FILENAME);
1021         return true;
1022     } else {
1023         splash(HZ, str(LANG_BACKDROP_FAILED));
1024         return false;
1025     }
1026     return true;
1027 }
1028 MENUITEM_FUNCTION(set_backdrop_item, 0, ID2P(LANG_SET_AS_BACKDROP),
1029                   set_backdrop, NULL, clipboard_callback, Icon_NOICON);
1030 #endif
1031 #ifdef HAVE_RECORDING
1032 static bool set_recdir(void)
1033 {
1034     strlcpy(global_settings.rec_directory, selected_file, MAX_FILENAME+1);
1035     settings_save();
1036     return false;
1037 }
1038 MENUITEM_FUNCTION(set_recdir_item, 0, ID2P(LANG_SET_AS_REC_DIR),
1039                   set_recdir, NULL, clipboard_callback, Icon_Recording);
1040 #endif
1041
1042 static int clipboard_callback(int action,const struct menu_item_ex *this_item)
1043 {
1044     switch (action)
1045     {
1046         case ACTION_REQUEST_MENUITEM:
1047 #ifdef HAVE_MULTIVOLUME
1048             if ((selected_file_attr & FAT_ATTR_VOLUME) &&
1049                 (this_item == &rename_file_item ||
1050                  this_item == &delete_dir_item ||
1051                  this_item == &clipboard_cut_item) )
1052                 return ACTION_EXIT_MENUITEM;
1053             /* no rename+delete for volumes */
1054             if ((selected_file_attr & ATTR_VOLUME) &&
1055                  (this_item == &delete_file_item ||
1056                   this_item == &list_viewers_item))
1057                 return ACTION_EXIT_MENUITEM;
1058 #endif
1059 #ifdef HAVE_TAGCACHE
1060             if (context == CONTEXT_ID3DB)
1061             {
1062                 if (((selected_file_attr & FILE_ATTR_MASK) ==
1063                         FILE_ATTR_AUDIO) &&
1064                     this_item == &properties_item)
1065                     return action;
1066                 return ACTION_EXIT_MENUITEM;
1067             }
1068 #endif
1069             if (this_item == &clipboard_paste_item)
1070             {  /* visible if there is something to paste */
1071                 return (clipboard_selection[0] != 0) ?
1072                                     action : ACTION_EXIT_MENUITEM;
1073             }
1074             else if (this_item == &create_dir_item)
1075             {
1076                 /* always visible */
1077                 return action;
1078             }
1079             else if (selected_file)
1080             {
1081                 /* requires an actual file */
1082                 if (this_item == &rename_file_item ||
1083                     this_item == &clipboard_cut_item ||
1084                     this_item == &clipboard_copy_item ||
1085                     this_item == &properties_item ||
1086                     this_item == &add_to_faves_item)
1087                 {
1088                     return action;
1089                 }
1090                 else if ((selected_file_attr & ATTR_DIRECTORY))
1091                 {
1092                     /* only for directories */
1093                     if (this_item == &delete_dir_item
1094 #ifdef HAVE_RECORDING
1095                      || this_item == &set_recdir_item
1096 #endif
1097                         )
1098                         return action;
1099                 }
1100                 else if (this_item == &delete_file_item ||
1101                          this_item == &list_viewers_item)
1102                 {
1103                     /* only for files */
1104                     return action;
1105                 }
1106 #if LCD_DEPTH > 1
1107                 else if (this_item == &set_backdrop_item)
1108                 {
1109                     char *suffix = strrchr(selected_file, '.');
1110                     if (suffix)
1111                     {
1112                         if (strcasecmp(suffix, ".bmp") == 0)
1113                         {
1114                             return action;
1115                         }
1116                     }
1117                 }
1118 #endif
1119             }
1120             return ACTION_EXIT_MENUITEM;
1121             break;
1122     }
1123     return action;
1124 }
1125
1126 static int onplaymenu_callback(int action,const struct menu_item_ex *this_item);
1127 /* used when onplay() is called in the CONTEXT_WPS context */
1128 MAKE_ONPLAYMENU( wps_onplay_menu, ID2P(LANG_ONPLAY_MENU_TITLE),
1129            onplaymenu_callback, Icon_Audio,
1130            &wps_playlist_menu, &cat_playlist_menu,
1131            &sound_settings, &playback_settings,
1132 #ifdef HAVE_TAGCACHE
1133            &rating_item,
1134 #endif
1135            &bookmark_menu, &browse_id3_item, &list_viewers_item,
1136            &delete_file_item, &view_cue_item,
1137 #ifdef HAVE_PITCHSCREEN
1138            &pitch_screen_item,
1139 #endif
1140          );
1141 /* used when onplay() is not called in the CONTEXT_WPS context */
1142 MAKE_ONPLAYMENU( tree_onplay_menu, ID2P(LANG_ONPLAY_MENU_TITLE),
1143            onplaymenu_callback, Icon_file_view_menu,
1144            &tree_playlist_menu, &cat_playlist_menu,
1145            &rename_file_item, &clipboard_cut_item, &clipboard_copy_item,
1146            &clipboard_paste_item, &delete_file_item, &delete_dir_item,
1147 #if LCD_DEPTH > 1
1148            &set_backdrop_item,
1149 #endif
1150            &list_viewers_item, &create_dir_item, &properties_item,
1151 #ifdef HAVE_RECORDING
1152            &set_recdir_item,
1153 #endif
1154            &add_to_faves_item,
1155          );
1156 static int onplaymenu_callback(int action,const struct menu_item_ex *this_item)
1157 {
1158     switch (action)
1159     {
1160         case ACTION_TREE_STOP:
1161             if (this_item == &wps_onplay_menu)
1162             {
1163                 list_stop_handler();
1164                 return ACTION_STD_CANCEL;
1165             }
1166             break;
1167         case ACTION_EXIT_MENUITEM:
1168             return ACTION_EXIT_AFTER_THIS_MENUITEM;
1169             break;
1170     }
1171     return action;
1172 }
1173
1174 #ifdef HAVE_HOTKEY
1175 /* direct function calls, no need for menu callbacks */
1176 static bool delete_item(void)
1177 {
1178 #ifdef HAVE_MULTIVOLUME
1179     /* no delete for volumes */
1180     if ((selected_file_attr & FAT_ATTR_VOLUME) ||
1181         (selected_file_attr & ATTR_VOLUME))
1182         return false;
1183 #endif
1184     return delete_file_dir();
1185 }
1186
1187 static bool open_with(void)
1188 {
1189     /* only open files */
1190     if (selected_file_attr & ATTR_DIRECTORY)
1191         return false;
1192 #ifdef HAVE_MULTIVOLUME
1193     if (selected_file_attr & ATTR_VOLUME)
1194         return false;
1195 #endif
1196     return list_viewers();
1197 }
1198
1199 extern const struct menu_item_ex *selected_menu_item;
1200 extern bool hotkey_settable_menu;
1201
1202 #define HOTKEY_ACTION_MASK 0x0FF /* Mask to apply to get the action (enum)           */
1203 #define HOTKEY_CTX_WPS     0x100 /* Mask to apply to check whether it's for WPS      */
1204 #define HOTKEY_CTX_TREE    0x200 /* Mask to apply to check whether it's for the tree */
1205
1206 /* Any desired hotkey functions go here... */
1207 enum hotkey_action {
1208     HOTKEY_OFF = 0,
1209     HOTKEY_VIEW_PLAYLIST = 1,
1210     HOTKEY_SHOW_TRACK_INFO,
1211     HOTKEY_PITCHSCREEN,
1212     HOTKEY_OPEN_WITH,
1213     HOTKEY_DELETE,
1214     HOTKEY_INSERT,
1215 };
1216
1217 struct hotkey_assignment {
1218     int item;               /* Bit or'd hotkey_action and HOTKEY_CTX_x   */
1219     struct menu_func func;  /* Function to run if this entry is selected */
1220     int return_code;        /* What to return after the function is run  */
1221     const struct menu_item_ex *menu_addr; /* Must have non-dynamic text, */
1222         /* i.e. have the flag MENU_HAS_DESC. E.g. be a MENUITEM_FUNCTION */
1223         /* For all possibilities see menu.h.                             */
1224 };
1225
1226 #define HOTKEY_FUNC(func, param) {{(void *)func}, param}
1227
1228 /* ... and here.  Order is not important. */
1229 static struct hotkey_assignment hotkey_items[] = {
1230     { HOTKEY_VIEW_PLAYLIST  | HOTKEY_CTX_WPS,
1231             HOTKEY_FUNC(NULL, NULL),
1232             ONPLAY_PLAYLIST,    &view_cur_playlist },
1233     { HOTKEY_SHOW_TRACK_INFO| HOTKEY_CTX_WPS,
1234             HOTKEY_FUNC(browse_id3, NULL),
1235             ONPLAY_RELOAD_DIR,  &browse_id3_item },
1236 #ifdef HAVE_PITCHSCREEN
1237     { HOTKEY_PITCHSCREEN    | HOTKEY_CTX_WPS,
1238             HOTKEY_FUNC(gui_syncpitchscreen_run, NULL),
1239             ONPLAY_RELOAD_DIR,  &pitch_screen_item },
1240 #endif
1241     { HOTKEY_OPEN_WITH      | HOTKEY_CTX_WPS | HOTKEY_CTX_TREE,
1242             HOTKEY_FUNC(open_with, NULL),
1243             ONPLAY_RELOAD_DIR,  &list_viewers_item },
1244     { HOTKEY_DELETE         | HOTKEY_CTX_WPS | HOTKEY_CTX_TREE,
1245             HOTKEY_FUNC(delete_item, NULL),
1246             ONPLAY_RELOAD_DIR,  &delete_file_item },
1247     { HOTKEY_DELETE         | HOTKEY_CTX_TREE,
1248             HOTKEY_FUNC(delete_item, NULL),
1249             ONPLAY_RELOAD_DIR,  &delete_dir_item },
1250     { HOTKEY_INSERT         | HOTKEY_CTX_TREE,
1251             HOTKEY_FUNC(playlist_insert_func, (intptr_t*)PLAYLIST_INSERT),
1252             ONPLAY_START_PLAY,  &i_pl_item },
1253 };
1254
1255 static const int num_hotkey_items = sizeof(hotkey_items) / sizeof(hotkey_items[0]);
1256
1257 /* Return the language ID for the input function */
1258 const char* get_hotkey_desc(int hk_func)
1259 {
1260     int i;
1261     for (i = 0; i < num_hotkey_items; i++)
1262     {
1263         if ((hotkey_items[i].item & HOTKEY_ACTION_MASK) == hk_func)
1264             return P2STR(hotkey_items[i].menu_addr->callback_and_desc->desc);
1265     }
1266
1267     return str(LANG_HOTKEY_NOT_SET);
1268 }
1269
1270 /* Execute the hotkey function, if listed for this screen */
1271 static int execute_hotkey(bool is_wps)
1272 {
1273     int i;
1274     struct hotkey_assignment *this_item;
1275     const int context = is_wps ? HOTKEY_CTX_WPS : HOTKEY_CTX_TREE;
1276     const int this_hotkey = (is_wps ? global_settings.hotkey_wps :
1277         global_settings.hotkey_tree);
1278
1279     /* search assignment struct for a match for the hotkey setting */
1280     for (i = 0; i < num_hotkey_items; i++)
1281     {
1282         this_item = &hotkey_items[i];
1283         if ((this_item->item & context) &&
1284             ((this_item->item & HOTKEY_ACTION_MASK) == this_hotkey))
1285         {
1286             /* run the associated function (with optional param), if any */
1287             const struct menu_func func = this_item->func;
1288             if (func.function != NULL)
1289             {
1290                 if (func.param != NULL)
1291                     (*func.function_w_param)(func.param);
1292                 else
1293                     (*func.function)();
1294             }
1295             /* return with the associated code */
1296             return this_item->return_code;
1297         }
1298     }
1299
1300     /* no valid hotkey set */
1301     splash(HZ, ID2P(LANG_HOTKEY_NOT_SET));
1302     return ONPLAY_RELOAD_DIR;
1303 }
1304
1305 /* Set the hotkey to the current context menu function, if listed */
1306 static void set_hotkey(bool is_wps)
1307 {
1308     int i;
1309     struct hotkey_assignment *this_item;
1310     const int context = is_wps ? HOTKEY_CTX_WPS : HOTKEY_CTX_TREE;
1311     int *hk_func = is_wps ? &global_settings.hotkey_wps :
1312                             &global_settings.hotkey_tree;
1313     int this_hk;
1314     char *this_desc;
1315     bool match_found = false;
1316
1317     /* search assignment struct for a function that matches the current menu item */
1318     for (i = 0; i < num_hotkey_items; i++)
1319     {
1320         this_item = &hotkey_items[i];
1321         if ((this_item->item & context) &&
1322             (this_item->menu_addr == selected_menu_item))
1323         {
1324             this_hk = this_item->item & HOTKEY_ACTION_MASK;
1325             this_desc = P2STR((selected_menu_item->callback_and_desc)->desc);
1326             match_found = true;
1327             break;
1328         }
1329     }
1330
1331     /* ignore the hotkey if no match found or no change to setting */
1332     if (!match_found || (this_hk == *hk_func)) return;
1333
1334     char   line1_buf[100],
1335            line2_buf[100];
1336     char  *line1 = line1_buf,
1337           *line2 = line2_buf;
1338     char **line1_ptr = &line1,
1339          **line2_ptr = &line2;
1340     const struct text_message     message={(const char **)line1_ptr, 1};
1341     const struct text_message yes_message={(const char **)line2_ptr, 1};
1342
1343     snprintf(line1, sizeof(line1_buf), str(LANG_SET_HOTKEY_QUESTION), this_desc);
1344     snprintf(line2, sizeof(line2_buf), str(LANG_HOTKEY_ASSIGNED), this_desc);
1345
1346     /* confirm the hotkey setting change */
1347     if(gui_syncyesno_run(&message, &yes_message, NULL)==YESNO_YES)
1348     {
1349         /* store the hotkey settings */
1350         *hk_func = this_hk;
1351         settings_save();
1352     }
1353 }
1354 #endif /* HOTKEY */
1355
1356 int onplay(char* file, int attr, int from, bool hotkey)
1357 {
1358     const struct menu_item_ex *menu;
1359     onplay_result = ONPLAY_OK;
1360     context = from;
1361     selected_file = file;
1362     selected_file_attr = attr;
1363     int menu_selection;
1364 #ifdef HAVE_HOTKEY
1365     if (hotkey)
1366         return execute_hotkey(context == CONTEXT_WPS);
1367     hotkey_settable_menu = true;
1368 #else
1369     (void)hotkey;
1370 #endif
1371     if (context == CONTEXT_WPS)
1372         menu = &wps_onplay_menu;
1373     else
1374         menu = &tree_onplay_menu;
1375     menu_selection = do_menu(menu, NULL, NULL, false);
1376 #ifdef HAVE_HOTKEY
1377     hotkey_settable_menu = false;
1378     switch (menu_selection)
1379     {
1380         case MENU_SELECTED_HOTKEY:
1381             set_hotkey(context == CONTEXT_WPS);
1382             return ONPLAY_RELOAD_DIR;
1383 #else
1384     switch (menu_selection)
1385     {
1386 #endif
1387         case GO_TO_WPS:
1388             return ONPLAY_START_PLAY;
1389         case GO_TO_ROOT:
1390         case GO_TO_MAINMENU:
1391             return ONPLAY_MAINMENU;
1392         case GO_TO_PLAYLIST_VIEWER:
1393             return ONPLAY_PLAYLIST;
1394         default:
1395             return onplay_result;
1396     }
1397 }