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  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include <errno.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24
  25 #include "debug.h"
  26 #include "sprintf.h"
  27 #include "lcd.h"
  28 #include "dir.h"
  29 #include "file.h"
  30 #include "audio.h"
  31 #include "menu.h"
  32 #include "lang.h"
  33 #include "playlist.h"
  34 #include "button.h"
  35 #include "kernel.h"
  36 #include "keyboard.h"
  37 #include "mp3data.h"
  38 #include "id3.h"
  39 #include "screens.h"
  40 #include "tree.h"
  41 #include "buffer.h"
  42 #include "settings.h"
  43 #include "statusbar.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 #if LCD_DEPTH > 1
  54 #include "backdrop.h"
  55 #endif
  56 #ifdef HAVE_LCD_BITMAP
  57 #include "icons.h"
  58 #endif
  59 #include "main_menu.h"
  60 #include "sound_menu.h"
  61 #if CONFIG_CODEC == SWCODEC
  62 #include "eq_menu.h"
  63 #endif
  64 #include "playlist_menu.h"
  65 #include "playlist_catalog.h"
  66 #ifdef HAVE_TAGCACHE
  67 #include "tagtree.h"
  68 #endif
  69
  70 static int context;
  71 static char* selected_file = NULL;
  72 static int selected_file_attr = 0;
  73 static int onplay_result = ONPLAY_OK;
  74 static char clipboard_selection[MAX_PATH];
  75 static int clipboard_selection_attr = 0;
  76 static bool clipboard_is_copy = false;
  77
  78 /* For playlist options */
  79 struct playlist_args {
  80     int position;
  81     bool queue;
  82 };
  83
  84 /* ----------------------------------------------------------------------- */
  85 /* Displays the bookmark menu options for the user to decide.  This is an  */
  86 /* interface function.                                                     */
  87 /* ----------------------------------------------------------------------- */
  88 static bool bookmark_menu(void)
  89 {
  90     int i,m;
  91     bool result;
  92     struct menu_item items[3];
  93
  94     i=0;
  95
  96     if ((audio_status() & AUDIO_STATUS_PLAY))
  97     {
  98         items[i].desc = ID2P(LANG_BOOKMARK_MENU_CREATE);
  99         items[i].function = bookmark_create_menu;
 100         i++;
 101
 102         if (bookmark_exist())
 103         {
 104             items[i].desc = ID2P(LANG_BOOKMARK_MENU_LIST);
 105             items[i].function = bookmark_load_menu;
 106             i++;
 107         }
 108     }
 109
 110     m=menu_init( items, i, NULL, NULL, NULL, NULL );
 111
 112 #ifdef HAVE_LCD_CHARCELLS
 113     status_set_param(true);
 114 #endif
 115     result = menu_run(m);
 116 #ifdef HAVE_LCD_CHARCELLS
 117     status_set_param(false);
 118 #endif
 119     menu_exit(m);
 120
 121     settings_save();
 122
 123     return result;
 124 }
 125
 126 static bool list_viewers(void)
 127 {
 128     struct menu_item menu[16];
 129     int m, i, result;
 130     int ret = 0;
 131
 132     i=filetype_load_menu(menu,sizeof(menu)/sizeof(*menu));
 133     if (i)
 134     {
 135         m = menu_init( menu, i, NULL, NULL, NULL, NULL );
 136         result = menu_show(m);
 137         menu_exit(m);
 138         if (result >= 0)
 139             ret = filetype_load_plugin((char *)menu[result].desc,selected_file);
 140     }
 141     else
 142     {
 143         /* FIX: translation! */
 144         gui_syncsplash(HZ*2, true, (unsigned char *)"No viewers found");
 145     }
 146
 147     if (ret == PLUGIN_USB_CONNECTED)
 148         onplay_result = ONPLAY_RELOAD_DIR;
 149
 150     return false;
 151 }
 152
 153 static bool shuffle_playlist(void)
 154 {
 155     playlist_sort(NULL, true);
 156     playlist_randomise(NULL, current_tick, true);
 157
 158     return false;
 159 }
 160
 161 static bool save_playlist(void)
 162 {
 163     save_playlist_screen(NULL);
 164     return false;
 165 }
 166
 167 static bool add_to_playlist(int position, bool queue)
 168 {
 169     bool new_playlist = !(audio_status() & AUDIO_STATUS_PLAY);
 170     char *lines[] = {
 171         (char *)str(LANG_RECURSE_DIRECTORY_QUESTION),
 172         selected_file
 173     };
 174     struct text_message message={lines, 2};
 175
 176     gui_syncsplash(0, true, str(LANG_WAIT));
 177
 178     if (new_playlist)
 179         playlist_create(NULL, NULL);
 180
 181     /* always set seed before inserting shuffled */
 182     if (position == PLAYLIST_INSERT_SHUFFLED)
 183         srand(current_tick);
 184
 185 #ifdef HAVE_TAGCACHE
 186     if (context == CONTEXT_ID3DB)
 187     {
 188         tagtree_insert_selection_playlist(position, queue);
 189     }
 190     else
 191 #endif
 192     {
 193         if ((selected_file_attr & TREE_ATTR_MASK) == TREE_ATTR_MPA)
 194             playlist_insert_track(NULL, selected_file, position, queue, true);
 195         else if (selected_file_attr & ATTR_DIRECTORY)
 196         {
 197             bool recurse = false;
 198
 199             if (global_settings.recursive_dir_insert != RECURSE_ASK)
 200                 recurse = (bool)global_settings.recursive_dir_insert;
 201             else
 202             {
 203                 /* Ask if user wants to recurse directory */
 204                 recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES);
 205             }
 206
 207             playlist_insert_directory(NULL, selected_file, position, queue,
 208                                       recurse);
 209         }
 210         else if ((selected_file_attr & TREE_ATTR_MASK) == TREE_ATTR_M3U)
 211             playlist_insert_playlist(NULL, selected_file, position, queue);
 212     }
 213
 214     if (new_playlist && (playlist_amount() > 0))
 215     {
 216         /* nothing is currently playing so begin playing what we just
 217            inserted */
 218         if (global_settings.playlist_shuffle)
 219             playlist_shuffle(current_tick, -1);
 220         playlist_start(0,0);
 221         gui_syncstatusbar_draw(&statusbars, false);
 222         onplay_result = ONPLAY_START_PLAY;
 223     }
 224
 225     return false;
 226 }
 227
 228 static bool view_playlist(void)
 229 {
 230     bool was_playing = audio_status() & AUDIO_STATUS_PLAY;
 231     bool result;
 232
 233     result = playlist_viewer_ex(selected_file);
 234
 235     if (!was_playing && (audio_status() & AUDIO_STATUS_PLAY) &&
 236         onplay_result == ONPLAY_OK)
 237         /* playlist was started from viewer */
 238         onplay_result = ONPLAY_START_PLAY;
 239
 240     return result;
 241 }
 242
 243 static bool cat_add_to_a_playlist(void)
 244 {
 245     return catalog_add_to_a_playlist(selected_file, selected_file_attr,
 246         false);
 247 }
 248
 249 static bool cat_add_to_a_new_playlist(void)
 250 {
 251     return catalog_add_to_a_playlist(selected_file, selected_file_attr, true);
 252 }
 253
 254 static bool cat_playlist_options(void)
 255 {
 256     struct menu_item items[3];
 257     int m, i=0, result;
 258     bool ret = false;
 259
 260     if ((audio_status() & AUDIO_STATUS_PLAY && context == CONTEXT_WPS) ||
 261         context == CONTEXT_TREE)
 262     {
 263         if (context == CONTEXT_WPS)
 264         {
 265             items[i].desc = ID2P(LANG_CATALOG_VIEW);
 266             items[i].function = catalog_view_playlists;
 267             i++;
 268         }
 269
 270         items[i].desc = ID2P(LANG_CATALOG_ADD_TO);
 271         items[i].function = cat_add_to_a_playlist;
 272         i++;
 273         items[i].desc = ID2P(LANG_CATALOG_ADD_TO_NEW);
 274         items[i].function = cat_add_to_a_new_playlist;
 275         i++;
 276     }
 277
 278     m = menu_init( items, i, NULL, NULL, NULL, NULL );
 279     result = menu_show(m);
 280     if(result >= 0)
 281         ret = items[result].function();
 282     menu_exit(m);
 283
 284     return ret;
 285 }
 286
 287 /* Sub-menu for playlist options */
 288 static bool playlist_options(void)
 289 {
 290     struct menu_item items[13];
 291     struct playlist_args args[13]; /* increase these 2 if you add entries! */
 292     int m, i=0, pstart=0, result;
 293     bool ret = false;
 294
 295     if ((selected_file_attr & TREE_ATTR_MASK) == TREE_ATTR_M3U &&
 296         context == CONTEXT_TREE)
 297     {
 298         items[i].desc = ID2P(LANG_VIEW);
 299         items[i].function = view_playlist;
 300         i++;
 301         pstart++;
 302     }
 303
 304     if (audio_status() & AUDIO_STATUS_PLAY &&
 305         context == CONTEXT_WPS)
 306     {
 307         items[i].desc = ID2P(LANG_VIEW_DYNAMIC_PLAYLIST);
 308         items[i].function = playlist_viewer;
 309         i++;
 310         pstart++;
 311
 312         items[i].desc = ID2P(LANG_SEARCH_IN_PLAYLIST);
 313         items[i].function = search_playlist;
 314         i++;
 315         pstart++;
 316
 317         items[i].desc = ID2P(LANG_SAVE_DYNAMIC_PLAYLIST);
 318         items[i].function = save_playlist;
 319         i++;
 320         pstart++;
 321
 322         items[i].desc = ID2P(LANG_SHUFFLE_PLAYLIST);
 323         items[i].function = shuffle_playlist;
 324         i++;
 325         pstart++;
 326     }
 327
 328     if (context == CONTEXT_TREE || context == CONTEXT_ID3DB)
 329     {
 330         if (audio_status() & AUDIO_STATUS_PLAY)
 331         {
 332             items[i].desc = ID2P(LANG_INSERT);
 333             args[i].position = PLAYLIST_INSERT;
 334             args[i].queue = false;
 335             i++;
 336
 337             items[i].desc = ID2P(LANG_INSERT_FIRST);
 338             args[i].position = PLAYLIST_INSERT_FIRST;
 339             args[i].queue = false;
 340             i++;
 341
 342             items[i].desc = ID2P(LANG_INSERT_LAST);
 343             args[i].position = PLAYLIST_INSERT_LAST;
 344             args[i].queue = false;
 345             i++;
 346
 347             items[i].desc = ID2P(LANG_INSERT_SHUFFLED);
 348             args[i].position = PLAYLIST_INSERT_SHUFFLED;
 349             args[i].queue = false;
 350             i++;
 351
 352             items[i].desc = ID2P(LANG_QUEUE);
 353             args[i].position = PLAYLIST_INSERT;
 354             args[i].queue = true;
 355             i++;
 356
 357             items[i].desc = ID2P(LANG_QUEUE_FIRST);
 358             args[i].position = PLAYLIST_INSERT_FIRST;
 359             args[i].queue = true;
 360             i++;
 361
 362             items[i].desc = ID2P(LANG_QUEUE_LAST);
 363             args[i].position = PLAYLIST_INSERT_LAST;
 364             args[i].queue = true;
 365             i++;
 366
 367             items[i].desc = ID2P(LANG_QUEUE_SHUFFLED);
 368             args[i].position = PLAYLIST_INSERT_SHUFFLED;
 369             args[i].queue = true;
 370             i++;
 371
 372             items[i].desc = ID2P(LANG_REPLACE);
 373             args[i].position = PLAYLIST_REPLACE;
 374             args[i].queue = false;
 375             i++;
 376         }
 377         else if (((selected_file_attr & TREE_ATTR_MASK) == TREE_ATTR_MPA) ||
 378                  (selected_file_attr & ATTR_DIRECTORY))
 379         {
 380             items[i].desc = ID2P(LANG_INSERT);
 381             args[i].position = PLAYLIST_INSERT_LAST;
 382             args[i].queue = false;
 383             i++;
 384
 385             if (selected_file_attr & ATTR_DIRECTORY)
 386             {
 387                 items[i].desc = ID2P(LANG_INSERT_SHUFFLED);
 388                 args[i].position = PLAYLIST_INSERT_SHUFFLED;
 389                 args[i].queue = false;
 390                 i++;
 391             }
 392         }
 393     }
 394
 395     m = menu_init( items, i, NULL, NULL, NULL, NULL );
 396     result = menu_show(m);
 397     if (result >= 0 && result < pstart)
 398         ret = items[result].function();
 399     else if (result >= pstart)
 400         ret = add_to_playlist(args[result].position, args[result].queue);
 401     menu_exit(m);
 402
 403     return ret;
 404 }
 405
 406
 407 /* helper function to remove a non-empty directory */
 408 static int remove_dir(char* dirname, int len)
 409 {
 410     int result = 0;
 411     DIR* dir;
 412     int dirlen = strlen(dirname);
 413     int i;
 414
 415     dir = opendir(dirname);
 416     if (!dir)
 417         return -1; /* open error */
 418
 419     while(true)
 420     {
 421         struct dirent* entry;
 422         /* walk through the directory content */
 423         entry = readdir(dir);
 424         if (!entry)
 425             break;
 426
 427         dirname[dirlen] ='\0';
 428         FOR_NB_SCREENS(i)
 429             screens[i].puts(0,1,dirname);
 430
 431         /* append name to current directory */
 432         snprintf(dirname+dirlen, len-dirlen, "/%s", entry->d_name);
 433         if (entry->attribute & ATTR_DIRECTORY)
 434         {   /* remove a subdirectory */
 435             if (!strcmp((char *)entry->d_name, ".") ||
 436                 !strcmp((char *)entry->d_name, ".."))
 437                 continue; /* skip these */
 438
 439             /* inform the user which dir we're deleting */
 440
 441             result = remove_dir(dirname, len); /* recursion */
 442             if (result)
 443                 break; /* or better continue, delete what we can? */
 444         }
 445         else
 446         {   /* remove a file */
 447             FOR_NB_SCREENS(i)
 448                 screens[i].puts_scroll(0,2,entry->d_name);
 449             result = remove(dirname);
 450         }
 451 #ifdef HAVE_LCD_BITMAP
 452         FOR_NB_SCREENS(i)
 453             screens[i].update();
 454 #endif
 455         if(ACTION_STD_CANCEL == get_action(CONTEXT_STD,TIMEOUT_NOBLOCK))
 456         {
 457             gui_syncsplash(HZ, true, str(LANG_MENU_SETTING_CANCEL));
 458             result = -1;
 459             break;
 460         }
 461     }
 462     closedir(dir);
 463
 464     if (!result)
 465     {   /* remove the now empty directory */
 466         dirname[dirlen] = '\0'; /* terminate to original length */
 467
 468         result = rmdir(dirname);
 469     }
 470
 471     return result;
 472 }
 473
 474
 475 /* share code for file and directory deletion, saves space */
 476 static bool delete_handler(bool is_dir)
 477 {
 478     char *lines[]={
 479         (char *)str(LANG_REALLY_DELETE),
 480         selected_file
 481     };
 482     char *yes_lines[]={
 483         (char *)str(LANG_DELETED),
 484         selected_file
 485     };
 486
 487     struct text_message message={lines, 2};
 488     struct text_message yes_message={yes_lines, 2};
 489     if(gui_syncyesno_run(&message, &yes_message, NULL)!=YESNO_YES)
 490         return false;
 491     int res;
 492     if (is_dir)
 493     {
 494         char pathname[MAX_PATH]; /* space to go deep */
 495         cpu_boost(true);
 496         strncpy(pathname, selected_file, sizeof pathname);
 497         res = remove_dir(pathname, sizeof(pathname));
 498         cpu_boost(false);
 499     }
 500     else
 501         res = remove(selected_file);
 502
 503     if (!res) {
 504         onplay_result = ONPLAY_RELOAD_DIR;
 505     }
 506     return false;
 507 }
 508
 509
 510 static bool delete_file(void)
 511 {
 512     return delete_handler(false);
 513 }
 514
 515 static bool delete_dir(void)
 516 {
 517     return delete_handler(true);
 518 }
 519
 520 #if LCD_DEPTH > 1
 521 static bool set_backdrop(void)
 522 {
 523     /* load the image */
 524     if(load_main_backdrop(selected_file)) {
 525         gui_syncsplash(HZ, true, str(LANG_BACKDROP_LOADED));
 526         set_file(selected_file, (char *)global_settings.backdrop_file, MAX_FILENAME);
 527         show_main_backdrop();
 528         return true;
 529     } else {
 530         gui_syncsplash(HZ, true, str(LANG_BACKDROP_FAILED));
 531         return false;
 532     }
 533 }
 534 #endif
 535
 536 static bool rename_file(void)
 537 {
 538     char newname[MAX_PATH];
 539     char* ptr = strrchr(selected_file, '/') + 1;
 540     int pathlen = (ptr - selected_file);
 541     strncpy(newname, selected_file, sizeof newname);
 542     if (!kbd_input(newname + pathlen, (sizeof newname)-pathlen)) {
 543         if (!strlen(newname + pathlen) ||
 544             (rename(selected_file, newname) < 0)) {
 545             lcd_clear_display();
 546             lcd_puts(0,0,str(LANG_RENAME));
 547             lcd_puts(0,1,str(LANG_FAILED));
 548             lcd_update();
 549             sleep(HZ*2);
 550         }
 551         else
 552             onplay_result = ONPLAY_RELOAD_DIR;
 553     }
 554
 555     return false;
 556 }
 557
 558 static bool create_dir(void)
 559 {
 560     char dirname[MAX_PATH];
 561     char *cwd;
 562     int rc;
 563     int pathlen;
 564
 565     cwd = getcwd(NULL, 0);
 566     memset(dirname, 0, sizeof dirname);
 567
 568     snprintf(dirname, sizeof dirname, "%s/",
 569              cwd[1] ? cwd : "");
 570
 571     pathlen = strlen(dirname);
 572     rc = kbd_input(dirname + pathlen, (sizeof dirname)-pathlen);
 573     if (rc < 0)
 574         return false;
 575
 576     rc = mkdir(dirname, 0);
 577     if (rc < 0) {
 578         gui_syncsplash(HZ, true, (unsigned char *)"%s %s",
 579                        str(LANG_CREATE_DIR), str(LANG_FAILED));
 580     } else {
 581         onplay_result = ONPLAY_RELOAD_DIR;
 582     }
 583
 584     return true;
 585 }
 586
 587 static bool properties(void)
 588 {
 589     if(PLUGIN_USB_CONNECTED == filetype_load_plugin("properties",
 590                                                     selected_file))
 591         onplay_result = ONPLAY_RELOAD_DIR;
 592     return false;
 593 }
 594
 595 /* Store the current selection in the clipboard */
 596 static bool clipboard_clip(bool copy)
 597 {
 598     clipboard_selection[0] = 0;
 599     strncpy(clipboard_selection, selected_file, MAX_PATH);
 600     clipboard_selection_attr = selected_file_attr;
 601     clipboard_is_copy = copy;
 602
 603     return true;
 604 }
 605
 606 static bool clipboard_cut(void)
 607 {
 608     return clipboard_clip(false);
 609 }
 610
 611 static bool clipboard_copy(void)
 612 {
 613     return clipboard_clip(true);
 614 }
 615
 616 /* Paste a file to a new directory. Will overwrite always. */
 617 static bool clipboard_pastefile(const char *src, const char *target, bool copy)
 618 {
 619     int src_fd, target_fd, buffersize, size, bytesread, byteswritten;
 620     char *buffer;
 621     bool result = false;
 622
 623     if (copy) {
 624         /* See if we can get the plugin buffer for the file copy buffer */
 625         buffer = (char *) plugin_get_buffer(&buffersize);
 626         if (buffer == NULL || buffersize < 512) {
 627             /* Not large enough, try for a disk sector worth of stack instead */
 628             buffersize = 512;
 629             buffer = (char *) __builtin_alloca(buffersize);
 630         }
 631
 632         if (buffer == NULL) {
 633             return false;
 634         }
 635
 636         buffersize &= ~0x1ff;  /* Round buffer size to multiple of sector size */
 637
 638         src_fd = open(src, O_RDONLY);
 639
 640         if (src_fd >= 0) {
 641             target_fd = creat(target, O_WRONLY);
 642
 643             if (target_fd >= 0) {
 644                 result = true;
 645
 646                 size = filesize(src_fd);
 647
 648                 if (size == -1) {
 649                     result = false;
 650                 }
 651
 652                 while(size > 0) {
 653                     bytesread = read(src_fd, buffer, buffersize);
 654
 655                     if (bytesread == -1) {
 656                         result = false;
 657                         break;
 658                     }
 659
 660                     size -= bytesread;
 661
 662                     while(bytesread > 0) {
 663                         byteswritten = write(target_fd, buffer, bytesread);
 664
 665                         if (byteswritten == -1) {
 666                             result = false;
 667                             size = 0;
 668                             break;
 669                         }
 670
 671                         bytesread -= byteswritten;
 672                     }
 673                 }
 674
 675                 close(target_fd);
 676
 677                 /* Copy failed. Cleanup. */
 678                 if (!result) {
 679                     remove(target);
 680                 }
 681             }
 682
 683             close(src_fd);
 684         }
 685     } else {
 686         result = rename(src, target) == 0;
 687 #ifdef HAVE_MULTIVOLUME
 688         if (!result) {
 689             if (errno == EXDEV) {
 690                 /* Failed because cross volume rename doesn't work. Copy instead */
 691                 result = clipboard_pastefile(src, target, true);
 692
 693                 if (result) {
 694                     result = remove(src);
 695                 }
 696             }
 697         }
 698 #endif
 699     }
 700
 701     return result;
 702 }
 703
 704 /* Paste a directory to a new location. Designed to be called by clipboard_paste */
 705 static bool clipboard_pastedirectory(char *src, int srclen, char *target, int targetlen, bool copy)
 706 {
 707     DIR *srcdir;
 708     int srcdirlen = strlen(src);
 709     int targetdirlen = strlen(target);
 710     int fd;
 711     bool result = true;
 712
 713     /* Check if the target exists */
 714     fd = open(target, O_RDONLY);
 715     close(fd);
 716
 717     if (fd < 0) {
 718         if (!copy) {
 719             /* Just move the directory */
 720             result = rename(src, target) == 0;
 721
 722 #ifdef HAVE_MULTIVOLUME
 723             if (!result && errno == EXDEV) {
 724                 /* Try a copy as we're going across devices */
 725                 result = clipboard_pastedirectory(src, srclen, target, targetlen, true);
 726
 727                 /* If it worked, remove the source directory */
 728                 if (result) {
 729                     remove_dir(src, srclen);
 730                 }
 731             }
 732 #endif
 733             return result;
 734         } else {
 735             /* Make a directory to copy things to */
 736             result = mkdir(target, 0) == 0;
 737         }
 738     }
 739
 740     /* Check if something went wrong already */
 741     if (!result) {
 742         return result;
 743     }
 744
 745     srcdir = opendir(src);
 746     if (!srcdir) {
 747         return false;
 748     }
 749
 750     /* This loop will exit as soon as there's a problem */
 751     while(result)
 752     {
 753         struct dirent* entry;
 754         /* walk through the directory content */
 755         entry = readdir(srcdir);
 756         if (!entry)
 757             break;
 758
 759         /* append name to current directory */
 760         snprintf(src+srcdirlen, srclen-srcdirlen, "/%s", entry->d_name);
 761         snprintf(target+targetdirlen, targetlen-targetdirlen, "/%s", entry->d_name);
 762
 763         DEBUGF("Copy %s to %s\n", src, target);
 764
 765         if (entry->attribute & ATTR_DIRECTORY)
 766         {   /* copy/move a subdirectory */
 767             if (!strcmp((char *)entry->d_name, ".") ||
 768                 !strcmp((char *)entry->d_name, ".."))
 769                 continue; /* skip these */
 770
 771             result = clipboard_pastedirectory(src, srclen, target, targetlen, copy); /* recursion */
 772         }
 773         else
 774         {   /* copy/move a file */
 775             result = clipboard_pastefile(src, target, copy);
 776         }
 777     }
 778
 779     closedir(srcdir);
 780
 781     if (result) {
 782         src[srcdirlen] = '\0'; /* terminate to original length */
 783         target[targetdirlen] = '\0'; /* terminate to original length */
 784     }
 785
 786     return result;
 787 }
 788
 789 /* Paste the clipboard to the current directory */
 790 static bool clipboard_paste(void)
 791 {
 792     char target[MAX_PATH];
 793     char *cwd, *nameptr;
 794     bool success;
 795     int target_fd;
 796
 797     unsigned char *lines[]={str(LANG_REALLY_OVERWRITE)};
 798     struct text_message message={(char **)lines, 1};
 799
 800     /* Get the name of the current directory */
 801     cwd = getcwd(NULL, 0);
 802     snprintf(target, sizeof target, "%s", cwd[1] ? cwd : "");
 803
 804     /* Figure out the name of the selection */
 805     nameptr = strrchr(clipboard_selection, '/');
 806
 807     /* Paste the name on to the current directory to give us our final target */
 808     strcat(target, nameptr);
 809
 810     /* Check if we're going to overwrite */
 811     target_fd = open(target, O_RDONLY);
 812     close(target_fd);
 813
 814     /* If the target existed but they choose not to overwite, exit */
 815     if (target_fd >= 0 &&
 816         (gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)) {
 817         return false;
 818     }
 819
 820     /* Now figure out what we're doing */
 821     if (clipboard_selection_attr & ATTR_DIRECTORY) {
 822         /* Recursion. Set up external stack */
 823         char srcpath[MAX_PATH];
 824         char targetpath[MAX_PATH];
 825
 826         strncpy(srcpath, clipboard_selection, sizeof srcpath);
 827         strncpy(targetpath, target, sizeof targetpath);
 828
 829         success = clipboard_pastedirectory(srcpath, sizeof(srcpath), target, sizeof(targetpath), clipboard_is_copy);
 830     } else {
 831         success = clipboard_pastefile(clipboard_selection, target, clipboard_is_copy);
 832     }
 833
 834     /* Did it work? */
 835     if (success) {
 836         /* Reset everything */
 837         clipboard_selection[0] = 0;
 838         clipboard_selection_attr = 0;
 839         clipboard_is_copy = false;
 840
 841         /* Force reload of the current directory */
 842         onplay_result = ONPLAY_RELOAD_DIR;
 843     } else {
 844         gui_syncsplash(HZ, true, (unsigned char *)"%s %s",
 845                str(LANG_PASTE), str(LANG_FAILED));
 846     }
 847
 848     return true;
 849 }
 850
 851 static bool exit_to_main;
 852
 853 /* catch MENU_EXIT_MENU within context menu to call the main menu afterwards */
 854 static int onplay_callback(int key, int menu)
 855 {
 856     (void)menu;
 857
 858     if (key == ACTION_STD_MENU)
 859         exit_to_main = true;
 860
 861     return key;
 862 }
 863
 864 int onplay(char* file, int attr, int from)
 865 {
 866 #if CONFIG_CODEC == SWCODEC
 867     struct menu_item items[14]; /* increase this if you add entries! */
 868 #else
 869     struct menu_item items[12];
 870 #endif
 871     int m, i=0, result;
 872 #if LCD_DEPTH > 1
 873     char *suffix;
 874 #endif
 875
 876     onplay_result = ONPLAY_OK;
 877     context=from;
 878     exit_to_main = false;
 879     selected_file = file;
 880     selected_file_attr = attr;
 881
 882     if (context == CONTEXT_WPS)
 883     {
 884         items[i].desc = ID2P(LANG_SOUND_SETTINGS);
 885         items[i].function = sound_menu;
 886         i++;
 887     }
 888
 889     if (context == CONTEXT_WPS ||
 890         context == CONTEXT_TREE ||
 891         context == CONTEXT_ID3DB)
 892     {
 893         items[i].desc = ID2P(LANG_PLAYLIST);
 894         items[i].function = playlist_options;
 895         i++;
 896         items[i].desc = ID2P(LANG_CATALOG);
 897         items[i].function = cat_playlist_options;
 898         i++;
 899     }
 900
 901     if (context == CONTEXT_WPS)
 902     {
 903         items[i].desc = ID2P(LANG_BOOKMARK_MENU);
 904         items[i].function = bookmark_menu;
 905         i++;
 906     }
 907
 908     if (file)
 909     {
 910         if (context == CONTEXT_WPS)
 911         {
 912             items[i].desc = ID2P(LANG_MENU_SHOW_ID3_INFO);
 913             items[i].function = browse_id3;
 914             i++;
 915 /*            if(rundb_initialized)
 916             {
 917                 items[i].desc = ID2P(LANG_MENU_SET_RATING);
 918                 items[i].function = set_rating;
 919                 i++;
 920             }*/
 921         }
 922
 923 #ifdef HAVE_MULTIVOLUME
 924         if (!(attr & ATTR_VOLUME)) /* no rename+delete for volumes */
 925 #endif
 926         {
 927             if (context == CONTEXT_TREE)
 928             {
 929                 items[i].desc = ID2P(LANG_RENAME);
 930                 items[i].function = rename_file;
 931                 i++;
 932
 933                 items[i].desc = ID2P(LANG_CUT);
 934                 items[i].function = clipboard_cut;
 935                 i++;
 936
 937                 items[i].desc = ID2P(LANG_COPY);
 938                 items[i].function = clipboard_copy;
 939                 i++;
 940
 941                 if (clipboard_selection[0] != 0) /* Something in the clipboard? */
 942                 {
 943                     items[i].desc = ID2P(LANG_PASTE);
 944                     items[i].function = clipboard_paste;
 945                     i++;
 946                 }
 947             }
 948
 949             if (!(attr & ATTR_DIRECTORY) && context == CONTEXT_TREE)
 950             {
 951                 items[i].desc = ID2P(LANG_DELETE);
 952                 items[i].function = delete_file;
 953                 i++;
 954
 955 #if LCD_DEPTH > 1
 956                 suffix = strrchr(file, '.');
 957                 if (suffix)
 958                 {
 959                     if (strcasecmp(suffix, ".bmp") == 0)
 960                     {
 961                         items[i].desc = ID2P(LANG_SET_AS_BACKDROP);
 962                         items[i].function = set_backdrop;
 963                         i++;
 964                     }
 965                 }
 966 #endif
 967             }
 968             else
 969             {
 970                 if (context == CONTEXT_TREE)
 971                 {
 972                     items[i].desc = ID2P(LANG_DELETE_DIR);
 973                     items[i].function = delete_dir;
 974                     i++;
 975                 }
 976             }
 977         }
 978
 979         if (!(attr & ATTR_DIRECTORY))
 980         {
 981             items[i].desc = ID2P(LANG_ONPLAY_OPEN_WITH);
 982             items[i].function = list_viewers;
 983             i++;
 984         }
 985     }
 986     else
 987     {
 988         if (strlen(clipboard_selection) != 0)
 989         {
 990             items[i].desc = ID2P(LANG_PASTE);
 991             items[i].function = clipboard_paste;
 992             i++;
 993         }
 994     }
 995
 996     if (context == CONTEXT_TREE)
 997     {
 998         items[i].desc = ID2P(LANG_CREATE_DIR);
 999         items[i].function = create_dir;
1000         i++;
1001
1002         items[i].desc = ID2P(LANG_PROPERTIES);
1003         items[i].function = properties;
1004         i++;
1005     }
1006
1007     if (context == CONTEXT_WPS)
1008     {
1009 #ifdef HAVE_PITCHSCREEN
1010         /* Pitch screen access */
1011         items[i].desc = ID2P(LANG_PITCH);
1012         items[i].function = pitch_screen;
1013         i++;
1014 #endif
1015 #if CONFIG_CODEC == SWCODEC
1016         /* Equalizer menu items */
1017         items[i].desc = ID2P(LANG_EQUALIZER_GRAPHICAL);
1018         items[i].function = eq_menu_graphical;
1019         i++;
1020         items[i].desc = ID2P(LANG_EQUALIZER_BROWSE);
1021         items[i].function = eq_browse_presets;
1022         i++;
1023 #endif
1024     }
1025
1026     /* DIY menu handling, since we want to exit after selection */
1027     if (i)
1028     {
1029         m = menu_init( items, i, onplay_callback, NULL, NULL, NULL );
1030         result = menu_show(m);
1031         if (result >= 0)
1032             items[result].function();
1033         menu_exit(m);
1034
1035         if (exit_to_main)
1036             result = main_menu();
1037
1038 #ifdef HAVE_LCD_BITMAP
1039         if (global_settings.statusbar)
1040             lcd_setmargins(0, STATUSBAR_HEIGHT);
1041         else
1042             lcd_setmargins(0, 0);
1043 #endif
1044     }
1045
1046     return onplay_result;
1047 }