Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/onplay.c
Nils Wallménius 01729e7a18 FS#9281 Rename of splash functions. 
* Remove gui_splash()
* Rename gui_syncsplash() to splashf() and remove its voice 
capabilities.
* Rename the internal splash() to splash_internal() and introduce an 
externally visible splash() that handles simple splashing  without 
printf functionality e.g. splash(HZ, ID2P(LANG_FOO)); or splash(HZ, 
"foo"); if a LANG_* id is passed it will be voiced.
* Adjust all places that called gui_syncsplash() to use the correct 
variant from above.
* Export both new functions to plugins and adjust places calling 
rb->splash() to use the correct variant so that we now have naming 
consistency between the core and plugins.
* Fix one latent bug that would cause my sim to crash with the above 
changes and correct P2STR and P2ID macros, thanks to pondlife.


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18282 a1c6a512-1295-4272-9138-f99709370657
2008-08-15 08:27:39 +00:00

1202 lines
37 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Björn Stenberg
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include "debug.h"
#include "sprintf.h"
#include "lcd.h"
#include "dir.h"
#include "file.h"
#include "audio.h"
#include "menu.h"
#include "lang.h"
#include "playlist.h"
#include "button.h"
#include "kernel.h"
#include "keyboard.h"
#include "mp3data.h"
#include "id3.h"
#include "screens.h"
#include "tree.h"
#include "buffer.h"
#include "settings.h"
#include "statusbar.h"
#include "playlist_viewer.h"
#include "talk.h"
#include "onplay.h"
#include "filetypes.h"
#include "plugin.h"
#include "bookmark.h"
#include "action.h"
#include "splash.h"
#include "yesno.h"
#include "menus/exported_menus.h"
#ifdef HAVE_LCD_BITMAP
#include "icons.h"
#endif
#include "sound_menu.h"
#include "playlist_menu.h"
#include "playlist_catalog.h"
#ifdef HAVE_TAGCACHE
#include "tagtree.h"
#endif
#include "cuesheet.h"
#include "backdrop.h"
static int context;
static char* selected_file = NULL;
static int selected_file_attr = 0;
static int onplay_result = ONPLAY_OK;
static char clipboard_selection[MAX_PATH];
static int clipboard_selection_attr = 0;
static bool clipboard_is_copy = false;
/* redefine MAKE_MENU so the MENU_EXITAFTERTHISMENU flag can be added easily */
#define MAKE_ONPLAYMENU( name, str, callback, icon, ... ) \
static const struct menu_item_ex *name##_[] = {__VA_ARGS__}; \
static const struct menu_callback_with_desc name##__ = {callback,str,icon};\
static const struct menu_item_ex name = \
{MT_MENU|MENU_HAS_DESC|MENU_EXITAFTERTHISMENU| \
MENU_ITEM_COUNT(sizeof( name##_)/sizeof(*name##_)), \
{ (void*)name##_},{.callback_and_desc = & name##__}};
#ifdef HAVE_LCD_BITMAP
static void draw_slider(void);
#else
#define draw_slider()
#endif
/* ----------------------------------------------------------------------- */
/* Displays the bookmark menu options for the user to decide. This is an */
/* interface function. */
/* ----------------------------------------------------------------------- */
static int bookmark_menu_callback(int action,
const struct menu_item_ex *this_item);
MENUITEM_FUNCTION(bookmark_create_menu_item, 0,
ID2P(LANG_BOOKMARK_MENU_CREATE),
bookmark_create_menu, NULL, NULL, Icon_Bookmark);
MENUITEM_FUNCTION(bookmark_load_menu_item, 0,
ID2P(LANG_BOOKMARK_MENU_LIST),
bookmark_load_menu, NULL,
bookmark_menu_callback, Icon_Bookmark);
MAKE_ONPLAYMENU(bookmark_menu, ID2P(LANG_BOOKMARK_MENU), bookmark_menu_callback,
Icon_Bookmark, &bookmark_create_menu_item,
&bookmark_load_menu_item);
static int bookmark_menu_callback(int action,
const struct menu_item_ex *this_item)
{
(void)this_item;
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (this_item == &bookmark_load_menu_item)
{
if (bookmark_exist() == 0)
return ACTION_EXIT_MENUITEM;
}
/* hide the bookmark menu if there is no playback */
else if ((audio_status() & AUDIO_STATUS_PLAY) == 0)
return ACTION_EXIT_MENUITEM;
break;
#ifdef HAVE_LCD_CHARCELLS
case ACTION_ENTER_MENUITEM:
status_set_param(true);
break;
#endif
case ACTION_EXIT_MENUITEM:
#ifdef HAVE_LCD_CHARCELLS
status_set_param(false);
#endif
settings_save();
break;
}
return action;
}
static bool list_viewers(void)
{
int ret = filetype_list_viewers(selected_file);
if (ret == PLUGIN_USB_CONNECTED)
onplay_result = ONPLAY_RELOAD_DIR;
return false;
}
static bool shuffle_playlist(void)
{
playlist_sort(NULL, true);
playlist_randomise(NULL, current_tick, true);
return false;
}
static bool save_playlist(void)
{
save_playlist_screen(NULL);
return false;
}
static bool add_to_playlist(int position, bool queue)
{
bool new_playlist = !(audio_status() & AUDIO_STATUS_PLAY);
const char *lines[] = {
ID2P(LANG_RECURSE_DIRECTORY_QUESTION),
selected_file
};
const struct text_message message={lines, 2};
splash(0, ID2P(LANG_WAIT));
if (new_playlist)
playlist_create(NULL, NULL);
/* always set seed before inserting shuffled */
if (position == PLAYLIST_INSERT_SHUFFLED)
srand(current_tick);
#ifdef HAVE_TAGCACHE
if (context == CONTEXT_ID3DB)
{
tagtree_insert_selection_playlist(position, queue);
}
else
#endif
{
if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
playlist_insert_track(NULL, selected_file, position, queue, true);
else if (selected_file_attr & ATTR_DIRECTORY)
{
bool recurse = false;
if (global_settings.recursive_dir_insert != RECURSE_ASK)
recurse = (bool)global_settings.recursive_dir_insert;
else
{
/* Ask if user wants to recurse directory */
recurse = (gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES);
}
playlist_insert_directory(NULL, selected_file, position, queue,
recurse);
}
else if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)
playlist_insert_playlist(NULL, selected_file, position, queue);
}
if (new_playlist && (playlist_amount() > 0))
{
/* nothing is currently playing so begin playing what we just
inserted */
if (global_settings.playlist_shuffle)
playlist_shuffle(current_tick, -1);
playlist_start(0,0);
gui_syncstatusbar_draw(&statusbars, false);
onplay_result = ONPLAY_START_PLAY;
}
return false;
}
static bool view_playlist(void)
{
bool was_playing = audio_status() & AUDIO_STATUS_PLAY;
bool result;
result = playlist_viewer_ex(selected_file);
if (!was_playing && (audio_status() & AUDIO_STATUS_PLAY) &&
onplay_result == ONPLAY_OK)
/* playlist was started from viewer */
onplay_result = ONPLAY_START_PLAY;
return result;
}
static bool cat_add_to_a_playlist(void)
{
return catalog_add_to_a_playlist(selected_file, selected_file_attr,
false, NULL);
}
static bool cat_add_to_a_new_playlist(void)
{
return catalog_add_to_a_playlist(selected_file, selected_file_attr,
true, NULL);
}
static int cat_playlist_callback(int action,
const struct menu_item_ex *this_item);
MENUITEM_FUNCTION(cat_view_lists, 0, ID2P(LANG_CATALOG_VIEW),
catalog_view_playlists, 0, cat_playlist_callback,
Icon_Playlist);
MENUITEM_FUNCTION(cat_add_to_list, 0, ID2P(LANG_CATALOG_ADD_TO),
cat_add_to_a_playlist, 0, NULL, Icon_Playlist);
MENUITEM_FUNCTION(cat_add_to_new, 0, ID2P(LANG_CATALOG_ADD_TO_NEW),
cat_add_to_a_new_playlist, 0, NULL, Icon_Playlist);
MAKE_ONPLAYMENU(cat_playlist_menu, ID2P(LANG_CATALOG), cat_playlist_callback,
Icon_Playlist, &cat_view_lists, &cat_add_to_list,
&cat_add_to_new);
static int cat_playlist_callback(int action,
const struct menu_item_ex *this_item)
{
if (((selected_file_attr & FILE_ATTR_MASK) != FILE_ATTR_AUDIO) &&
((selected_file_attr & FILE_ATTR_MASK) != FILE_ATTR_M3U) &&
((selected_file_attr & ATTR_DIRECTORY) == 0))
{
return ACTION_EXIT_MENUITEM;
}
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (this_item == &cat_view_lists)
{
if (context == CONTEXT_WPS)
return action;
}
else if (selected_file && /* set before calling this menu,
so safe */
((audio_status() & AUDIO_STATUS_PLAY &&
context == CONTEXT_WPS) ||
context == CONTEXT_TREE))
{
return action;
}
else
return ACTION_EXIT_MENUITEM;
break;
}
return action;
}
/* CONTEXT_WPS playlist options */
MENUITEM_FUNCTION(playlist_viewer_item, 0,
ID2P(LANG_VIEW_DYNAMIC_PLAYLIST), playlist_viewer,
NULL, NULL, Icon_Playlist);
MENUITEM_FUNCTION(search_playlist_item, 0,
ID2P(LANG_SEARCH_IN_PLAYLIST), search_playlist,
NULL, NULL, Icon_Playlist);
MENUITEM_FUNCTION(playlist_save_item, 0, ID2P(LANG_SAVE_DYNAMIC_PLAYLIST),
save_playlist, NULL, NULL, Icon_Playlist);
MENUITEM_FUNCTION(reshuffle_item, 0, ID2P(LANG_SHUFFLE_PLAYLIST),
shuffle_playlist, NULL, NULL, Icon_Playlist);
MAKE_ONPLAYMENU( wps_playlist_menu, ID2P(LANG_PLAYLIST),
NULL, Icon_Playlist,
&playlist_viewer_item, &search_playlist_item,
&playlist_save_item, &reshuffle_item
);
/* CONTEXT_[TREE|ID3DB] playlist options */
static int playlist_insert_func(void *param)
{
add_to_playlist((intptr_t)param, false);
return 0;
}
static int playlist_queue_func(void *param)
{
add_to_playlist((intptr_t)param, true);
return 0;
}
static int treeplaylist_wplayback_callback(int action,
const struct menu_item_ex*
this_item)
{
(void)this_item;
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (audio_status() & AUDIO_STATUS_PLAY)
return action;
else
return ACTION_EXIT_MENUITEM;
break;
}
return action;
}
static int treeplaylist_callback(int action,
const struct menu_item_ex *this_item);
/* insert items */
MENUITEM_FUNCTION(i_pl_item_no_play, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT),
playlist_insert_func, (intptr_t*)PLAYLIST_INSERT_LAST,
treeplaylist_callback, Icon_Playlist);
MENUITEM_FUNCTION(i_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT),
playlist_insert_func, (intptr_t*)PLAYLIST_INSERT,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(i_first_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT_FIRST),
playlist_insert_func, (intptr_t*)PLAYLIST_INSERT_FIRST,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(i_last_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_INSERT_LAST),
playlist_insert_func, (intptr_t*)PLAYLIST_INSERT_LAST,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(i_shuf_pl_item, MENU_FUNC_USEPARAM,
ID2P(LANG_INSERT_SHUFFLED), playlist_insert_func,
(intptr_t*)PLAYLIST_INSERT_SHUFFLED, treeplaylist_callback,
Icon_Playlist);
/* queue items */
MENUITEM_FUNCTION(q_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE),
playlist_queue_func, (intptr_t*)PLAYLIST_INSERT,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(q_first_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE_FIRST),
playlist_queue_func, (intptr_t*)PLAYLIST_INSERT_FIRST,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(q_last_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_QUEUE_LAST),
playlist_queue_func, (intptr_t*)PLAYLIST_INSERT_LAST,
treeplaylist_wplayback_callback, Icon_Playlist);
MENUITEM_FUNCTION(q_shuf_pl_item, MENU_FUNC_USEPARAM,
ID2P(LANG_QUEUE_SHUFFLED), playlist_queue_func,
(intptr_t*)PLAYLIST_INSERT_SHUFFLED,
treeplaylist_wplayback_callback, Icon_Playlist);
/* replace playlist */
MENUITEM_FUNCTION(replace_pl_item, MENU_FUNC_USEPARAM, ID2P(LANG_REPLACE),
playlist_insert_func, (intptr_t*)PLAYLIST_REPLACE,
treeplaylist_wplayback_callback, Icon_Playlist);
/* others */
MENUITEM_FUNCTION(view_playlist_item, 0, ID2P(LANG_VIEW),
view_playlist, NULL,
treeplaylist_callback, Icon_Playlist);
MAKE_ONPLAYMENU( tree_playlist_menu, ID2P(LANG_PLAYLIST),
treeplaylist_callback, Icon_Playlist,
/* view */
&view_playlist_item,
/* insert */
&i_pl_item_no_play, &i_pl_item, &i_first_pl_item,
&i_last_pl_item, &i_shuf_pl_item,
/* queue */
&q_pl_item, &q_first_pl_item, &q_last_pl_item,
&q_shuf_pl_item,
/* replace */
&replace_pl_item
);
static int treeplaylist_callback(int action,
const struct menu_item_ex *this_item)
{
(void)this_item;
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (this_item == &tree_playlist_menu)
{
if (((selected_file_attr & FILE_ATTR_MASK) ==
FILE_ATTR_AUDIO) ||
((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U)||
(selected_file_attr & ATTR_DIRECTORY))
{
return action;
}
else
return ACTION_EXIT_MENUITEM;
}
else if (this_item == &view_playlist_item)
{
if ((selected_file_attr & FILE_ATTR_MASK) == FILE_ATTR_M3U &&
context == CONTEXT_TREE)
return action;
else
return ACTION_EXIT_MENUITEM;
}
else if (this_item == &i_pl_item_no_play)
{
if (!(audio_status() & AUDIO_STATUS_PLAY))
{
return action;
}
else
return ACTION_EXIT_MENUITEM;
}
else if (this_item == &i_shuf_pl_item)
{
if (audio_status() & AUDIO_STATUS_PLAY)
{
return action;
}
else if ((this_item == &i_shuf_pl_item) &&
((selected_file_attr & ATTR_DIRECTORY) ||
((selected_file_attr & FILE_ATTR_MASK) ==
FILE_ATTR_M3U)))
{
return action;
}
return ACTION_EXIT_MENUITEM;
}
break;
}
return action;
}
/* helper function to remove a non-empty directory */
static int remove_dir(char* dirname, int len)
{
int result = 0;
DIR* dir;
int dirlen = strlen(dirname);
dir = opendir(dirname);
if (!dir)
return -1; /* open error */
while(true)
{
struct dirent* entry;
/* walk through the directory content */
entry = readdir(dir);
if (!entry)
break;
dirname[dirlen] ='\0';
splash(0, dirname);
/* append name to current directory */
snprintf(dirname+dirlen, len-dirlen, "/%s", entry->d_name);
if (entry->attribute & ATTR_DIRECTORY)
{ /* remove a subdirectory */
if (!strcmp((char *)entry->d_name, ".") ||
!strcmp((char *)entry->d_name, ".."))
continue; /* skip these */
/* inform the user which dir we're deleting */
result = remove_dir(dirname, len); /* recursion */
if (result)
break; /* or better continue, delete what we can? */
}
else
{ /* remove a file */
draw_slider();
result = remove(dirname);
}
if(ACTION_STD_CANCEL == get_action(CONTEXT_STD,TIMEOUT_NOBLOCK))
{
splash(HZ, ID2P(LANG_CANCEL));
result = -1;
break;
}
}
closedir(dir);
if (!result)
{ /* remove the now empty directory */
dirname[dirlen] = '\0'; /* terminate to original length */
result = rmdir(dirname);
}
return result;
}
/* share code for file and directory deletion, saves space */
static bool delete_handler(bool is_dir)
{
char file_to_delete[MAX_PATH];
strcpy(file_to_delete, selected_file);
const char *lines[]={
ID2P(LANG_REALLY_DELETE),
file_to_delete
};
const char *yes_lines[]={
ID2P(LANG_DELETED),
file_to_delete
};
struct text_message message={lines, 2};
struct text_message yes_message={yes_lines, 2};
if(gui_syncyesno_run(&message, &yes_message, NULL)!=YESNO_YES)
return false;
splash(0, str(LANG_DELETING));
int res;
if (is_dir)
{
char pathname[MAX_PATH]; /* space to go deep */
cpu_boost(true);
strncpy(pathname, file_to_delete, sizeof pathname);
res = remove_dir(pathname, sizeof(pathname));
cpu_boost(false);
}
else
res = remove(file_to_delete);
if (!res)
onplay_result = ONPLAY_RELOAD_DIR;
return false;
}
static bool delete_file(void)
{
return delete_handler(false);
}
static bool delete_dir(void)
{
return delete_handler(true);
}
#if LCD_DEPTH > 1
static bool set_backdrop(void)
{
/* load the image */
if(load_main_backdrop(selected_file)) {
splash(HZ, str(LANG_BACKDROP_LOADED));
set_file(selected_file, (char *)global_settings.backdrop_file,
MAX_FILENAME);
show_main_backdrop();
return true;
} else {
splash(HZ, str(LANG_BACKDROP_FAILED));
return false;
}
}
#endif
static bool rename_file(void)
{
char newname[MAX_PATH];
char* ptr = strrchr(selected_file, '/') + 1;
int pathlen = (ptr - selected_file);
strncpy(newname, selected_file, sizeof newname);
if (!kbd_input(newname + pathlen, (sizeof newname)-pathlen)) {
if (!strlen(newname + pathlen) ||
(rename(selected_file, newname) < 0)) {
lcd_clear_display();
lcd_puts(0,0,str(LANG_RENAME));
lcd_puts(0,1,str(LANG_FAILED));
lcd_update();
cond_talk_ids_fq(LANG_RENAME, LANG_FAILED);
sleep(HZ*2);
}
else
onplay_result = ONPLAY_RELOAD_DIR;
}
return false;
}
static bool create_dir(void)
{
char dirname[MAX_PATH];
char *cwd;
int rc;
int pathlen;
cwd = getcwd(NULL, 0);
memset(dirname, 0, sizeof dirname);
snprintf(dirname, sizeof dirname, "%s/",
cwd[1] ? cwd : "");
pathlen = strlen(dirname);
rc = kbd_input(dirname + pathlen, (sizeof dirname)-pathlen);
if (rc < 0)
return false;
rc = mkdir(dirname);
if (rc < 0) {
cond_talk_ids_fq(LANG_CREATE_DIR, LANG_FAILED);
splashf(HZ, (unsigned char *)"%s %s", str(LANG_CREATE_DIR),
str(LANG_FAILED));
} else {
onplay_result = ONPLAY_RELOAD_DIR;
}
return true;
}
static bool properties(void)
{
if(PLUGIN_USB_CONNECTED == filetype_load_plugin("properties",
selected_file))
onplay_result = ONPLAY_RELOAD_DIR;
return false;
}
/* Store the current selection in the clipboard */
static bool clipboard_clip(bool copy)
{
clipboard_selection[0] = 0;
strncpy(clipboard_selection, selected_file, sizeof(clipboard_selection));
clipboard_selection_attr = selected_file_attr;
clipboard_is_copy = copy;
return true;
}
static bool clipboard_cut(void)
{
return clipboard_clip(false);
}
static bool clipboard_copy(void)
{
return clipboard_clip(true);
}
#ifdef HAVE_LCD_BITMAP
static void draw_slider(void)
{
int i;
FOR_NB_SCREENS(i)
{
show_busy_slider(&screens[i], 1, LCD_HEIGHT-2*screens[i].char_height,
LCD_WIDTH-2, 2*screens[i].char_height-1);
screens[i].update();
}
}
#endif
/* Paste a file to a new directory. Will overwrite always. */
static bool clipboard_pastefile(const char *src, const char *target, bool copy)
{
int src_fd, target_fd;
size_t buffersize;
ssize_t size, bytesread, byteswritten;
char *buffer;
bool result = false;
if (copy) {
/* See if we can get the plugin buffer for the file copy buffer */
buffer = (char *) plugin_get_buffer(&buffersize);
if (buffer == NULL || buffersize < 512) {
/* Not large enough, try for a disk sector worth of stack
instead */
buffersize = 512;
buffer = (char *) __builtin_alloca(buffersize);
}
if (buffer == NULL) {
return false;
}
buffersize &= ~0x1ff; /* Round buffer size to multiple of sector
size */
src_fd = open(src, O_RDONLY);
if (src_fd >= 0) {
target_fd = creat(target);
if (target_fd >= 0) {
result = true;
size = filesize(src_fd);
if (size == -1) {
result = false;
}
while(size > 0) {
bytesread = read(src_fd, buffer, buffersize);
if (bytesread == -1) {
result = false;
break;
}
size -= bytesread;
while(bytesread > 0) {
byteswritten = write(target_fd, buffer, bytesread);
if (byteswritten == -1) {
result = false;
size = 0;
break;
}
bytesread -= byteswritten;
draw_slider();
}
}
close(target_fd);
/* Copy failed. Cleanup. */
if (!result) {
remove(target);
}
}
close(src_fd);
}
} else {
result = rename(src, target) == 0;
#ifdef HAVE_MULTIVOLUME
if (!result) {
if (errno == EXDEV) {
/* Failed because cross volume rename doesn't work. Copy
instead */
result = clipboard_pastefile(src, target, true);
if (result) {
result = remove(src) == 0;
}
}
}
#endif
}
return result;
}
/* Paste a directory to a new location. Designed to be called by
clipboard_paste */
static bool clipboard_pastedirectory(char *src, int srclen, char *target,
int targetlen, bool copy)
{
DIR *srcdir;
int srcdirlen = strlen(src);
int targetdirlen = strlen(target);
bool result = true;
if (!file_exists(target)) {
if (!copy) {
/* Just move the directory */
result = rename(src, target) == 0;
#ifdef HAVE_MULTIVOLUME
if (!result && errno == EXDEV) {
/* Try a copy as we're going across devices */
result = clipboard_pastedirectory(src, srclen, target,
targetlen, true);
/* If it worked, remove the source directory */
if (result) {
remove_dir(src, srclen);
}
}
#endif
return result;
} else {
/* Make a directory to copy things to */
result = mkdir(target) == 0;
}
}
/* Check if something went wrong already */
if (!result) {
return result;
}
srcdir = opendir(src);
if (!srcdir) {
return false;
}
/* This loop will exit as soon as there's a problem */
while(result)
{
struct dirent* entry;
/* walk through the directory content */
entry = readdir(srcdir);
if (!entry)
break;
/* append name to current directory */
snprintf(src+srcdirlen, srclen-srcdirlen, "/%s", entry->d_name);
snprintf(target+targetdirlen, targetlen-targetdirlen, "/%s",
entry->d_name);
DEBUGF("Copy %s to %s\n", src, target);
if (entry->attribute & ATTR_DIRECTORY)
{ /* copy/move a subdirectory */
if (!strcmp((char *)entry->d_name, ".") ||
!strcmp((char *)entry->d_name, ".."))
continue; /* skip these */
result = clipboard_pastedirectory(src, srclen, target, targetlen,
copy); /* recursion */
}
else
{ /* copy/move a file */
result = clipboard_pastefile(src, target, copy);
}
}
closedir(srcdir);
if (result) {
src[srcdirlen] = '\0'; /* terminate to original length */
target[targetdirlen] = '\0'; /* terminate to original length */
}
return result;
}
/* Paste the clipboard to the current directory */
static bool clipboard_paste(void)
{
char target[MAX_PATH];
char *cwd, *nameptr;
bool success;
static const char *lines[]={ID2P(LANG_REALLY_OVERWRITE)};
static const struct text_message message={lines, 1};
/* Get the name of the current directory */
cwd = getcwd(NULL, 0);
/* Figure out the name of the selection */
nameptr = strrchr(clipboard_selection, '/');
/* Final target is current directory plus name of selection */
snprintf(target, sizeof(target), "%s%s", cwd[1] ? cwd : "", nameptr);
/* If the target existed but they choose not to overwite, exit */
if (file_exists(target) &&
(gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)) {
return false;
}
if (clipboard_is_copy) {
splash(0, ID2P(LANG_COPYING));
}
else
{
splash(0, ID2P(LANG_MOVING));
}
/* Now figure out what we're doing */
cpu_boost(true);
if (clipboard_selection_attr & ATTR_DIRECTORY) {
/* Recursion. Set up external stack */
char srcpath[MAX_PATH];
char targetpath[MAX_PATH];
if (!strncmp(clipboard_selection, target, strlen(clipboard_selection)))
{
/* Do not allow the user to paste a directory into a dir they are
copying */
success = 0;
}
else
{
strncpy(srcpath, clipboard_selection, sizeof srcpath);
strncpy(targetpath, target, sizeof targetpath);
success = clipboard_pastedirectory(srcpath, sizeof(srcpath),
target, sizeof(targetpath), clipboard_is_copy);
}
} else {
success = clipboard_pastefile(clipboard_selection, target,
clipboard_is_copy);
}
cpu_boost(false);
/* Did it work? */
if (success) {
/* Reset everything */
clipboard_selection[0] = 0;
clipboard_selection_attr = 0;
clipboard_is_copy = false;
/* Force reload of the current directory */
onplay_result = ONPLAY_RELOAD_DIR;
} else {
cond_talk_ids_fq(LANG_PASTE, LANG_FAILED);
splashf(HZ, (unsigned char *)"%s %s", str(LANG_PASTE),
str(LANG_FAILED));
}
return true;
}
static int onplaymenu_callback(int action,const struct menu_item_ex *this_item);
#ifdef HAVE_TAGCACHE
static int set_rating_inline(void)
{
struct mp3entry* id3 = audio_current_track();
if (id3 && id3->tagcache_idx && global_settings.runtimedb)
{
set_int_ex(str(LANG_MENU_SET_RATING), "", UNIT_INT, (void*)(&id3->rating),
NULL, 1, 0, 10, NULL, NULL);
tagcache_update_numeric(id3->tagcache_idx-1, tag_rating, id3->rating);
}
else
splash(HZ*2, ID2P(LANG_ID3_NO_INFO));
return 0;
}
static int ratingitem_callback(int action,const struct menu_item_ex *this_item)
{
(void)this_item;
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (!selected_file || !global_settings.runtimedb)
return ACTION_EXIT_MENUITEM;
break;
}
return action;
}
MENUITEM_FUNCTION(rating_item, 0, ID2P(LANG_MENU_SET_RATING),
set_rating_inline, NULL,
ratingitem_callback, Icon_Questionmark);
#endif
static bool view_cue(void)
{
struct mp3entry* id3 = audio_current_track();
if(id3 && cuesheet_is_enabled() && id3->cuesheet_type)
{
browse_cuesheet(curr_cue);
}
return false;
}
static int view_cue_item_callback(int action,
const struct menu_item_ex *this_item)
{
(void)this_item;
struct mp3entry* id3 = audio_current_track();
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (!selected_file || !cuesheet_is_enabled()
|| !id3 || !id3->cuesheet_type)
return ACTION_EXIT_MENUITEM;
break;
}
return action;
}
MENUITEM_FUNCTION(view_cue_item, 0, ID2P(LANG_BROWSE_CUESHEET),
view_cue, NULL, view_cue_item_callback, Icon_NOICON);
/* CONTEXT_WPS items */
MENUITEM_FUNCTION(browse_id3_item, 0, ID2P(LANG_MENU_SHOW_ID3_INFO),
browse_id3, NULL, NULL, Icon_NOICON);
#ifdef HAVE_PITCHSCREEN
MENUITEM_FUNCTION(pitch_screen_item, 0, ID2P(LANG_PITCH),
pitch_screen, NULL, NULL, Icon_Audio);
#endif
/* CONTEXT_[TREE|ID3DB] items */
static int clipboard_callback(int action,const struct menu_item_ex *this_item);
MENUITEM_FUNCTION(rename_file_item, 0, ID2P(LANG_RENAME),
rename_file, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(clipboard_cut_item, 0, ID2P(LANG_CUT),
clipboard_cut, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(clipboard_copy_item, 0, ID2P(LANG_COPY),
clipboard_copy, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(clipboard_paste_item, 0, ID2P(LANG_PASTE),
clipboard_paste, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(delete_file_item, 0, ID2P(LANG_DELETE),
delete_file, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(delete_dir_item, 0, ID2P(LANG_DELETE_DIR),
delete_dir, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(properties_item, 0, ID2P(LANG_PROPERTIES),
properties, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(create_dir_item, 0, ID2P(LANG_CREATE_DIR),
create_dir, NULL, clipboard_callback, Icon_NOICON);
MENUITEM_FUNCTION(list_viewers_item, 0, ID2P(LANG_ONPLAY_OPEN_WITH),
list_viewers, NULL, clipboard_callback, Icon_NOICON);
#if LCD_DEPTH > 1
MENUITEM_FUNCTION(set_backdrop_item, 0, ID2P(LANG_SET_AS_BACKDROP),
set_backdrop, NULL, clipboard_callback, Icon_NOICON);
#endif
#ifdef HAVE_RECORDING
static bool set_recdir(void)
{
strncpy(global_settings.rec_directory,
selected_file, MAX_FILENAME+1);
settings_save();
return false;
}
MENUITEM_FUNCTION(set_recdir_item, 0, ID2P(LANG_SET_AS_REC_DIR),
set_recdir, NULL, clipboard_callback, Icon_Recording);
#endif
static bool add_to_faves(void)
{
if(PLUGIN_USB_CONNECTED == filetype_load_plugin("shortcuts_append",
selected_file))
onplay_result = ONPLAY_RELOAD_DIR;
return false;
}
MENUITEM_FUNCTION(add_to_faves_item, 0, ID2P(LANG_ADD_TO_FAVES),
add_to_faves, NULL, clipboard_callback, Icon_NOICON);
static int clipboard_callback(int action,const struct menu_item_ex *this_item)
{
switch (action)
{
case ACTION_REQUEST_MENUITEM:
#ifdef HAVE_MULTIVOLUME
if ((selected_file_attr & FAT_ATTR_VOLUME) &&
(this_item == &rename_file_item ||
this_item == &delete_dir_item ||
this_item == &clipboard_cut_item) )
return ACTION_EXIT_MENUITEM;
#endif
if (context == CONTEXT_ID3DB)
return ACTION_EXIT_MENUITEM;
if (this_item == &clipboard_paste_item)
{ /* visible if there is something to paste */
return (clipboard_selection[0] != 0) ?
action : ACTION_EXIT_MENUITEM;
}
else if (this_item == &create_dir_item)
{
/* always visible */
return action;
}
else if ((this_item == &properties_item) ||
(this_item == &rename_file_item) ||
(this_item == &clipboard_cut_item) ||
(this_item == &clipboard_copy_item) ||
(this_item == &add_to_faves_item)
)
{
/* requires an actual file */
return (selected_file) ? action : ACTION_EXIT_MENUITEM;
}
#if LCD_DEPTH > 1
else if (this_item == &set_backdrop_item)
{
if (selected_file)
{
char *suffix = strrchr(selected_file, '.');
if (suffix)
{
if (strcasecmp(suffix, ".bmp") == 0)
{
return action;
}
}
}
return ACTION_EXIT_MENUITEM;
}
#endif
else if ((selected_file_attr & ATTR_DIRECTORY))
{
if ((this_item == &delete_dir_item)
)
return action;
#ifdef HAVE_RECORDING
else if (this_item == &set_recdir_item)
return action;
#endif
}
else if (selected_file
#ifdef HAVE_MULTIVOLUME
/* no rename+delete for volumes */
&& !(selected_file_attr & ATTR_VOLUME)
#endif
)
{
if ((this_item == &delete_file_item) ||
(this_item == &list_viewers_item))
{
return action;
}
}
return ACTION_EXIT_MENUITEM;
break;
}
return action;
}
/* used when onplay() is called in the CONTEXT_WPS context */
MAKE_ONPLAYMENU( wps_onplay_menu, ID2P(LANG_ONPLAY_MENU_TITLE),
onplaymenu_callback, Icon_Audio,
&wps_playlist_menu, &cat_playlist_menu,
&sound_settings, &playback_settings,
#ifdef HAVE_TAGCACHE
&rating_item,
#endif
&bookmark_menu, &browse_id3_item, &list_viewers_item,
&delete_file_item, &view_cue_item,
#ifdef HAVE_PITCHSCREEN
&pitch_screen_item,
#endif
);
/* used when onplay() is not called in the CONTEXT_WPS context */
MAKE_ONPLAYMENU( tree_onplay_menu, ID2P(LANG_ONPLAY_MENU_TITLE),
onplaymenu_callback, Icon_file_view_menu,
&tree_playlist_menu, &cat_playlist_menu,
&rename_file_item, &clipboard_cut_item, &clipboard_copy_item,
&clipboard_paste_item, &delete_file_item, &delete_dir_item,
#if LCD_DEPTH > 1
&set_backdrop_item,
#endif
&list_viewers_item, &create_dir_item, &properties_item,
#ifdef HAVE_RECORDING
&set_recdir_item,
#endif
&add_to_faves_item,
);
static int onplaymenu_callback(int action,const struct menu_item_ex *this_item)
{
(void)this_item;
switch (action)
{
case ACTION_TREE_STOP:
if (this_item == &wps_onplay_menu)
{
list_stop_handler();
return ACTION_STD_CANCEL;
}
break;
case ACTION_EXIT_MENUITEM:
return ACTION_EXIT_AFTER_THIS_MENUITEM;
break;
}
return action;
}
int onplay(char* file, int attr, int from)
{
const struct menu_item_ex *menu;
onplay_result = ONPLAY_OK;
context = from;
selected_file = file;
selected_file_attr = attr;
if (context == CONTEXT_WPS)
menu = &wps_onplay_menu;
else
menu = &tree_onplay_menu;
switch (do_menu(menu, NULL, NULL, false))
{
case GO_TO_WPS:
return ONPLAY_START_PLAY;
case GO_TO_ROOT:
case GO_TO_MAINMENU:
return ONPLAY_MAINMENU;
default:
return context == CONTEXT_WPS ? ONPLAY_OK : ONPLAY_RELOAD_DIR;
}
}
Reference in a new issue View git blame Copy permalink