Bump version numbers for 3.13
[maemo-rb.git] / apps / tree.c
blobcc080ac7fa14d041f3ddd7d3e23886d073fd2468
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2002 Daniel Stenberg
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdbool.h>
24 #include "string-extra.h"
26 #include "applimits.h"
27 #include "dir.h"
28 #include "file.h"
29 #include "lcd.h"
30 #include "font.h"
31 #include "button.h"
32 #include "kernel.h"
33 #include "usb.h"
34 #include "tree.h"
35 #include "audio.h"
36 #include "playlist.h"
37 #include "menu.h"
38 #include "skin_engine/skin_engine.h"
39 #include "settings.h"
40 #include "debug.h"
41 #include "storage.h"
42 #include "rolo.h"
43 #include "icons.h"
44 #include "lang.h"
45 #include "screens.h"
46 #include "keyboard.h"
47 #include "bookmark.h"
48 #include "onplay.h"
49 #include "core_alloc.h"
50 #include "power.h"
51 #include "action.h"
52 #include "talk.h"
53 #include "filetypes.h"
54 #include "misc.h"
55 #include "filefuncs.h"
56 #include "filetree.h"
57 #include "tagtree.h"
58 #ifdef HAVE_RECORDING
59 #include "recorder/recording.h"
60 #endif
61 #include "rtc.h"
62 #include "dircache.h"
63 #ifdef HAVE_TAGCACHE
64 #include "tagcache.h"
65 #endif
66 #include "yesno.h"
67 #include "eeprom_settings.h"
68 #include "playlist_catalog.h"
70 /* gui api */
71 #include "list.h"
72 #include "splash.h"
73 #include "buttonbar.h"
74 #include "quickscreen.h"
75 #include "appevents.h"
77 #include "root_menu.h"
79 static const struct filetype *filetypes;
80 static int filetypes_count;
82 struct gui_synclist tree_lists;
84 /* I put it here because other files doesn't use it yet,
85 * but should be elsewhere since it will be used mostly everywhere */
86 #ifdef HAVE_BUTTONBAR
87 static struct gui_buttonbar tree_buttonbar;
88 #endif
89 static struct tree_context tc;
91 char lastfile[MAX_PATH];
92 static char lastdir[MAX_PATH];
93 #ifdef HAVE_TAGCACHE
94 static int lasttable, lastextra, lastfirstpos;
95 #endif
97 static bool reload_dir = false;
99 static bool start_wps = false;
100 static int curr_context = false;/* id3db or tree*/
102 static int dirbrowse(void);
103 static int ft_play_dirname(char* name);
104 static void ft_play_filename(char *dir, char *file);
105 static void say_filetype(int attr);
107 struct entry* tree_get_entries(struct tree_context *t)
109 return core_get_data(t->cache.entries_handle);
112 struct entry* tree_get_entry_at(struct tree_context *t, int index)
114 struct entry* entries = tree_get_entries(t);
115 return &entries[index];
119 static const char* tree_get_filename(int selected_item, void *data,
120 char *buffer, size_t buffer_len)
122 struct tree_context * local_tc=(struct tree_context *)data;
123 char *name;
124 int attr=0;
125 bool stripit = false;
126 #ifdef HAVE_TAGCACHE
127 bool id3db = *(local_tc->dirfilter) == SHOW_ID3DB;
129 if (id3db)
131 return tagtree_get_entry_name(&tc, selected_item, buffer, buffer_len);
133 else
134 #endif
136 struct entry* e = tree_get_entry_at(local_tc, selected_item);
137 name = e->name;
138 attr = e->attr;
141 if(!(attr & ATTR_DIRECTORY))
143 switch(global_settings.show_filename_ext)
145 case 0:
146 /* show file extension: off */
147 stripit = true;
148 break;
149 case 1:
150 /* show file extension: on */
151 break;
152 case 2:
153 /* show file extension: only unknown types */
154 stripit = filetype_supported(attr);
155 break;
156 case 3:
157 default:
158 /* show file extension: only when viewing all */
159 stripit = (*(local_tc->dirfilter) != SHOW_ID3DB) &&
160 (*(local_tc->dirfilter) != SHOW_ALL);
161 break;
165 if(stripit)
167 return(strip_extension(buffer, buffer_len, name));
169 return(name);
172 #ifdef HAVE_LCD_COLOR
173 static int tree_get_filecolor(int selected_item, void * data)
175 if (*tc.dirfilter == SHOW_ID3DB)
176 return -1;
177 struct tree_context * local_tc=(struct tree_context *)data;
178 struct entry* e = tree_get_entry_at(local_tc, selected_item);
179 return filetype_get_color(e->name, e->attr);
181 #endif
183 static enum themable_icons tree_get_fileicon(int selected_item, void * data)
185 struct tree_context * local_tc=(struct tree_context *)data;
186 #ifdef HAVE_TAGCACHE
187 bool id3db = *(local_tc->dirfilter) == SHOW_ID3DB;
188 if (id3db) {
189 return tagtree_get_icon(&tc);
191 else
192 #endif
194 struct entry* e = tree_get_entry_at(local_tc, selected_item);
195 return filetype_get_icon(e->attr);
199 static int tree_voice_cb(int selected_item, void * data)
201 struct tree_context * local_tc=(struct tree_context *)data;
202 char *name;
203 int attr=0;
204 #ifdef HAVE_TAGCACHE
205 bool id3db = *(local_tc->dirfilter) == SHOW_ID3DB;
206 char buf[AVERAGE_FILENAME_LENGTH*2];
208 if (id3db)
210 attr = tagtree_get_attr(local_tc);
211 name = tagtree_get_entry_name(local_tc, selected_item, buf, sizeof(buf));
213 else
214 #endif
216 struct entry* e = tree_get_entry_at(local_tc, selected_item);
217 name = e->name;
218 attr = e->attr;
220 bool is_dir = (attr & ATTR_DIRECTORY);
221 bool did_clip = false;
222 /* First the .talk clip case */
223 if(is_dir)
225 if(global_settings.talk_dir_clip)
227 did_clip = true;
228 if(ft_play_dirname(name) <0)
229 /* failed, not existing */
230 did_clip = false;
232 } else { /* it's a file */
233 if (global_settings.talk_file_clip && (attr & FILE_ATTR_THUMBNAIL))
235 did_clip = true;
236 ft_play_filename(local_tc->currdir, name);
239 if(!did_clip)
241 /* say the number or spell if required or as a fallback */
242 switch (is_dir ? global_settings.talk_dir : global_settings.talk_file)
244 case 1: /* as numbers */
245 talk_id(is_dir ? VOICE_DIR : VOICE_FILE, false);
246 talk_number(selected_item+1 - (is_dir ? 0 : local_tc->dirsindir),
247 true);
248 if(global_settings.talk_filetype
249 && !is_dir && *local_tc->dirfilter < NUM_FILTER_MODES)
250 say_filetype(attr);
251 break;
252 case 2: /* spelled */
253 talk_shutup();
254 if(global_settings.talk_filetype)
256 if(is_dir)
257 talk_id(VOICE_DIR, true);
258 else if(*local_tc->dirfilter < NUM_FILTER_MODES)
259 say_filetype(attr);
261 talk_spell(name, true);
262 break;
265 return 0;
268 bool check_rockboxdir(void)
270 if(!dir_exists(ROCKBOX_DIR))
271 { /* No need to localise this message.
272 If .rockbox is missing, it wouldn't work anyway */
273 FOR_NB_SCREENS(i)
274 screens[i].clear_display();
275 splash(HZ*2, "No .rockbox directory");
276 FOR_NB_SCREENS(i)
277 screens[i].clear_display();
278 splash(HZ*2, "Installation incomplete");
279 return false;
281 return true;
284 /* do this really late in the init sequence */
285 void tree_gui_init(void)
287 check_rockboxdir();
289 strcpy(tc.currdir, "/");
291 #ifdef HAVE_LCD_CHARCELLS
292 FOR_NB_SCREENS(i)
293 screens[i].double_height(false);
294 #endif
295 #ifdef HAVE_BUTTONBAR
296 gui_buttonbar_init(&tree_buttonbar);
297 /* since archos only have one screen, no need to create more than that */
298 gui_buttonbar_set_display(&tree_buttonbar, &(screens[SCREEN_MAIN]) );
299 #endif
300 gui_synclist_init(&tree_lists, &tree_get_filename, &tc, false, 1, NULL);
301 gui_synclist_set_voice_callback(&tree_lists, tree_voice_cb);
302 gui_synclist_set_icon_callback(&tree_lists,
303 global_settings.show_icons?&tree_get_fileicon:NULL);
304 #ifdef HAVE_LCD_COLOR
305 gui_synclist_set_color_callback(&tree_lists, &tree_get_filecolor);
306 #endif
310 struct tree_context* tree_get_context(void)
312 return &tc;
316 * Returns the position of a given file in the current directory
317 * returns -1 if not found
319 static int tree_get_file_position(char * filename)
321 int i;
322 struct entry* e;
324 /* use lastfile to determine the selected item (default=0) */
325 for (i=0; i < tc.filesindir; i++)
327 e = tree_get_entry_at(&tc, i);
328 if (!strcasecmp(e->name, filename))
329 return(i);
331 return(-1);/* no file can match, returns undefined */
335 * Called when a new dir is loaded (for example when returning from other apps ...)
336 * also completely redraws the tree
338 static int update_dir(void)
340 bool changed = false;
341 #ifdef HAVE_TAGCACHE
342 bool id3db = *tc.dirfilter == SHOW_ID3DB;
343 /* Checks for changes */
344 if (id3db) {
345 if (tc.currtable != lasttable ||
346 tc.currextra != lastextra ||
347 tc.firstpos != lastfirstpos ||
348 reload_dir)
350 if (tagtree_load(&tc) < 0)
351 return -1;
353 lasttable = tc.currtable;
354 lastextra = tc.currextra;
355 lastfirstpos = tc.firstpos;
356 changed = true;
359 else
360 #endif
362 /* if the tc.currdir has been changed, reload it ...*/
363 if (strncmp(tc.currdir, lastdir, sizeof(lastdir)) || reload_dir)
365 if (ft_load(&tc, NULL) < 0)
366 return -1;
367 strcpy(lastdir, tc.currdir);
368 changed = true;
371 /* if selected item is undefined */
372 if (tc.selected_item == -1)
374 /* use lastfile to determine the selected item */
375 tc.selected_item = tree_get_file_position(lastfile);
377 /* If the file doesn't exists, select the first one (default) */
378 if(tc.selected_item < 0)
379 tc.selected_item = 0;
380 changed = true;
382 if (changed)
385 #ifdef HAVE_TAGCACHE
386 !id3db &&
387 #endif
388 tc.dirfull )
390 splash(HZ, ID2P(LANG_SHOWDIR_BUFFER_FULL));
393 #ifdef HAVE_TAGCACHE
394 if (id3db)
396 #ifdef HAVE_LCD_BITMAP
397 if (global_settings.show_path_in_browser == SHOW_PATH_FULL
398 || global_settings.show_path_in_browser == SHOW_PATH_CURRENT)
400 gui_synclist_set_title(&tree_lists, tagtree_get_title(&tc),
401 filetype_get_icon(ATTR_DIRECTORY));
403 else
405 /* Must clear the title as the list is reused */
406 gui_synclist_set_title(&tree_lists, NULL, NOICON);
408 #endif
410 else
411 #endif
413 #ifdef HAVE_LCD_BITMAP
414 if (tc.browse && tc.browse->title)
416 int icon = tc.browse->icon;
417 if (icon == NOICON)
418 icon = filetype_get_icon(ATTR_DIRECTORY);
419 gui_synclist_set_title(&tree_lists, tc.browse->title, icon);
421 else if (global_settings.show_path_in_browser == SHOW_PATH_FULL)
423 gui_synclist_set_title(&tree_lists, tc.currdir,
424 filetype_get_icon(ATTR_DIRECTORY));
426 else if (global_settings.show_path_in_browser == SHOW_PATH_CURRENT)
428 char *title = strrchr(tc.currdir, '/') + 1;
429 if (*title == '\0')
431 /* Display "Files" for the root dir */
432 gui_synclist_set_title(&tree_lists, str(LANG_DIR_BROWSER),
433 filetype_get_icon(ATTR_DIRECTORY));
435 else
436 gui_synclist_set_title(&tree_lists, title,
437 filetype_get_icon(ATTR_DIRECTORY));
439 else
441 /* Must clear the title as the list is reused */
442 gui_synclist_set_title(&tree_lists, NULL, NOICON);
444 #endif
447 gui_synclist_set_nb_items(&tree_lists, tc.filesindir);
448 gui_synclist_set_icon_callback(&tree_lists,
449 global_settings.show_icons?tree_get_fileicon:NULL);
450 if( tc.selected_item >= tc.filesindir)
451 tc.selected_item=tc.filesindir-1;
453 gui_synclist_select_item(&tree_lists, tc.selected_item);
454 #ifdef HAVE_BUTTONBAR
455 if (global_settings.buttonbar) {
456 if (*tc.dirfilter < NUM_FILTER_MODES)
457 gui_buttonbar_set(&tree_buttonbar, str(LANG_SYSFONT_DIRBROWSE_F1),
458 str(LANG_SYSFONT_DIRBROWSE_F2),
459 str(LANG_SYSFONT_DIRBROWSE_F3));
460 else
461 gui_buttonbar_set(&tree_buttonbar, "<<<", "", "");
462 gui_buttonbar_draw(&tree_buttonbar);
464 #endif
465 gui_synclist_draw(&tree_lists);
466 gui_synclist_speak_item(&tree_lists);
467 return tc.filesindir;
470 /* load tracks from specified directory to resume play */
471 void resume_directory(const char *dir)
473 int dirfilter = *tc.dirfilter;
474 int ret;
475 #ifdef HAVE_TAGCACHE
476 bool id3db = *tc.dirfilter == SHOW_ID3DB;
477 #endif
478 /* make sure the dirfilter is sane. The only time it should be possible
479 * thats its not is when resume playlist is called from a plugin
481 #ifdef HAVE_TAGCACHE
482 if (!id3db)
483 #endif
484 *tc.dirfilter = global_settings.dirfilter;
485 ret = ft_load(&tc, dir);
486 *tc.dirfilter = dirfilter;
487 if (ret < 0)
488 return;
489 lastdir[0] = 0;
491 ft_build_playlist(&tc, 0);
493 #ifdef HAVE_TAGCACHE
494 if (id3db)
495 tagtree_load(&tc);
496 #endif
499 /* Returns the current working directory and also writes cwd to buf if
500 non-NULL. In case of error, returns NULL. */
501 char *getcwd(char *buf, getcwd_size_t size)
503 if (!buf)
504 return tc.currdir;
505 else if (size)
507 if ((getcwd_size_t)strlcpy(buf, tc.currdir, size) < size)
508 return buf;
510 /* size == 0, or truncation in strlcpy */
511 return NULL;
514 /* Force a reload of the directory next time directory browser is called */
515 void reload_directory(void)
517 reload_dir = true;
520 char* get_current_file(char* buffer, size_t buffer_len)
522 #ifdef HAVE_TAGCACHE
523 /* in ID3DB mode it is a bad idea to call this function */
524 /* (only happens with `follow playlist') */
525 if( *tc.dirfilter == SHOW_ID3DB )
526 return NULL;
527 #endif
529 struct entry* e = tree_get_entry_at(&tc, tc.selected_item);
530 if (getcwd(buffer, buffer_len))
532 if (tc.dirlength)
534 if (buffer[strlen(buffer)-1] != '/')
535 strlcat(buffer, "/", buffer_len);
536 if (strlcat(buffer, e->name, buffer_len) >= buffer_len)
537 return NULL;
539 return buffer;
541 return NULL;
544 /* Allow apps to change our dirfilter directly (required for sub browsers)
545 if they're suddenly going to become a file browser for example */
546 void set_dirfilter(int l_dirfilter)
548 *tc.dirfilter = l_dirfilter;
551 /* Selects a file and update tree context properly */
552 void set_current_file(const char *path)
554 const char *name;
555 int i;
557 #ifdef HAVE_TAGCACHE
558 /* in ID3DB mode it is a bad idea to call this function */
559 /* (only happens with `follow playlist') */
560 if( *tc.dirfilter == SHOW_ID3DB )
561 return;
562 #endif
564 /* separate directory from filename */
565 /* gets the directory's name and put it into tc.currdir */
566 name = strrchr(path+1,'/');
567 if (name)
569 strlcpy(tc.currdir, path, name - path + 1);
570 name++;
572 else
574 strcpy(tc.currdir, "/");
575 name = path+1;
578 strcpy(lastfile, name);
581 /* If we changed dir we must recalculate the dirlevel
582 and adjust the selected history properly */
583 if (strncmp(tc.currdir,lastdir,sizeof(lastdir)))
585 tc.dirlevel = 0;
586 tc.selected_item_history[tc.dirlevel] = -1;
588 /* use '/' to calculate dirlevel */
589 for (i = 1; path[i] != '\0'; i++)
591 if (path[i] == '/')
593 tc.dirlevel++;
594 tc.selected_item_history[tc.dirlevel] = -1;
598 if (ft_load(&tc, NULL) >= 0)
600 tc.selected_item = tree_get_file_position(lastfile);
605 /* main loop, handles key events */
606 static int dirbrowse(void)
608 int numentries=0;
609 char buf[MAX_PATH];
610 int button;
611 #ifdef HAVE_LCD_BITMAP
612 int oldbutton;
613 #endif
614 bool reload_root = false;
615 int lastfilter = *tc.dirfilter;
616 bool lastsortcase = global_settings.sort_case;
617 bool exit_func = false;
619 char* currdir = tc.currdir; /* just a shortcut */
620 #ifdef HAVE_TAGCACHE
621 bool id3db = *tc.dirfilter == SHOW_ID3DB;
623 if (id3db)
624 curr_context=CONTEXT_ID3DB;
625 else
626 #endif
627 curr_context=CONTEXT_TREE;
628 if (tc.selected_item < 0)
629 tc.selected_item = 0;
630 #ifdef HAVE_TAGCACHE
631 tc.firstpos = 0;
632 lasttable = -1;
633 lastextra = -1;
634 lastfirstpos = 0;
635 #endif
637 start_wps = false;
638 numentries = update_dir();
639 reload_dir = false;
640 if (numentries == -1)
641 return GO_TO_PREVIOUS; /* currdir is not a directory */
643 if (*tc.dirfilter > NUM_FILTER_MODES && numentries==0)
645 splash(HZ*2, ID2P(LANG_NO_FILES));
646 return GO_TO_PREVIOUS; /* No files found for rockbox_browse() */
649 gui_synclist_draw(&tree_lists);
650 while(1) {
651 bool restore = false;
652 if (tc.dirlevel < 0)
653 tc.dirlevel = 0; /* shouldnt be needed.. this code needs work! */
655 #if CONFIG_CODEC == SWCODEC
656 keyclick_set_callback(gui_synclist_keyclick_callback, &tree_lists);
657 #endif
658 button = get_action(CONTEXT_TREE,
659 list_do_action_timeout(&tree_lists, HZ/2));
660 #ifdef HAVE_LCD_BITMAP
661 oldbutton = button;
662 #endif
663 gui_synclist_do_button(&tree_lists, &button,LIST_WRAP_UNLESS_HELD);
664 tc.selected_item = gui_synclist_get_sel_pos(&tree_lists);
665 switch ( button ) {
666 case ACTION_STD_OK:
667 /* nothing to do if no files to display */
668 if ( numentries == 0 )
669 break;
671 short attr = tree_get_entry_at(&tc, tc.selected_item)->attr;
672 if ((tc.browse->flags & BROWSE_SELECTONLY) &&
673 !(attr & ATTR_DIRECTORY))
675 tc.browse->flags |= BROWSE_SELECTED;
676 get_current_file(tc.browse->buf, tc.browse->bufsize);
677 return GO_TO_PREVIOUS;
680 #ifdef HAVE_TAGCACHE
681 switch (id3db?tagtree_enter(&tc):ft_enter(&tc))
682 #else
683 switch (ft_enter(&tc))
684 #endif
686 case GO_TO_FILEBROWSER: reload_dir = true; break;
687 case GO_TO_WPS:
688 return GO_TO_WPS;
689 #if CONFIG_TUNER
690 case GO_TO_FM:
691 return GO_TO_FM;
692 #endif
693 case GO_TO_ROOT: exit_func = true; break;
694 default: break;
696 restore = true;
697 break;
699 case ACTION_STD_CANCEL:
700 if (*tc.dirfilter > NUM_FILTER_MODES && tc.dirlevel < 1) {
701 exit_func = true;
702 break;
704 if ((*tc.dirfilter == SHOW_ID3DB && tc.dirlevel == 0) ||
705 ((*tc.dirfilter != SHOW_ID3DB && !strcmp(currdir,"/"))))
707 #ifdef HAVE_LCD_BITMAP /* charcell doesnt have ACTION_TREE_PGLEFT so this isnt needed */
708 if (oldbutton == ACTION_TREE_PGLEFT)
709 break;
710 else
711 #endif
712 return GO_TO_ROOT;
715 #ifdef HAVE_TAGCACHE
716 if (id3db)
717 tagtree_exit(&tc);
718 else
719 #endif
720 if (ft_exit(&tc) == 3)
721 exit_func = true;
723 restore = true;
724 break;
726 case ACTION_TREE_STOP:
727 if (list_stop_handler())
728 restore = true;
729 break;
731 case ACTION_STD_MENU:
732 return GO_TO_ROOT;
733 break;
735 #ifdef HAVE_RECORDING
736 case ACTION_STD_REC:
737 return GO_TO_RECSCREEN;
738 #endif
740 case ACTION_TREE_WPS:
741 return GO_TO_PREVIOUS_MUSIC;
742 break;
743 #ifdef HAVE_QUICKSCREEN
744 case ACTION_STD_QUICKSCREEN:
745 /* don't enter f2 from plugin browser */
746 if (*tc.dirfilter < NUM_FILTER_MODES)
748 if (quick_screen_quick(button))
749 reload_dir = true;
750 restore = true;
752 break;
753 #endif
754 #ifdef BUTTON_F3
755 case ACTION_F3:
756 /* don't enter f3 from plugin browser */
757 if (*tc.dirfilter < NUM_FILTER_MODES)
759 if (quick_screen_f3(ACTION_F3))
760 reload_dir = true;
761 restore = true;
763 break;
764 #endif
766 #ifdef HAVE_HOTKEY
767 case ACTION_TREE_HOTKEY:
768 if (!global_settings.hotkey_tree)
769 break;
770 /* fall through */
771 #endif
772 case ACTION_STD_CONTEXT:
774 bool hotkey = button == ACTION_TREE_HOTKEY;
775 int onplay_result;
776 int attr = 0;
778 if (tc.browse->flags & BROWSE_NO_CONTEXT_MENU)
779 break;
781 if(!numentries)
782 onplay_result = onplay(NULL, 0, curr_context, hotkey);
783 else {
784 #ifdef HAVE_TAGCACHE
785 if (id3db)
787 if (tagtree_get_attr(&tc) == FILE_ATTR_AUDIO)
789 attr = FILE_ATTR_AUDIO;
790 tagtree_get_filename(&tc, buf, sizeof(buf));
792 else
793 attr = ATTR_DIRECTORY;
795 else
796 #endif
798 struct entry *entry = tree_get_entry_at(&tc, tc.selected_item);
799 attr = entry->attr;
801 if (currdir[1]) /* Not in / */
802 snprintf(buf, sizeof buf, "%s/%s",
803 currdir, entry->name);
804 else /* In / */
805 snprintf(buf, sizeof buf, "/%s", entry->name);
807 onplay_result = onplay(buf, attr, curr_context, hotkey);
809 switch (onplay_result)
811 case ONPLAY_MAINMENU:
812 return GO_TO_ROOT;
814 case ONPLAY_OK:
815 restore = true;
816 break;
818 case ONPLAY_RELOAD_DIR:
819 reload_dir = true;
820 break;
822 case ONPLAY_START_PLAY:
823 return GO_TO_WPS;
824 break;
826 break;
829 #ifdef HAVE_HOTSWAP
830 case SYS_FS_CHANGED:
831 #ifdef HAVE_TAGCACHE
832 if (!id3db)
833 #endif
834 reload_dir = true;
835 /* The 'dir no longer valid' situation will be caught later
836 * by checking the showdir() result. */
837 break;
838 #endif
840 default:
841 if (default_event_handler(button) == SYS_USB_CONNECTED)
843 if(*tc.dirfilter > NUM_FILTER_MODES)
844 /* leave sub-browsers after usb, doing otherwise
845 might be confusing to the user */
846 exit_func = true;
847 else
848 reload_dir = true;
850 break;
852 if (start_wps)
853 return GO_TO_WPS;
854 if (button && !IS_SYSEVENT(button))
856 storage_spin();
860 check_rescan:
861 /* do we need to rescan dir? */
862 if (reload_dir || reload_root ||
863 lastfilter != *tc.dirfilter ||
864 lastsortcase != global_settings.sort_case)
866 if (reload_root) {
867 strcpy(currdir, "/");
868 tc.dirlevel = 0;
869 #ifdef HAVE_TAGCACHE
870 tc.currtable = 0;
871 tc.currextra = 0;
872 lasttable = -1;
873 lastextra = -1;
874 #endif
875 reload_root = false;
878 if (!reload_dir)
880 gui_synclist_select_item(&tree_lists, 0);
881 gui_synclist_draw(&tree_lists);
882 tc.selected_item = 0;
883 lastdir[0] = 0;
886 lastfilter = *tc.dirfilter;
887 lastsortcase = global_settings.sort_case;
888 restore = true;
891 if (exit_func)
892 return GO_TO_PREVIOUS;
894 if (restore || reload_dir) {
895 /* restore display */
896 numentries = update_dir();
897 reload_dir = false;
898 if (currdir[1] && (numentries < 0))
899 { /* not in root and reload failed */
900 reload_root = true; /* try root */
901 goto check_rescan;
905 return true;
908 bool create_playlist(void)
910 char filename[MAX_PATH];
912 if (tc.currdir[1])
913 snprintf(filename, sizeof filename, "%s.m3u8", tc.currdir);
914 else
915 snprintf(filename, sizeof filename, "%s/all.m3u8",
916 catalog_get_directory());
919 if (kbd_input(filename, MAX_PATH))
920 return false;
921 splashf(0, "%s %s", str(LANG_CREATING), filename);
923 trigger_cpu_boost();
924 catalog_add_to_a_playlist(tc.currdir, ATTR_DIRECTORY, true, filename);
925 cancel_cpu_boost();
927 return true;
930 void browse_context_init(struct browse_context *browse,
931 int dirfilter, unsigned flags,
932 char *title, enum themable_icons icon,
933 const char *root, const char *selected)
935 browse->dirfilter = dirfilter;
936 browse->flags = flags;
937 browse->callback_show_item = NULL;
938 browse->title = title;
939 browse->icon = icon;
940 browse->root = root;
941 browse->selected = selected;
942 browse->buf = NULL;
943 browse->bufsize = 0;
946 #define NUM_TC_BACKUP 3
947 static struct tree_context backups[NUM_TC_BACKUP];
948 /* do not make backup if it is not recursive call */
949 static int backup_count = -1;
950 int rockbox_browse(struct browse_context *browse)
952 static char current[MAX_PATH];
953 int ret_val = 0;
954 int dirfilter = browse->dirfilter;
956 if (backup_count >= NUM_TC_BACKUP)
957 return GO_TO_PREVIOUS;
958 if (backup_count >= 0)
959 backups[backup_count] = tc;
960 backup_count++;
962 tc.dirfilter = &dirfilter;
963 tc.sort_dir = global_settings.sort_dir;
965 reload_dir = true;
966 if (*tc.dirfilter >= NUM_FILTER_MODES)
968 int last_context;
970 tc.browse = browse;
971 tc.selected_item = 0;
972 tc.dirlevel = 0;
973 strlcpy(tc.currdir, browse->root, sizeof(tc.currdir));
974 start_wps = false;
975 last_context = curr_context;
977 if (browse->selected)
979 snprintf(current, sizeof(current), "%s/%s",
980 browse->root, browse->selected);
981 set_current_file(current);
982 /* set_current_file changes dirlevel, change it back */
983 tc.dirlevel = 0;
986 ret_val = dirbrowse();
987 curr_context = last_context;
989 else
991 if (dirfilter != SHOW_ID3DB)
992 tc.dirfilter = &global_settings.dirfilter;
993 tc.browse = browse;
994 strcpy(current, browse->root);
995 set_current_file(current);
996 if (browse->flags&BROWSE_RUNFILE)
997 ret_val = ft_enter(&tc);
998 else
999 ret_val = dirbrowse();
1001 backup_count--;
1002 if (backup_count >= 0)
1003 tc = backups[backup_count];
1004 return ret_val;
1007 static int move_callback(int handle, void* current, void* new)
1009 struct tree_cache* cache = &tc.cache;
1010 if (cache->lock_count > 0)
1011 return BUFLIB_CB_CANNOT_MOVE;
1013 size_t diff = new - current;
1014 /* FIX_PTR makes sure to not accidentally update static allocations */
1015 #define FIX_PTR(x) \
1016 { if ((void*)x >= current && (void*)x < (current+cache->name_buffer_size)) x+= diff; }
1018 if (handle == cache->name_buffer_handle)
1019 { /* update entry structs, *even if they are struct tagentry */
1020 struct entry *this = core_get_data(cache->entries_handle);
1021 struct entry *last = this + cache->max_entries;
1022 for(; this < last; this++)
1023 FIX_PTR(this->name);
1025 /* nothing to do if entries moved */
1026 return BUFLIB_CB_OK;
1029 static struct buflib_callbacks ops = {
1030 .move_callback = move_callback,
1031 .shrink_callback = NULL,
1034 void tree_mem_init(void)
1036 /* initialize tree context struct */
1037 struct tree_cache* cache = &tc.cache;
1038 memset(&tc, 0, sizeof(tc));
1039 tc.dirfilter = &global_settings.dirfilter;
1040 tc.sort_dir = global_settings.sort_dir;
1042 cache->name_buffer_size = AVERAGE_FILENAME_LENGTH *
1043 global_settings.max_files_in_dir;
1044 cache->name_buffer_handle = core_alloc_ex("tree names",
1045 cache->name_buffer_size,
1046 &ops);
1048 cache->max_entries = global_settings.max_files_in_dir;
1049 cache->entries_handle = core_alloc_ex("tree entries",
1050 cache->max_entries*(sizeof(struct entry)),
1051 &ops);
1052 tree_get_filetypes(&filetypes, &filetypes_count);
1055 bool bookmark_play(char *resume_file, int index, int offset, int seed,
1056 char *filename)
1058 int i;
1059 char* suffix = strrchr(resume_file, '.');
1060 bool started = false;
1062 if (suffix != NULL &&
1063 (!strcasecmp(suffix, ".m3u") || !strcasecmp(suffix, ".m3u8")))
1065 /* Playlist playback */
1066 char* slash;
1067 /* check that the file exists */
1068 if(!file_exists(resume_file))
1069 return false;
1071 slash = strrchr(resume_file,'/');
1072 if (slash)
1074 char* cp;
1075 *slash=0;
1077 cp=resume_file;
1078 if (!cp[0])
1079 cp="/";
1081 if (playlist_create(cp, slash+1) != -1)
1083 if (global_settings.playlist_shuffle)
1084 playlist_shuffle(seed, -1);
1085 playlist_start(index,offset);
1086 started = true;
1088 *slash='/';
1091 else
1093 /* Directory playback */
1094 lastdir[0]='\0';
1095 if (playlist_create(resume_file, NULL) != -1)
1097 char filename_buf[MAX_PATH + 1];
1098 const char* peek_filename;
1099 resume_directory(resume_file);
1100 if (global_settings.playlist_shuffle)
1101 playlist_shuffle(seed, -1);
1103 /* Check if the file is at the same spot in the directory,
1104 else search for it */
1105 peek_filename = playlist_peek(index, filename_buf,
1106 sizeof(filename_buf));
1108 if (peek_filename == NULL)
1110 /* playlist has shrunk, search from the top */
1111 index = 0;
1112 peek_filename = playlist_peek(index, filename_buf,
1113 sizeof(filename_buf));
1114 if (peek_filename == NULL)
1115 return false;
1118 if (strcmp(strrchr(peek_filename, '/') + 1, filename))
1120 for ( i=0; i < playlist_amount(); i++ )
1122 peek_filename = playlist_peek(i, filename_buf,
1123 sizeof(filename_buf));
1125 if (peek_filename == NULL)
1126 return false;
1128 if (!strcmp(strrchr(peek_filename, '/') + 1, filename))
1129 break;
1131 if (i < playlist_amount())
1132 index = i;
1133 else
1134 return false;
1136 playlist_start(index,offset);
1137 started = true;
1141 if (started)
1142 start_wps = true;
1143 return started;
1146 static void say_filetype(int attr)
1148 /* try to find a voice ID for the extension, if known */
1149 int j;
1150 attr &= FILE_ATTR_MASK; /* file type */
1151 for (j=0; j<filetypes_count; j++)
1152 if (attr == filetypes[j].tree_attr)
1154 talk_id(filetypes[j].voiceclip, true);
1155 return;
1159 static int ft_play_dirname(char* name)
1161 #if CONFIG_CODEC != SWCODEC
1162 if (audio_status() & AUDIO_STATUS_PLAY)
1163 return 0;
1164 #endif
1166 if(talk_file(tc.currdir, name, dir_thumbnail_name, NULL,
1167 NULL, false))
1169 if(global_settings.talk_filetype)
1170 talk_id(VOICE_DIR, true);
1171 return 1;
1173 else
1174 return -1;
1177 static void ft_play_filename(char *dir, char *file)
1179 #if CONFIG_CODEC != SWCODEC
1180 if (audio_status() & AUDIO_STATUS_PLAY)
1181 return;
1182 #endif
1184 if (strlen(file) >= strlen(file_thumbnail_ext)
1185 && strcasecmp(&file[strlen(file) - strlen(file_thumbnail_ext)],
1186 file_thumbnail_ext))
1187 /* file has no .talk extension */
1188 talk_file(dir, NULL, file, file_thumbnail_ext,
1189 NULL, false);
1190 else
1191 /* it already is a .talk file, play this directly, but prefix it. */
1192 talk_file(dir, NULL, file, NULL,
1193 TALK_IDARRAY(LANG_VOICE_DIR_HOVER), false);
1196 /* These two functions are called by the USB and shutdown handlers */
1197 void tree_flush(void)
1199 #ifdef HAVE_TAGCACHE
1200 tagcache_shutdown();
1201 #endif
1203 #ifdef HAVE_TC_RAMCACHE
1204 tagcache_unload_ramcache();
1205 #endif
1207 #ifdef HAVE_DIRCACHE
1209 int old_val = global_status.dircache_size;
1210 if (global_settings.dircache)
1212 if (!dircache_is_initializing())
1213 global_status.dircache_size = dircache_get_cache_size();
1214 # ifdef HAVE_EEPROM_SETTINGS
1215 if (firmware_settings.initialized)
1216 dircache_save();
1217 # endif
1218 dircache_suspend();
1220 else
1222 global_status.dircache_size = 0;
1224 if (old_val != global_status.dircache_size)
1225 status_save();
1227 #endif
1230 void tree_restore(void)
1232 #ifdef HAVE_EEPROM_SETTINGS
1233 firmware_settings.disk_clean = false;
1234 #endif
1236 #ifdef HAVE_TC_RAMCACHE
1237 remove(TAGCACHE_STATEFILE);
1238 #endif
1240 #ifdef HAVE_DIRCACHE
1241 remove(DIRCACHE_FILE);
1242 if (global_settings.dircache)
1244 /* Print "Scanning disk..." to the display. */
1245 splash(0, str(LANG_SCANNING_DISK));
1247 dircache_build(global_status.dircache_size);
1249 #endif
1250 #ifdef HAVE_TAGCACHE
1251 tagcache_start_scan();
1252 #endif