bool folder_select(char* setting, int setting_len)
{
struct folder *root;
struct simplelist_info info;
size_t buf_size;
/* 32 separate folders should be Enough For Everybody(TM) */
char *vect[32];
char copy[setting_len];
int nb_items;
/* copy onto stack as split_string() modifies it */
strlcpy(copy, setting, setting_len);
nb_items = split_string(copy, ':', vect, ARRAYLEN(vect));
buffer_front = plugin_get_buffer(&buf_size);
buffer_end = buffer_front + buf_size;
root = load_root();
if (nb_items > 0)
{
for(int i = 0; i < nb_items; i++)
select_paths(root, vect[i]);
}
simplelist_info_init(&info, str(LANG_SELECT_FOLDER),
count_items(root), root);
info.get_name = folder_get_name;
info.action_callback = folder_action_callback;
info.get_icon = folder_get_icon;
simplelist_show_list(&info);
/* done editing. check for changes */
save_folders(root, copy, setting_len);
if (strcmp(copy, setting))
{ /* prompt for saving changes and commit if yes */
if (yesno_pop(ID2P(LANG_SAVE_CHANGES)))
{
strcpy(setting, copy);
settings_save();
return true;
}
}
return false;
}
void radio_screen(void)
{
bool done = false;
int button;
bool stereo = false, last_stereo = false;
int update_type = 0;
bool screen_freeze = false;
bool keep_playing = false;
bool talk = false;
#ifdef FM_RECORD_DBLPRE
int lastbutton = BUTTON_NONE;
unsigned long rec_lastclick = 0;
#endif
#if CONFIG_CODEC != SWCODEC
int timeout = current_tick + HZ/10;
#if !defined(SIMULATOR)
unsigned int last_seconds = 0;
unsigned int seconds = 0;
struct audio_recording_options rec_options;
#endif /* SIMULATOR */
#endif /* CONFIG_CODEC != SWCODEC */
#ifndef HAVE_NOISY_IDLE_MODE
int button_timeout = current_tick + (2*HZ);
#endif
/* change status to "in screen" */
push_current_activity(ACTIVITY_FM);
in_screen = true;
if(radio_preset_count() <= 0)
{
radio_load_presets(global_settings.fmr_file);
}
skin_get_global_state()->id3 = NULL;
#ifdef HAVE_ALBUMART
radioart_init(true);
#endif
if(radio_status == FMRADIO_OFF)
audio_stop();
fms_fix_displays(FMS_ENTER);
#ifndef SIMULATOR
#if CONFIG_CODEC != SWCODEC
rec_create_directory();
audio_init_recording();
sound_settings_apply();
/* Yes, we use the D/A for monitoring */
peak_meter_playback(true);
peak_meter_enable(true);
rec_init_recording_options(&rec_options);
rec_options.rec_source = AUDIO_SRC_LINEIN;
rec_set_recording_options(&rec_options);
audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
sound_default(SOUND_RIGHT_GAIN), AUDIO_GAIN_LINEIN);
#endif /* CONFIG_CODEC != SWCODEC */
#endif /* ndef SIMULATOR */
/* turn on radio */
#if CONFIG_CODEC == SWCODEC
/* This should be done before touching audio settings */
while (!pcm_is_initialized())
sleep(0);
audio_set_input_source(AUDIO_SRC_FMRADIO,
(radio_status == FMRADIO_PAUSED) ?
SRCF_FMRADIO_PAUSED : SRCF_FMRADIO_PLAYING);
#else
if (radio_status == FMRADIO_OFF)
radio_start();
#endif
if(radio_preset_count() < 1 && yesno_pop(ID2P(LANG_FM_FIRST_AUTOSCAN)))
presets_scan(NULL);
preset_set_current(preset_find(curr_freq));
if(radio_current_preset() != -1)
radio_mode = RADIO_PRESET_MODE;
/* Load/update the skin at last, when fully initialzed, so that it can
* display the right content from the beginning */
FOR_NB_SCREENS(i)
skin_update(FM_SCREEN, i, SKIN_REFRESH_ALL);
#ifndef HAVE_NOISY_IDLE_MODE
cpu_idle_mode(true);
#endif
while(!done)
{
if(search_dir != 0)
{
curr_freq = step_freq(curr_freq, search_dir);
update_type = SKIN_REFRESH_ALL;
if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
{
preset_set_current(preset_find(curr_freq));
remember_frequency();
end_search();
talk = true;
}
trigger_cpu_boost();
}
if (!update_type)
{
cancel_cpu_boost();
}
button = fms_do_button_loop(update_type>0);
#ifndef HAVE_NOISY_IDLE_MODE
if (button != ACTION_NONE)
{
cpu_idle_mode(false);
button_timeout = current_tick + (2*HZ);
}
#endif
switch(button)
{
case ACTION_FM_STOP:
#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
if(audio_status() == AUDIO_STATUS_RECORD)
{
audio_stop();
}
else
#endif
{
done = true;
if(presets_have_changed())
{
if(yesno_pop(ID2P(LANG_SAVE_CHANGES)))
{
presets_save();
}
}
}
update_type = SKIN_REFRESH_NON_STATIC;
break;
#ifdef FM_RECORD
case ACTION_FM_RECORD:
#ifdef FM_RECORD_DBLPRE
if (lastbutton != ACTION_FM_RECORD_DBLPRE)
{
rec_lastclick = 0;
break;
}
if (current_tick - rec_lastclick > HZ/2)
{
rec_lastclick = current_tick;
break;
}
#endif /* FM_RECORD_DBLPRE */
#ifndef SIMULATOR
if(audio_status() == AUDIO_STATUS_RECORD)
{
rec_command(RECORDING_CMD_START_NEWFILE);
update_type = SKIN_REFRESH_ALL;
}
else
{
rec_command(RECORDING_CMD_START);
update_type = SKIN_REFRESH_ALL;
}
#if CONFIG_CODEC != SWCODEC
last_seconds = 0;
#endif
#endif /* SIMULATOR */
break;
#endif /* #ifdef FM_RECORD */
case ACTION_FM_EXIT:
#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
if(audio_status() == AUDIO_STATUS_RECORD)
audio_stop();
#endif
keep_playing = true;
done = true;
if(presets_have_changed())
{
if(yesno_pop(ID2P(LANG_SAVE_CHANGES)))
{
presets_save();
}
}
break;
case ACTION_STD_PREV:
case ACTION_STD_NEXT:
next_station(button == ACTION_STD_PREV ? -1 : 1);
end_search();
update_type = SKIN_REFRESH_ALL;
talk = true;
break;
case ACTION_STD_PREVREPEAT:
case ACTION_STD_NEXTREPEAT:
{
int dir = search_dir;
search_dir = button == ACTION_STD_PREVREPEAT ? -1 : 1;
if (radio_mode != RADIO_SCAN_MODE)
{
preset_next(search_dir);
end_search();
talk = true;
}
else if (dir == 0)
{
/* Starting auto scan */
tuner_set(RADIO_MUTE, 1);
}
update_type = SKIN_REFRESH_ALL;
break;
}
case ACTION_SETTINGS_INC:
case ACTION_SETTINGS_INCREPEAT:
global_settings.volume++;
setvol();
update_type = SKIN_REFRESH_NON_STATIC;
break;
case ACTION_SETTINGS_DEC:
case ACTION_SETTINGS_DECREPEAT:
global_settings.volume--;
setvol();
update_type = SKIN_REFRESH_NON_STATIC;
break;
case ACTION_FM_PLAY:
if (radio_status == FMRADIO_PLAYING)
radio_pause();
else
radio_start();
update_type = SKIN_REFRESH_NON_STATIC;
talk = false;
talk_shutup();
break;
case ACTION_FM_MENU:
fms_fix_displays(FMS_EXIT);
do_menu(&radio_settings_menu, NULL, NULL, false);
preset_set_current(preset_find(curr_freq));
fms_fix_displays(FMS_ENTER);
update_type = SKIN_REFRESH_ALL;
break;
#ifdef FM_PRESET
case ACTION_FM_PRESET:
if(radio_preset_count() < 1)
{
splash(HZ, ID2P(LANG_FM_NO_PRESETS));
update_type = SKIN_REFRESH_ALL;
break;
}
fms_fix_displays(FMS_EXIT);
handle_radio_presets();
fms_fix_displays(FMS_ENTER);
update_type = SKIN_REFRESH_ALL;
break;
#endif /* FM_PRESET */
#ifdef FM_FREEZE
case ACTION_FM_FREEZE:
if(!screen_freeze)
{
splash(HZ, str(LANG_FM_FREEZE));
screen_freeze = true;
}
else
{
update_type = SKIN_REFRESH_ALL;
screen_freeze = false;
}
break;
#endif /* FM_FREEZE */
case SYS_USB_CONNECTED:
#if CONFIG_CODEC != SWCODEC
/* Only accept USB connection when not recording */
if(audio_status() != AUDIO_STATUS_RECORD)
#endif
{
default_event_handler(SYS_USB_CONNECTED);
screen_freeze = true; /* Cosmetic: makes sure the
radio screen doesn't redraw */
done = true;
}
break;
#ifdef FM_MODE
case ACTION_FM_MODE:
if(radio_mode == RADIO_SCAN_MODE)
{
/* Force scan mode if there are no presets. */
if(radio_preset_count() > 0)
radio_mode = RADIO_PRESET_MODE;
}
else
radio_mode = RADIO_SCAN_MODE;
update_type = SKIN_REFRESH_ALL;
cond_talk_ids_fq(radio_mode ?
LANG_PRESET : LANG_RADIO_SCAN_MODE);
talk = true;
break;
#endif /* FM_MODE */
#ifdef FM_NEXT_PRESET
case ACTION_FM_NEXT_PRESET:
preset_next(1);
end_search();
update_type = SKIN_REFRESH_ALL;
talk = true;
break;
#endif
#ifdef FM_PREV_PRESET
case ACTION_FM_PREV_PRESET:
preset_next(-1);
end_search();
update_type = SKIN_REFRESH_ALL;
talk = true;
break;
#endif
case ACTION_NONE:
update_type = SKIN_REFRESH_NON_STATIC;
break;
/* this case is used by the softlock feature
* it requests a full update here */
case ACTION_REDRAW:
skin_request_full_update(FM_SCREEN);
break;
default:
default_event_handler(button);
#ifdef HAVE_RDS_CAP
if (tuner_get(RADIO_EVENT))
update_type = SKIN_REFRESH_ALL;
#endif
if (!tuner_get(RADIO_PRESENT))
{
#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
if(audio_status() == AUDIO_STATUS_RECORD)
audio_stop();
#endif
keep_playing = false;
done = true;
if(presets_have_changed())
{
if(yesno_pop(ID2P(LANG_SAVE_CHANGES)))
{
radio_save_presets();
}
}
/* Clear the preset list on exit. */
preset_list_clear();
}
break;
} /*switch(button)*/
#ifdef FM_RECORD_DBLPRE
if (button != ACTION_NONE)
lastbutton = button;
#endif
#if CONFIG_CODEC != SWCODEC
peak_meter_peek();
#endif
if(!screen_freeze)
{
/* Only display the peak meter when not recording */
#if CONFIG_CODEC != SWCODEC
if(TIME_AFTER(current_tick, timeout))
{
timeout = current_tick + HZ;
#else /* SWCODEC */
{
#endif /* CONFIG_CODEC == SWCODEC */
/* keep "mono" from always being displayed when paused */
if (radio_status != FMRADIO_PAUSED)
{
stereo = tuner_get(RADIO_STEREO) &&
!global_settings.fm_force_mono;
if(stereo != last_stereo)
{
update_type = SKIN_REFRESH_ALL;
last_stereo = stereo;
}
}
}
#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
seconds = audio_recorded_time() / HZ;
if (update_type || seconds > last_seconds)
{
last_seconds = seconds;
#else
if (update_type)
{
#endif
FOR_NB_SCREENS(i)
skin_update(FM_SCREEN, i, update_type);
if (update_type == (int)SKIN_REFRESH_ALL)
skin_request_full_update(CUSTOM_STATUSBAR);
}
}
update_type = 0;
if (global_settings.talk_file && talk
&& radio_status == FMRADIO_PAUSED)
{
talk = false;
bool enqueue = false;
if (radio_mode == RADIO_SCAN_MODE)
{
talk_value_decimal(curr_freq, UNIT_INT, 6, enqueue);
enqueue = true;
}
if (radio_current_preset() >= 0)
preset_talk(radio_current_preset(), radio_mode == RADIO_PRESET_MODE,
enqueue);
}
#if CONFIG_CODEC != SWCODEC
if(audio_status() & AUDIO_STATUS_ERROR)
{
done = true;
}
#endif
#ifndef HAVE_NOISY_IDLE_MODE
if (TIME_AFTER(current_tick, button_timeout))
{
cpu_idle_mode(true);
}
#endif
} /*while(!done)*/
#ifndef SIMULATOR
#if CONFIG_CODEC != SWCODEC
if(audio_status() & AUDIO_STATUS_ERROR)
{
splash(0, str(LANG_DISK_FULL));
audio_error_clear();
while(1)
{
button = get_action(CONTEXT_FM|ALLOW_SOFTLOCK, TIMEOUT_BLOCK);
if(button == ACTION_FM_STOP)
break;
}
}
audio_init_playback();
#endif /* CONFIG_CODEC != SWCODEC */
sound_settings_apply();
#endif /* SIMULATOR */
if(keep_playing)
{
/* Catch FMRADIO_PLAYING status for the sim. */
#ifndef SIMULATOR
#if CONFIG_CODEC != SWCODEC
/* Enable the Left and right A/D Converter */
audio_set_recording_gain(sound_default(SOUND_LEFT_GAIN),
sound_default(SOUND_RIGHT_GAIN),
AUDIO_GAIN_LINEIN);
mas_codec_writereg(6, 0x4000);
#endif
end_search();
#endif /* SIMULATOR */
}
else
{
#if CONFIG_CODEC == SWCODEC
audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
#else
radio_stop();
#endif
}
#ifndef HAVE_NOISY_IDLE_MODE
cpu_idle_mode(false);
#endif
fms_fix_displays(FMS_EXIT);
pop_current_activity();
in_screen = false;
} /* radio_screen */
void toggle_mono_mode(bool mono)
{
tuner_set(RADIO_FORCE_MONO, mono);
}
void set_radio_region(int region)
{
#ifdef HAVE_RADIO_REGION
tuner_set(RADIO_REGION, region);
#endif
next_station(0);
remember_frequency();
(void)region;
}
/* Main viewer function. Filename identifies playlist to be viewed. If NULL,
view current playlist. */
enum playlist_viewer_result playlist_viewer_ex(const char* filename)
{
enum playlist_viewer_result ret = PLAYLIST_VIEWER_OK;
bool exit = false; /* exit viewer */
int button;
bool dirty = false;
struct gui_synclist playlist_lists;
if (!playlist_viewer_init(&viewer, filename, false))
goto exit;
push_current_activity(ACTIVITY_PLAYLISTVIEWER);
gui_synclist_init(&playlist_lists, playlist_callback_name,
&viewer, false, 1, NULL);
gui_synclist_set_voice_callback(&playlist_lists, playlist_callback_voice);
gui_synclist_set_icon_callback(&playlist_lists,
global_settings.playlist_viewer_icons?
&playlist_callback_icons:NULL);
gui_synclist_set_nb_items(&playlist_lists, viewer.num_tracks);
gui_synclist_set_title(&playlist_lists, str(LANG_PLAYLIST), Icon_Playlist);
gui_synclist_select_item(&playlist_lists, viewer.selected_track);
gui_synclist_draw(&playlist_lists);
gui_synclist_speak_item(&playlist_lists);
while (!exit)
{
int track;
if (global_status.resume_index != -1 && !viewer.playlist)
playlist_get_resume_info(&track);
else
track = -1;
if (track != viewer.current_playing_track ||
playlist_amount_ex(viewer.playlist) != viewer.num_tracks)
{
/* Playlist has changed (new track started?) */
if (!update_playlist(false))
goto exit;
/*Needed because update_playlist gives wrong value when
playing is stopped*/
viewer.current_playing_track = track;
gui_synclist_set_nb_items(&playlist_lists, viewer.num_tracks);
gui_synclist_draw(&playlist_lists);
}
/* Timeout so we can determine if play status has changed */
bool res = list_do_action(CONTEXT_TREE, HZ/2,
&playlist_lists, &button, LIST_WRAP_UNLESS_HELD);
/* during moving, another redraw is going to be needed,
* since viewer.selected_track is updated too late (after the first draw)
* drawing the moving item needs it */
viewer.selected_track=gui_synclist_get_sel_pos(&playlist_lists);
if (res)
{
bool reload = playlist_buffer_needs_reload(&viewer.buffer,
viewer.selected_track);
if (reload)
playlist_buffer_load_entries_screen(&viewer.buffer,
button == ACTION_STD_NEXT ? FORWARD : BACKWARD);
if (reload || viewer.moving_track >= 0)
gui_synclist_draw(&playlist_lists);
}
switch (button)
{
case ACTION_TREE_WPS:
case ACTION_STD_CANCEL:
{
if (viewer.moving_track >= 0)
{
viewer.selected_track = viewer.moving_track;
gui_synclist_select_item(&playlist_lists, viewer.moving_track);
viewer.moving_track = -1;
viewer.moving_playlist_index = -1;
gui_synclist_draw(&playlist_lists);
}
else
{
exit = true;
ret = PLAYLIST_VIEWER_CANCEL;
}
break;
}
case ACTION_STD_OK:
{
struct playlist_entry * current_track =
playlist_buffer_get_track(&viewer.buffer,
viewer.selected_track);
if (viewer.moving_track >= 0)
{
/* Move track */
int ret_val;
ret_val = playlist_move(viewer.playlist,
viewer.moving_playlist_index,
current_track->index);
if (ret_val < 0)
splashf(HZ, (unsigned char *)"%s %s", str(LANG_MOVE),
str(LANG_FAILED));
update_playlist(true);
viewer.moving_track = -1;
viewer.moving_playlist_index = -1;
dirty = true;
}
else if (!viewer.playlist)
{
/* play new track */
if (!global_settings.party_mode)
{
playlist_start(current_track->index, 0);
update_playlist(false);
}
}
else if (!global_settings.party_mode)
{
int start_index = current_track->index;
if (!warn_on_pl_erase())
{
gui_synclist_draw(&playlist_lists);
break;
}
/* New playlist */
if (playlist_set_current(viewer.playlist) < 0)
goto exit;
if (global_settings.playlist_shuffle)
start_index = playlist_shuffle(current_tick, start_index);
playlist_start(start_index, 0);
/* Our playlist is now the current list */
if (!playlist_viewer_init(&viewer, NULL, true))
goto exit;
exit = true;
}
gui_synclist_draw(&playlist_lists);
break;
}
case ACTION_STD_CONTEXT:
{
/* ON+PLAY menu */
int ret_val;
ret_val = onplay_menu(viewer.selected_track);
if (ret_val < 0)
{
ret = PLAYLIST_VIEWER_USB;
goto exit;
}
else if (ret_val > 0)
{
/* Playlist changed */
gui_synclist_del_item(&playlist_lists);
update_playlist(true);
if (viewer.num_tracks <= 0)
exit = true;
if (viewer.selected_track >= viewer.num_tracks)
viewer.selected_track = viewer.num_tracks-1;
dirty = true;
}
gui_synclist_draw(&playlist_lists);
break;
}
case ACTION_STD_MENU:
ret = PLAYLIST_VIEWER_MAINMENU;
goto exit;
default:
if(default_event_handler(button) == SYS_USB_CONNECTED)
{
ret = PLAYLIST_VIEWER_USB;
goto exit;
}
break;
}
}
exit:
pop_current_activity();
if (viewer.playlist)
{
if(dirty && yesno_pop(ID2P(LANG_SAVE_CHANGES)))
save_playlist_screen(viewer.playlist);
playlist_close(viewer.playlist);
}
return ret;
}
