devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity
foxbox/apps/onplay.c
Nils Wallménius b311367481 *** Lang v2 cleanup (FS#6574) *** 
1) Introduces apps/features.txt that controls which strings are included 
for each target based on defines.
2) .lng and .voice files are now target specific and the format versions 
of both these file types have been bumped, which means that new voice 
files are needed. 
3) Use the 'features' mechanism to exclude strings for targets that 
didn't use them.
4) Delete unused and deprecated and duplicated strings, sort strings in 
english.lang

Some string IDs were changed so translations will be slightly worse than 
before.



git-svn-id: svn://svn.rockbox.org/rockbox/trunk@14198 a1c6a512-1295-4272-9138-f99709370657
2007-08-05 19:19:39 +00:00

1223 lines
37 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Björn Stenberg
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* 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"
#if CONFIG_CODEC == SWCODEC
#include "menus/eq_menu.h"
#endif
#include "playlist_menu.h"
#include "playlist_catalog.h"
#ifdef HAVE_TAGCACHE
#include "tagtree.h"
#endif
#include "cuesheet.h"
#if (LCD_DEPTH > 1) || (defined(HAVE_LCD_REMOTE) && (LCD_REMOTE_DEPTH > 1))
#include "backdrop.h"
#endif
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##__}};
/* ----------------------------------------------------------------------- */
/* 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_MENU(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);
char *lines[] = {
(char *)str(LANG_RECURSE_DIRECTORY_QUESTION),
selected_file
};
struct text_message message={lines, 2};
gui_syncsplash(0, str(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);
}
static bool cat_add_to_a_new_playlist(void)
{
return catalog_add_to_a_playlist(selected_file, selected_file_attr, true);
}
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_MENU( 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)
{
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);
int i;
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';
FOR_NB_SCREENS(i)
screens[i].puts(0,1,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 */
#ifdef HAVE_LCD_BITMAP
FOR_NB_SCREENS(i)
{
show_busy_slider(&screens[i], 2, 3*screens[i].char_height,
LCD_WIDTH-4, screens[i].char_height);
}
#endif
result = remove(dirname);
}
#ifdef HAVE_LCD_BITMAP
FOR_NB_SCREENS(i)
screens[i].update();
#endif
if(ACTION_STD_CANCEL == get_action(CONTEXT_STD,TIMEOUT_NOBLOCK))
{
gui_syncsplash(HZ, str(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 *lines[]={
(char *)str(LANG_REALLY_DELETE),
selected_file
};
char *yes_lines[]={
(char *)str(LANG_DELETED),
selected_file
};
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;
gui_syncsplash(0, str(LANG_DELETING));
int res;
if (is_dir)
{
char pathname[MAX_PATH]; /* space to go deep */
cpu_boost(true);
strncpy(pathname, selected_file, sizeof pathname);
res = remove_dir(pathname, sizeof(pathname));
cpu_boost(false);
}
else
res = remove(selected_file);
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)) {
gui_syncsplash(HZ, str(LANG_BACKDROP_LOADED));
set_file(selected_file, (char *)global_settings.backdrop_file,
MAX_FILENAME);
show_main_backdrop();
return true;
} else {
gui_syncsplash(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();
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) {
gui_syncsplash(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 inline void draw_slider(void)
{
int i;
FOR_NB_SCREENS(i)
{
show_busy_slider(&screens[i], 2, LCD_HEIGHT/4,
LCD_WIDTH-4, screens[i].char_height);
screens[i].update();
}
}
#else
#define draw_slider()
#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);
}
}
}
#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);
int fd;
bool result = true;
/* Check if the target exists */
fd = open(target, O_RDONLY);
close(fd);
if (fd < 0) {
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;
int target_fd;
unsigned char *lines[]={str(LANG_REALLY_OVERWRITE)};
struct text_message message={(char **)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);
/* Check if we're going to overwrite */
target_fd = open(target, O_RDONLY);
close(target_fd);
/* If the target existed but they choose not to overwite, exit */
if (target_fd >= 0 &&
(gui_syncyesno_run(&message, NULL, NULL) == YESNO_NO)) {
return false;
}
if (clipboard_is_copy) {
gui_syncsplash(0, str(LANG_COPYING));
}
else
{
gui_syncsplash(0, str(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 {
gui_syncsplash(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)
{
(void)this_item;
switch (action)
{
case ACTION_EXIT_MENUITEM:
return ACTION_EXIT_AFTER_THIS_MENUITEM;
break;
}
return action;
}
#ifdef HAVE_TAGCACHE
char *rating_name(int selected_item, void * data, char *buffer)
{
(void)selected_item; (void)data;
struct mp3entry* id3 = audio_current_track();
if(id3)
snprintf(buffer, MAX_PATH,
"%s: %d", str(LANG_MENU_SET_RATING), id3->rating);
else
snprintf(buffer, MAX_PATH,
"%s: -", str(LANG_MENU_SET_RATING));
return buffer;
}
static bool set_rating_inline(void)
{
struct mp3entry* id3 = audio_current_track();
if (id3 && id3->tagcache_idx)
{
if (id3->rating<10)
id3->rating++;
else
id3->rating=0;
tagcache_update_numeric(id3->tagcache_idx, tag_rating, id3->rating);
}
return false;
}
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_DYNTEXT(rating_item, 0, set_rating_inline,
NULL, rating_name, 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);
/* NOTE: the LANG_MENU_SET_RATING string has been removed from english.lang */
#ifdef HAVE_PITCHSCREEN
MENUITEM_FUNCTION(pitch_screen_item, 0, ID2P(LANG_PITCH),
pitch_screen, NULL, NULL, Icon_Audio);
#endif
#if CONFIG_CODEC == SWCODEC
MENUITEM_FUNCTION(eq_menu_graphical_item, 0, ID2P(LANG_EQUALIZER_GRAPHICAL),
eq_menu_graphical, NULL, NULL, Icon_Audio);
MENUITEM_FUNCTION(eq_browse_presets_item, 0, ID2P(LANG_EQUALIZER_BROWSE),
eq_browse_presets, 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);
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",
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:
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) ||
(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)
)
{
/* always visible */
return action;
}
#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,
&sound_settings, &wps_playlist_menu, &cat_playlist_menu,
#ifdef HAVE_TAGCACHE
&rating_item,
#endif
&bookmark_menu, &browse_id3_item, &delete_file_item, &view_cue_item,
#ifdef HAVE_PITCHSCREEN
&pitch_screen_item,
#endif
#if CONFIG_CODEC == SWCODEC
&eq_menu_graphical_item, &eq_browse_presets_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,
);
int onplay(char* file, int attr, int from)
{
int menu_result;
int selected_item = 0; /* this is a bit of a hack to reopen
the menu if certain items are selected */
onplay_result = ONPLAY_OK;
context = from;
selected_file = file;
selected_file_attr = attr;
if (context == CONTEXT_WPS)
{
#ifdef HAVE_TAGCACHE
do {
#endif
menu_result = do_menu(&wps_onplay_menu, &selected_item);
#ifdef HAVE_TAGCACHE
} while ((wps_onplay_menu_[selected_item] == &rating_item));
#endif
}
else
menu_result = do_menu(&tree_onplay_menu, NULL);
switch (menu_result)
{
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;
}
}
View git blame Copy permalink