static void preset_erase(char *title) { preset_t *item, *lag; /* Try to find the preset. If not found, do nothing */ item = preset_find(title, &lag); if (!item) return; /* Remove it from the list */ if (lag) lag->next = item->next; else preset_list = item->next; /* Free the preset's name and struct */ g_free(item->title); free(item); /* Adjust the item count */ preset_qty--; /* Save all presets except the one we just deleted. This is the only * way to delete a whole section from an XMMS config file. */ preset_write(NULL); /* Adjust the buttons */ preset_adjust(FALSE); }
/* Save the current configuration under a given title */ static void preset_save(char *title) { preset_t *item, *scan, *lag; char *s; /* If invalid title, then reject it */ for (s = title; isalnum(*s) || *s == ' ' || *s == '-' || *s == '.' || *s == '_'; s++) { } if (*s || !strcasecmp(title, random_name)) return; /* Try to find an existing preset with that name. */ item = preset_find(title, NULL); if (!item) { /* Not found! Create a new preset and add it to the list */ item = (preset_t *)malloc(sizeof(preset_t)); item->title = g_strdup(title); /* add this to the list of presets, keeping the * list sorted by title. */ for (scan = preset_list, lag = NULL; scan && strcmp(scan->title, item->title) < 0; lag = scan, scan = scan->next) { } item->next = scan; if (lag) lag->next = item; else preset_list = item; /* increment the number of presets */ preset_qty++; } /* Copy the new settings into the preset */ item->conf = config; /* Update the config file */ preset_write(item); /* Update the buttons */ preset_adjust(FALSE); }
/* Step to the next or previous station */ void next_station(int direction) { if (direction != 0 && radio_mode != RADIO_SCAN_MODE) { preset_next(direction); return; } curr_freq = step_freq(curr_freq, direction); if (radio_status == FMRADIO_PLAYING) tuner_set(RADIO_MUTE, 1); tuner_set(RADIO_FREQUENCY, curr_freq); if (radio_status == FMRADIO_PLAYING) tuner_set(RADIO_MUTE, 0); preset_set_current(preset_find(curr_freq)); remember_frequency(); }
/* Load the preset that has a given title */ static void preset_load(char *title) { preset_t *item; int i; /* Try to find a preset with that name. */ config.random_preset = FALSE; if (!strcasecmp(title, random_name)) { /* For "Random on quiet", randomly choose a preset */ i = preset_qty > 0 ? rand_0_to(preset_qty) : 0; for (item = preset_list; --i > 0; item = item->next) { } config.random_preset = TRUE; } else /* use the named preset */ item = preset_find(title, NULL); /* Load the preset (if it exists) */ if (item) config_load_preset(&item->conf); }
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; }
/* Adjust all buttons. Notice that this can be called from other modules! */ void preset_adjust(int keep_title) { preset_t *scan, *best; gint diff, bestdiff; char *title; gint anytitle, knowntitle, sameconfig, israndom; static int busy; /* If no widgets, then do nothing */ if (!box) return; /* This function is called when the contents of the combo box is * changed, and it also changes the contents itself. This could lead * to recursion, but we want to avoid that. */ if (busy) return; busy = TRUE; /* Has the list of presets changed? */ if (preset_qty != prevqty) { /* Remember the qty so we can detect the next change too */ prevqty = preset_qty; /* If not supposed to change title, then remember it */ title = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry))); /* Recreate the name list */ if (name_list) { g_list_free(name_list); name_list = NULL; } for (scan = preset_list; scan; scan = scan->next) name_list = g_list_append(name_list, scan->title); g_list_append(name_list, random_name); /* Update the combo's history list from the name list */ gtk_combo_set_popdown_strings(GTK_COMBO(combo), name_list); /* If supposed to change title, then try to find a current * preset which matches the current settings */ if (!keep_title) { best = NULL; for (scan = preset_list; scan; scan = scan->next) { diff = preset_diff(&config, &scan->conf); if (!best || bestdiff > diff) { best = scan; bestdiff = diff; if (bestdiff == 0) break; } } if (best) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), best->title); } else { /* restore old title */ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), title); g_free(title); } } else if (!keep_title) { /* If the current settings match any preset, then set combo * value to its name. */ best = NULL; for (scan = preset_list; scan; scan = scan->next) { diff = preset_diff(&config, &scan->conf); if (!best || bestdiff > diff) { best = scan; bestdiff = diff; if (bestdiff == 0) break; } } if (best) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), best->title); } /* Set some flags, depending on the text in the combo box */ title = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)); israndom = anytitle = knowntitle = sameconfig = FALSE; if (!strcasecmp(title, random_name)) { /* For "Random on quiet", we want to be able to load it but not * save or erase it. This is a special case. */ israndom = knowntitle = TRUE; } else if (*title) { anytitle = TRUE; scan = preset_find(title, NULL); if (scan) { knowntitle = TRUE; if (0 == preset_diff(&config, &scan->conf)) sameconfig = TRUE; else /* Apparently the user altered some property * of the current preset. This should prevent * any future random changes. */ config.random_preset = FALSE; } } /* Adjust the buttons, depending on those flags */ gtk_widget_set_sensitive(load, knowntitle && !sameconfig); gtk_widget_set_sensitive(save, anytitle && !sameconfig); gtk_widget_set_sensitive(erase, !israndom && knowntitle); busy = FALSE; }