woopsies
[kugel-rb.git] / apps / filetree.c
blob460ab9e4536d2500ee48a169b63df093afaae158
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2005 by Björn 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 <stdlib.h>
22 #include <file.h>
23 #include <dir.h>
24 #include <string.h>
25 #include <kernel.h>
26 #include <lcd.h>
27 #include <debug.h>
28 #include <font.h>
29 #include <limits.h>
30 #include "bookmark.h"
31 #include "tree.h"
32 #include "settings.h"
33 #include "filetypes.h"
34 #include "talk.h"
35 #include "playlist.h"
36 #include "lang.h"
37 #include "language.h"
38 #include "screens.h"
39 #include "plugin.h"
40 #include "rolo.h"
41 #include "splash.h"
42 #include "cuesheet.h"
43 #include "filetree.h"
44 #include "misc.h"
45 #include "strnatcmp.h"
46 #ifdef HAVE_LCD_BITMAP
47 #include "keyboard.h"
48 #endif
50 #if CONFIG_TUNER
51 #include "radio.h"
52 #endif
53 #include "wps.h"
55 static int compare_sort_dir; /* qsort key for sorting directories */
57 int ft_build_playlist(struct tree_context* c, int start_index)
59 int i;
60 int start=start_index;
62 struct entry *dircache = c->dircache;
64 for(i = 0;i < c->filesindir;i++)
66 if((dircache[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
68 if (playlist_add(dircache[i].name) < 0)
69 break;
71 else
73 /* Adjust the start index when se skip non-MP3 entries */
74 if(i < start)
75 start_index--;
79 return start_index;
82 /* Start playback of a playlist, checking for bookmark autoload, modified
83 * playlists, etc., as required. Returns false if playback wasn't started,
84 * or started via bookmark autoload, true otherwise.
86 * Pointers to both the full pathname and the separated parts needed to
87 * avoid allocating yet another path buffer on the stack (and save some
88 * code; the caller typically needs to create the full pathname anyway)...
90 bool ft_play_playlist(char* pathname, char* dirname, char* filename)
92 if (global_settings.party_mode && audio_status())
94 splash(HZ, ID2P(LANG_PARTY_MODE));
95 return false;
98 if (bookmark_autoload(pathname))
100 return false;
103 splash(0, ID2P(LANG_WAIT));
105 /* about to create a new current playlist...
106 allow user to cancel the operation */
107 if (!warn_on_pl_erase())
108 return false;
110 if (playlist_create(dirname, filename) != -1)
112 if (global_settings.playlist_shuffle)
114 playlist_shuffle(current_tick, -1);
117 playlist_start(0, 0);
118 return true;
121 return false;
124 /* walk a directory and check all dircache entries if a .talk file exists */
125 static void check_file_thumbnails(struct tree_context* c)
127 int i;
128 struct dirent *entry;
129 struct entry* dircache = c->dircache;
130 DIR *dir;
132 dir = opendir(c->currdir);
133 if(!dir)
134 return;
135 /* mark all files as non talking, except the .talk ones */
136 for (i=0; i < c->filesindir; i++)
138 if (dircache[i].attr & ATTR_DIRECTORY)
139 continue; /* we're not touching directories */
141 if (strcasecmp(file_thumbnail_ext,
142 &dircache[i].name[strlen(dircache[i].name)
143 - strlen(file_thumbnail_ext)]))
144 { /* no .talk file */
145 dircache[i].attr &= ~FILE_ATTR_THUMBNAIL; /* clear */
147 else
148 { /* .talk file, we later let them speak themselves */
149 dircache[i].attr |= FILE_ATTR_THUMBNAIL; /* set */
153 while((entry = readdir(dir)) != 0) /* walk directory */
155 int ext_pos;
157 ext_pos = strlen((char *)entry->d_name) - strlen(file_thumbnail_ext);
158 if (ext_pos <= 0 /* too short to carry ".talk" */
159 || (entry->attribute & ATTR_DIRECTORY) /* no file */
160 || strcasecmp((char *)&entry->d_name[ext_pos], file_thumbnail_ext))
161 { /* or doesn't end with ".talk", no candidate */
162 continue;
165 /* terminate the (disposable) name in dir buffer,
166 this truncates off the ".talk" without needing an extra buffer */
167 entry->d_name[ext_pos] = '\0';
169 /* search corresponding file in dir cache */
170 for (i=0; i < c->filesindir; i++)
172 if (!strcasecmp(dircache[i].name, (char *)entry->d_name))
173 { /* match */
174 dircache[i].attr |= FILE_ATTR_THUMBNAIL; /* set the flag */
175 break; /* exit search loop, because we found it */
179 closedir(dir);
182 /* support function for qsort() */
183 static int compare(const void* p1, const void* p2)
185 struct entry* e1 = (struct entry*)p1;
186 struct entry* e2 = (struct entry*)p2;
187 int criteria;
189 if (e1->attr & ATTR_DIRECTORY && e2->attr & ATTR_DIRECTORY)
190 { /* two directories */
191 criteria = compare_sort_dir;
193 #ifdef HAVE_MULTIVOLUME
194 if (e1->attr & ATTR_VOLUME || e2->attr & ATTR_VOLUME)
195 { /* a volume identifier is involved */
196 if (e1->attr & ATTR_VOLUME && e2->attr & ATTR_VOLUME)
197 criteria = SORT_ALPHA; /* two volumes: sort alphabetically */
198 else /* only one is a volume: volume first */
199 return (e2->attr & ATTR_VOLUME) - (e1->attr & ATTR_VOLUME);
201 #endif
204 else if (!(e1->attr & ATTR_DIRECTORY) && !(e2->attr & ATTR_DIRECTORY))
205 { /* two files */
206 criteria = global_settings.sort_file;
208 else /* dir and file, dir goes first */
209 return (e2->attr & ATTR_DIRECTORY) - (e1->attr & ATTR_DIRECTORY);
211 switch(criteria)
213 case SORT_TYPE:
214 case SORT_TYPE_REVERSED:
216 int t1 = e1->attr & FILE_ATTR_MASK;
217 int t2 = e2->attr & FILE_ATTR_MASK;
219 if (!t1) /* unknown type */
220 t1 = INT_MAX; /* gets a high number, to sort after known */
221 if (!t2) /* unknown type */
222 t2 = INT_MAX; /* gets a high number, to sort after known */
224 if (t1 != t2) /* if different */
225 return (t1 - t2) * (criteria == SORT_TYPE_REVERSED ? -1 : 1);
226 /* else fall through to alphabetical sorting */
229 case SORT_DATE:
230 case SORT_DATE_REVERSED:
231 /* Ignore SORT_TYPE */
232 if (criteria == SORT_DATE || criteria == SORT_DATE_REVERSED)
234 if (e1->time_write != e2->time_write)
235 return (e1->time_write - e2->time_write)
236 * (criteria == SORT_DATE_REVERSED ? -1 : 1);
237 /* else fall through to alphabetical sorting */
240 case SORT_ALPHA:
241 case SORT_ALPHA_REVERSED:
243 if (global_settings.sort_case)
245 if (global_settings.interpret_numbers == SORT_INTERPRET_AS_NUMBER)
246 return strnatcmp(e1->name, e2->name)
247 * (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
248 else
249 return strncmp(e1->name, e2->name, MAX_PATH)
250 * (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
252 else
254 if (global_settings.interpret_numbers == SORT_INTERPRET_AS_NUMBER)
255 return strnatcasecmp(e1->name, e2->name)
256 * (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
257 else
258 return strncasecmp(e1->name, e2->name, MAX_PATH)
259 * (criteria == SORT_ALPHA_REVERSED ? -1 : 1);
264 return 0; /* never reached */
267 /* load and sort directory into dircache. returns NULL on failure. */
268 int ft_load(struct tree_context* c, const char* tempdir)
270 int i;
271 int name_buffer_used = 0;
272 DIR *dir;
274 if (tempdir)
275 dir = opendir(tempdir);
276 else
277 dir = opendir(c->currdir);
278 if(!dir)
279 return -1; /* not a directory */
281 c->dirsindir = 0;
282 c->dirfull = false;
284 for ( i=0; i < global_settings.max_files_in_dir; i++ ) {
285 int len;
286 struct dirent *entry = readdir(dir);
287 struct entry* dptr =
288 (struct entry*)(c->dircache + i * sizeof(struct entry));
289 if (!entry)
290 break;
292 len = strlen((char *)entry->d_name);
294 /* skip directories . and .. */
295 if ((entry->attribute & ATTR_DIRECTORY) &&
296 (((len == 1) && (!strncmp((char *)entry->d_name, ".", 1))) ||
297 ((len == 2) && (!strncmp((char *)entry->d_name, "..", 2))))) {
298 i--;
299 continue;
302 /* Skip FAT volume ID */
303 if (entry->attribute & ATTR_VOLUME_ID) {
304 i--;
305 continue;
308 /* filter out dotfiles and hidden files */
309 if (*c->dirfilter != SHOW_ALL &&
310 ((entry->d_name[0]=='.') ||
311 (entry->attribute & ATTR_HIDDEN))) {
312 i--;
313 continue;
316 dptr->attr = entry->attribute;
318 /* check for known file types */
319 if ( !(dptr->attr & ATTR_DIRECTORY) )
320 dptr->attr |= filetype_get_attr((char *)entry->d_name);
322 /* filter out non-visible files */
323 if ((!(dptr->attr & ATTR_DIRECTORY) && (
324 (*c->dirfilter == SHOW_PLAYLIST &&
325 (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_M3U) ||
326 ((*c->dirfilter == SHOW_MUSIC &&
327 (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_AUDIO) &&
328 (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_M3U) ||
329 (*c->dirfilter == SHOW_SUPPORTED && !filetype_supported(dptr->attr)))) ||
330 (*c->dirfilter == SHOW_WPS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_WPS) ||
331 #ifdef HAVE_LCD_BITMAP
332 (*c->dirfilter == SHOW_FONT && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_FONT) ||
333 (*c->dirfilter == SHOW_SBS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_SBS) ||
334 #if CONFIG_TUNER
335 (*c->dirfilter == SHOW_FMS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_FMS) ||
336 #endif
337 #endif
338 #ifdef HAVE_REMOTE_LCD
339 (*c->dirfilter == SHOW_RWPS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_RWPS) ||
340 (*c->dirfilter == SHOW_RSBS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_RSBS) ||
341 #if CONFIG_TUNER
342 (*c->dirfilter == SHOW_RFMS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_RFMS) ||
343 #endif
344 #endif
345 #if CONFIG_TUNER
346 (*c->dirfilter == SHOW_FMR && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_FMR) ||
347 #endif
348 (*c->dirfilter == SHOW_CFG && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_CFG) ||
349 (*c->dirfilter == SHOW_LNG && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_LNG) ||
350 (*c->dirfilter == SHOW_MOD && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_MOD) ||
351 (*c->dirfilter == SHOW_PLUGINS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_ROCK &&
352 (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_LUA))
354 i--;
355 continue;
358 if (len > c->name_buffer_size - name_buffer_used - 1) {
359 /* Tell the world that we ran out of buffer space */
360 c->dirfull = true;
361 break;
363 dptr->name = &c->name_buffer[name_buffer_used];
364 dptr->time_write =
365 (long)entry->wrtdate<<16 |
366 (long)entry->wrttime; /* in one # */
367 strcpy(dptr->name, (char *)entry->d_name);
368 name_buffer_used += len + 1;
370 if (dptr->attr & ATTR_DIRECTORY) /* count the remaining dirs */
371 c->dirsindir++;
373 c->filesindir = i;
374 c->dirlength = i;
375 closedir(dir);
377 compare_sort_dir = c->sort_dir;
378 qsort(c->dircache,i,sizeof(struct entry),compare);
380 /* If thumbnail talking is enabled, make an extra run to mark files with
381 associated thumbnails, so we don't do unsuccessful spinups later. */
382 if (global_settings.talk_file_clip)
383 check_file_thumbnails(c); /* map .talk to ours */
385 return 0;
387 #ifdef HAVE_LCD_BITMAP
388 static void ft_load_font(char *file)
390 #if NB_SCREENS > 1
391 MENUITEM_STRINGLIST(menu, ID2P(LANG_CUSTOM_FONT), NULL,
392 ID2P(LANG_MAIN_SCREEN), ID2P(LANG_REMOTE_SCREEN))
393 switch (do_menu(&menu, NULL, NULL, false))
395 case 0: /* main lcd */
396 splash(0, ID2P(LANG_WAIT));
397 font_load(NULL, file);
398 set_file(file, (char *)global_settings.font_file, MAX_FILENAME);
399 break;
400 case 1: /* remote */
401 splash(0, ID2P(LANG_WAIT));
402 font_load_remoteui(file);
403 set_file(file, (char *)global_settings.remote_font_file, MAX_FILENAME);
404 break;
406 #else
407 splash(0, ID2P(LANG_WAIT));
408 font_load(NULL, file);
409 set_file(file, (char *)global_settings.font_file, MAX_FILENAME);
410 #endif
412 #endif
414 int ft_enter(struct tree_context* c)
416 int rc = 0;
417 char buf[MAX_PATH];
418 struct entry *dircache = c->dircache;
419 struct entry* file = &dircache[c->selected_item];
420 bool reload_dir = false;
421 bool start_wps = false;
422 bool exit_func = false;
424 if (c->currdir[1])
425 snprintf(buf,sizeof(buf),"%s/%s",c->currdir, file->name);
426 else
427 snprintf(buf,sizeof(buf),"/%s",file->name);
429 if (file->attr & ATTR_DIRECTORY) {
430 memcpy(c->currdir, buf, sizeof(c->currdir));
431 if ( c->dirlevel < MAX_DIR_LEVELS )
432 c->selected_item_history[c->dirlevel] = c->selected_item;
433 c->dirlevel++;
434 c->selected_item=0;
436 else {
437 int seed = current_tick;
438 bool play = false;
439 int start_index=0;
441 switch ( file->attr & FILE_ATTR_MASK ) {
442 case FILE_ATTR_M3U:
443 play = ft_play_playlist(buf, c->currdir, file->name);
445 if (play)
447 start_index = 0;
450 break;
452 case FILE_ATTR_AUDIO:
453 if (bookmark_autoload(c->currdir))
454 break;
456 splash(0, ID2P(LANG_WAIT));
458 /* about to create a new current playlist...
459 allow user to cancel the operation */
460 if (!warn_on_pl_erase())
461 break;
463 if (global_settings.party_mode && audio_status())
465 playlist_insert_track(NULL, buf,
466 PLAYLIST_INSERT_LAST, true, true);
467 splash(HZ, ID2P(LANG_QUEUE_LAST));
469 else if (playlist_create(c->currdir, NULL) != -1)
471 start_index = ft_build_playlist(c, c->selected_item);
472 if (global_settings.playlist_shuffle)
474 start_index = playlist_shuffle(seed, start_index);
476 /* when shuffling dir.: play all files
477 even if the file selected by user is
478 not the first one */
479 if (!global_settings.play_selected)
480 start_index = 0;
483 playlist_start(start_index, 0);
484 play = true;
486 break;
488 #if CONFIG_TUNER
489 /* fmr preset file */
490 case FILE_ATTR_FMR:
491 splash(0, ID2P(LANG_WAIT));
493 /* Preset inside the default folder. */
494 if(!strncasecmp(FMPRESET_PATH, buf, strlen(FMPRESET_PATH)))
496 set_file(buf, global_settings.fmr_file, MAX_FILENAME);
497 radio_load_presets(global_settings.fmr_file);
498 if(!in_radio_screen())
499 radio_screen();
502 * Preset outside default folder, we can choose such only
503 * if we are out of the radio screen, so the check for the
504 * radio status isn't neccessary
506 else
508 radio_load_presets(buf);
509 radio_screen();
512 break;
513 case FILE_ATTR_FMS:
514 splash(0, ID2P(LANG_WAIT));
515 set_file(buf, (char *)global_settings.fms_file, MAX_FILENAME);
516 settings_apply_skins();
517 break;
518 #ifdef HAVE_REMOTE_LCD
519 case FILE_ATTR_RFMS:
520 splash(0, ID2P(LANG_WAIT));
521 set_file(buf, (char *)global_settings.rfms_file, MAX_FILENAME);
522 settings_apply_skins();
523 break;
524 #endif
525 #endif
527 #ifdef HAVE_LCD_BITMAP
528 case FILE_ATTR_SBS:
529 splash(0, ID2P(LANG_WAIT));
530 set_file(buf, (char *)global_settings.sbs_file, MAX_FILENAME);
531 settings_apply_skins();
532 break;
533 #endif
534 #ifdef HAVE_REMOTE_LCD
535 case FILE_ATTR_RSBS:
536 splash(0, ID2P(LANG_WAIT));
537 set_file(buf, (char *)global_settings.rsbs_file, MAX_FILENAME);
538 settings_apply_skins();
539 break;
540 #endif
541 /* wps config file */
542 case FILE_ATTR_WPS:
543 splash(0, ID2P(LANG_WAIT));
544 set_file(buf, (char *)global_settings.wps_file,
545 MAX_FILENAME);
546 settings_apply_skins();
547 break;
549 #if defined(HAVE_REMOTE_LCD) && (NB_SCREENS > 1)
550 /* remote-wps config file */
551 case FILE_ATTR_RWPS:
552 splash(0, ID2P(LANG_WAIT));
553 set_file(buf, (char *)global_settings.rwps_file,
554 MAX_FILENAME);
555 settings_apply_skins();
556 break;
557 #endif
559 case FILE_ATTR_CFG:
560 splash(0, ID2P(LANG_WAIT));
561 if (!settings_load_config(buf,true))
562 break;
563 splash(HZ, ID2P(LANG_SETTINGS_LOADED));
564 break;
566 case FILE_ATTR_BMARK:
567 splash(0, ID2P(LANG_WAIT));
568 bookmark_load(buf, false);
569 reload_dir = true;
570 break;
572 case FILE_ATTR_LNG:
573 splash(0, ID2P(LANG_WAIT));
574 if (lang_core_load(buf))
576 splash(HZ, ID2P(LANG_FAILED));
577 break;
579 set_file(buf, (char *)global_settings.lang_file,
580 MAX_FILENAME);
581 talk_init(); /* use voice of same language */
582 viewportmanager_theme_changed(THEME_LANGUAGE);
583 settings_apply_skins();
584 splash(HZ, ID2P(LANG_LANGUAGE_LOADED));
585 break;
587 #ifdef HAVE_LCD_BITMAP
588 case FILE_ATTR_FONT:
589 ft_load_font(buf);
590 break;
592 case FILE_ATTR_KBD:
593 splash(0, ID2P(LANG_WAIT));
594 if (!load_kbd(buf))
595 splash(HZ, ID2P(LANG_KEYBOARD_LOADED));
596 set_file(buf, (char *)global_settings.kbd_file, MAX_FILENAME);
597 break;
598 #endif
600 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
601 /* firmware file */
602 case FILE_ATTR_MOD:
603 splash(0, ID2P(LANG_WAIT));
604 rolo_load(buf);
605 break;
606 #endif
608 /* plugin file */
609 case FILE_ATTR_ROCK:
610 case FILE_ATTR_LUA:
612 char *plugin = buf, *argument = NULL;
613 int ret;
615 if ((file->attr & FILE_ATTR_MASK) == FILE_ATTR_LUA) {
616 plugin = VIEWERS_DIR "/lua.rock"; /* Use a #define here ? */
617 argument = buf;
620 if (global_settings.party_mode && audio_status()) {
621 splash(HZ, ID2P(LANG_PARTY_MODE));
622 break;
624 ret = plugin_load(plugin, argument);
625 switch (ret)
627 case PLUGIN_GOTO_WPS:
628 play = true;
629 break;
630 case PLUGIN_USB_CONNECTED:
631 if(*c->dirfilter > NUM_FILTER_MODES)
632 /* leave sub-browsers after usb, doing
633 otherwise might be confusing to the user */
634 exit_func = true;
635 else
636 reload_dir = true;
637 break;
639 case PLUGIN_ERROR:
640 case PLUGIN_OK:
642 default:
643 break;
645 break;
647 case FILE_ATTR_CUE:
648 display_cuesheet_content(buf);
649 break;
651 default:
653 const char* plugin;
655 if (global_settings.party_mode && audio_status()) {
656 splash(HZ, ID2P(LANG_PARTY_MODE));
657 break;
660 plugin = filetype_get_plugin(file);
661 if (plugin)
663 switch (plugin_load(plugin,buf))
665 case PLUGIN_USB_CONNECTED:
666 reload_dir = true;
667 break;
668 case PLUGIN_GOTO_WPS:
669 play = true;
670 break;
672 case PLUGIN_OK:
673 case PLUGIN_ERROR:
675 default:
676 break;
679 break;
683 if ( play ) {
684 /* the resume_index must always be the index in the
685 shuffled list in case shuffle is enabled */
686 global_status.resume_index = start_index;
687 global_status.resume_offset = 0;
688 status_save();
690 start_wps = true;
692 else {
693 if (*c->dirfilter > NUM_FILTER_MODES &&
694 *c->dirfilter != SHOW_CFG &&
695 *c->dirfilter != SHOW_FONT &&
696 *c->dirfilter != SHOW_PLUGINS)
698 exit_func = true;
703 if (reload_dir)
704 rc = 1;
705 if (start_wps)
706 rc = 2;
707 if (exit_func)
708 rc = 3;
710 return rc;
713 int ft_exit(struct tree_context* c)
715 extern char lastfile[]; /* from tree.c */
716 char buf[MAX_PATH];
717 int rc = 0;
718 bool exit_func = false;
720 int i = strlen(c->currdir);
721 if (i>1) {
722 while (c->currdir[i-1]!='/')
723 i--;
724 strcpy(buf,&c->currdir[i]);
725 if (i==1)
726 c->currdir[i]=0;
727 else
728 c->currdir[i-1]=0;
730 if (*c->dirfilter > NUM_FILTER_MODES && c->dirlevel < 1)
731 exit_func = true;
733 c->dirlevel--;
734 if ( c->dirlevel < MAX_DIR_LEVELS )
735 c->selected_item=c->selected_item_history[c->dirlevel];
736 else
737 c->selected_item=0;
739 /* if undefined position */
740 if (c->selected_item == -1)
741 strcpy(lastfile, buf);
743 else
745 if (*c->dirfilter > NUM_FILTER_MODES && c->dirlevel < 1)
746 exit_func = true;
749 if (exit_func)
750 rc = 3;
752 return rc;