Mercurial > audlegacy
changeset 261:5fd398406cf7 trunk
[svn] Still need to pry internal OSS from clenched fingers. In need of anti-warning love too, but it compiles.
| author | chainsaw |
|---|---|
| date | Tue, 06 Dec 2005 16:09:32 -0800 |
| parents | 4b1c9d1a469b |
| children | 5410de731c3c |
| files | Plugins/Output/crossfade/Makefile.am Plugins/Output/crossfade/configure.c Plugins/Output/crossfade/configure.h Plugins/Output/crossfade/crossfade.c Plugins/Output/crossfade/crossfade.h Plugins/Output/crossfade/interface-2.0.c Plugins/Output/crossfade/interface-2.0.h Plugins/Output/crossfade/monitor.c Plugins/Output/crossfade/support-2.0.c Plugins/Output/crossfade/support-2.0.h |
| diffstat | 10 files changed, 5328 insertions(+), 40 deletions(-) [+] |
line wrap: on
line diff
--- a/Plugins/Output/crossfade/Makefile.am Tue Dec 06 14:02:16 2005 -0800 +++ b/Plugins/Output/crossfade/Makefile.am Tue Dec 06 16:09:32 2005 -0800 @@ -1,4 +1,6 @@ +if ENABLE_CROSSFADE lib_LTLIBRARIES = libcrossfade.la +endif gtk_sources = \ interface-2.0.c \ @@ -7,22 +9,15 @@ support-2.0.h \ callbacks.c \ callbacks.h -interface-2.0.c: - glade-2 -w interface-2.0.glade -if HAVE_LIBFFTW_COND -fftw_sources = fft.c fft.h -fftw_libs = -lfftw -lrfftw -endif - -if HAVE_LIBSAMPLERATE_COND +if HAVE_LIBSAMPLERATE samplerate_libs = -lsamplerate endif libdir = $(plugindir)/$(OUTPUT_PLUGIN_DIR) libcrossfade = @PLUGIN_LDFLAGS@ -libcrossfade_la_LIBADD = $(fftw_libs) $(samplerate_libs) +libcrossfade_la_LIBADD = $(samplerate_libs) libcrossfade_la_SOURCES = \ crossfade.c \ crossfade.h \ @@ -44,6 +39,6 @@ timing.h \ volume.c \ volume.h \ - $(gtk_sources) \ - $(fftw_sources) + $(gtk_sources) +INCLUDES = $(GTK_CFLAGS) -I$(top_builddir)/intl -I$(top_srcdir)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/configure.c Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,2180 @@ + +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr <peter@eisenlohr.org> + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#undef PRESET_SUPPORT + +#include "crossfade.h" +#include "configure.h" +#include "interface.h" +#include "monitor.h" +#include "support.h" +#ifdef HAVE_OSS +# include "oss.h" +#endif + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <ctype.h> + +#include <fcntl.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/stat.h> + +#ifdef HAVE_OSS +# ifdef HAVE_SYS_SOUNDCARD_H +# include <sys/soundcard.h> +# elif defined(HAVE_MACHINE_SOUNDCARD_H) +# include <machine/soundcard.h> +# endif +#endif + +#ifdef HAVE_LIBSAMPLERATE +# include <samplerate.h> +#endif + + +#define HIDE(name) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_hide(set_wgt); } + +#define SHOW(name) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_show(set_wgt); } + + +#define SETW_SENSITIVE(wgt, sensitive) \ + gtk_widget_set_sensitive(wgt, sensitive) + +#define SETW_TOGGLE(wgt, active) \ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wgt), active) + +#define SETW_SPIN(wgt, value) \ + gtk_spin_button_set_value(GTK_SPIN_BUTTON(wgt), value) + + +#define SET_SENSITIVE(name, sensitive) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_widget_set_sensitive(set_wgt, sensitive); } + +#define SET_TOGGLE(name, active) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(set_wgt), active); } + +#define SET_SPIN(name, value) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_spin_button_set_value(GTK_SPIN_BUTTON(set_wgt), value); } + +#define SET_PAGE(name, index) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_notebook_set_page(GTK_NOTEBOOK(set_wgt), index); } + +#define SET_HISTORY(name, index) \ +{ if((set_wgt = lookup_widget(config_win, name))) \ + gtk_option_menu_set_history(GTK_OPTION_MENU(set_wgt), index); } + + +#define GET_SENSITIVE(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + && GTK_WIDGET_SENSITIVE(get_wgt)) \ + +#define GET_TOGGLE(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(get_wgt))) + +#define GET_SPIN(name) \ +((get_wgt = lookup_widget(config_win, name)) \ + ? gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(get_wgt)) : 0) + + +static GtkWidget *config_win = NULL; +static GtkWidget *about_win = NULL; +static GtkWidget *set_wgt; +static GtkWidget *get_wgt; + +/* init with DEFAULT_CFG to make sure all string pointers are set to NULL */ +static config_t _cfg = CONFIG_DEFAULT; +static config_t *cfg = &_cfg; + +/* some helpers to keep track of the GUI's state */ +static gboolean checking = FALSE; +static gint op_index; +static plugin_config_t op_config; +static gint ep_index; + + +static void update_plugin_config(gchar **config_string, gchar *name, + plugin_config_t *pc, gboolean save); + +/*****************************************************************************/ + +void g_free_f(gpointer data, gpointer user_data) +{ + g_free(data); +} + +/*****************************************************************************/ + +#ifdef PRESET_SUPPORT +static void +scan_presets(gchar *filename) +{ + struct stat stats; + FILE *fh; + gchar *data, **lines, *tmp, *name; + int i; + + if(lstat(filename, &stats)) { + DEBUG(("[crossfade] scan_presets: \"%s\":\n", filename)); + PERROR("[crossfade] scan_presets: lstat"); + return; + } + if(stats.st_size <= 0) return; + + if(!(data = g_malloc(stats.st_size + 1))) { + DEBUG(("[crossfade] scan_presets: g_malloc(%ld) failed!\n", stats.st_size)); + return; + } + + if(!(fh = fopen(filename, "r"))) { + PERROR("[crossfade] scan_presets: fopen"); + g_free(data); + return; + } + + if(fread(data, stats.st_size, 1, fh) != 1) { + DEBUG(("[crossfade] scan_presets: fread() failed!\n")); + g_free(data); + fclose(fh); + return; + } + fclose(fh); + data[stats.st_size] = 0; + + lines = g_strsplit(data, "\n", 0); + g_free(data); + + if(!lines) { + DEBUG(("[crossfade] scan_presets: g_strsplit() failed!\n")); + return; + } + + g_list_foreach(config->presets, g_free_f, NULL); + g_list_free(config->presets); + config->presets = NULL; + + for(i=0; lines[i]; i++) { + if(lines[i][0] == '[') { + if((tmp = strchr(lines[i], ']'))) { + *tmp = 0; + if((name = g_strdup(lines[i]+1))) + config->presets = g_list_append(config->presets, name); + } + } + } + + g_strfreev(lines); +} +#endif + +static void +read_fade_config(ConfigFile *cfgfile, gchar *section, gchar *key, fade_config_t *fc) +{ + gchar *s = NULL; + gint n; + + if(!cfgfile || !section || !key || !fc) return; + + xmms_cfg_read_string(cfgfile, section, key, &s); + if(!s) return; + + n = sscanf(s, + "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + &fc->type, + &fc->pause_len_ms, + &fc->simple_len_ms, + &fc->out_enable, + &fc->out_len_ms, + &fc->out_volume, + &fc->ofs_type, + &fc->ofs_type_wanted, + &fc->ofs_custom_ms, + &fc->in_locked, + &fc->in_enable, + &fc->in_len_ms, + &fc->in_volume, + &fc->flush_pause_enable, + &fc->flush_pause_len_ms, + &fc->flush_in_enable, + &fc->flush_in_len_ms, + &fc->flush_in_volume); + + g_free(s); +} + +static void +write_fade_config(ConfigFile *cfgfile, gchar *section, gchar *key, fade_config_t *fc) +{ + gchar *s; + + if(!cfgfile || !section || !key || !fc) return; + + s = g_strdup_printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + fc->type, + fc->pause_len_ms, + fc->simple_len_ms, + fc->out_enable, + fc->out_len_ms, + fc->out_volume, + fc->ofs_type, + fc->ofs_type_wanted, + fc->ofs_custom_ms, + fc->in_locked, + fc->in_enable, + fc->in_len_ms, + fc->in_volume, + fc->flush_pause_enable, + fc->flush_pause_len_ms, + fc->flush_in_enable, + fc->flush_in_len_ms, + fc->flush_in_volume); + + if(!s) return; + + xmms_cfg_write_string(cfgfile, section, key, s); + g_free(s); +} + +void +xfade_load_config() +{ +#ifdef PRESET_SUPPORT + gchar *filename; +#endif + gchar *section = "Crossfade"; + ConfigFile *cfgfile; + + if((cfgfile = xmms_cfg_open_default_file())) { + /* config items used in v0.1 */ + xmms_cfg_read_int (cfgfile, section, "output_method", &config->output_method); + xmms_cfg_read_int (cfgfile, section, "audio_device", &config->oss_audio_device); + xmms_cfg_read_boolean(cfgfile, section, "use_alt_audio_device", &config->oss_use_alt_audio_device); + xmms_cfg_read_string (cfgfile, section, "alt_audio_device", &config->oss_alt_audio_device); + xmms_cfg_read_int (cfgfile, section, "mixer_device", &config->oss_mixer_device); + xmms_cfg_read_string (cfgfile, section, "output_plugin", &config->op_name); + xmms_cfg_read_string (cfgfile, section, "op_config_string", &config->op_config_string); + xmms_cfg_read_int (cfgfile, section, "buffer_size", &config->mix_size_ms); + xmms_cfg_read_int (cfgfile, section, "sync_size", &config->sync_size_ms); + xmms_cfg_read_int (cfgfile, section, "preload_size", &config->preload_size_ms); + xmms_cfg_read_int (cfgfile, section, "songchange_timeout", &config->songchange_timeout); + xmms_cfg_read_boolean(cfgfile, section, "enable_mixer", &config->enable_mixer); + xmms_cfg_read_boolean(cfgfile, section, "mixer_reverse", &config->mixer_reverse); + xmms_cfg_read_boolean(cfgfile, section, "enable_debug", &config->enable_debug); + xmms_cfg_read_boolean(cfgfile, section, "enable_monitor", &config->enable_monitor); + + /* config items introduced by v0.2 */ + xmms_cfg_read_int (cfgfile, section, "oss_buffer_size", &config->oss_buffer_size_ms); + xmms_cfg_read_int (cfgfile, section, "oss_preload_size", &config->oss_preload_size_ms); + xmms_cfg_read_boolean(cfgfile, section, "oss_mixer_use_master", &config->oss_mixer_use_master); + xmms_cfg_read_boolean(cfgfile, section, "gap_lead_enable", &config->gap_lead_enable); + xmms_cfg_read_int (cfgfile, section, "gap_lead_len_ms", &config->gap_lead_len_ms); + xmms_cfg_read_int (cfgfile, section, "gap_lead_level", &config->gap_lead_level); + xmms_cfg_read_boolean(cfgfile, section, "gap_trail_enable", &config->gap_trail_enable); + xmms_cfg_read_int (cfgfile, section, "gap_trail_len_ms", &config->gap_trail_len_ms); + xmms_cfg_read_int (cfgfile, section, "gap_trail_level", &config->gap_trail_level); + xmms_cfg_read_int (cfgfile, section, "gap_trail_locked", &config->gap_trail_locked); + + /* config items introduced by v0.2.1 */ + xmms_cfg_read_boolean(cfgfile, section, "buffer_size_auto", &config->mix_size_auto); + + /* config items introduced by v0.2.3 */ + xmms_cfg_read_boolean(cfgfile, section, "album_detection", &config->album_detection); + + /* config items introduced by v0.2.4 */ + xmms_cfg_read_boolean(cfgfile, section, "http_workaround", &config->enable_http_workaround); + xmms_cfg_read_boolean(cfgfile, section, "enable_op_max_used", &config->enable_op_max_used); + xmms_cfg_read_int (cfgfile, section, "op_max_used_ms", &config->op_max_used_ms); + + /* config items introduced by v0.2.6 */ + xmms_cfg_read_string (cfgfile, section, "effect_plugin", &config->ep_name); + xmms_cfg_read_boolean(cfgfile, section, "effect_enable", &config->ep_enable); + xmms_cfg_read_int (cfgfile, section, "output_rate", &config->output_rate); + + /* config items introduced by v0.2.7 */ + xmms_cfg_read_boolean(cfgfile, section, "oss_maxbuf_enable", &config->oss_maxbuf_enable); + + /* config items introduced by v0.3.0 */ + xmms_cfg_read_boolean(cfgfile, section, "use_alt_mixer_device", &config->oss_use_alt_mixer_device); + xmms_cfg_read_int (cfgfile, section, "oss_fragments", &config->oss_fragments); + xmms_cfg_read_int (cfgfile, section, "oss_fragment_size", &config->oss_fragment_size); + xmms_cfg_read_boolean(cfgfile, section, "volnorm_enable", &config->volnorm_enable); + xmms_cfg_read_boolean(cfgfile, section, "volnorm_use_qa", &config->volnorm_use_qa); + xmms_cfg_read_int (cfgfile, section, "volnorm_target", &config->volnorm_target); + xmms_cfg_read_boolean(cfgfile, section, "output_keep_opened", &config->output_keep_opened); + xmms_cfg_read_boolean(cfgfile, section, "mixer_software", &config->mixer_software); + xmms_cfg_read_int (cfgfile, section, "mixer_vol_left", &config->mixer_vol_left); + xmms_cfg_read_int (cfgfile, section, "mixer_vol_right", &config->mixer_vol_right); + + /* config items introduced by v0.3.2 */ + xmms_cfg_read_boolean(cfgfile, section, "no_xfade_if_same_file",&config->no_xfade_if_same_file); + + /* config items introduced by v0.3.3 */ + xmms_cfg_read_string (cfgfile, section, "alt_mixer_device", &config->oss_alt_mixer_device); + xmms_cfg_read_boolean(cfgfile, section, "gap_crossing", &config->gap_crossing); + + /* config items introduced by v0.3.6 */ + xmms_cfg_read_int (cfgfile, section, "output_quality", &config->output_quality); + + /* fade configs */ + read_fade_config(cfgfile, section, "fc_xfade", &config->fc[FADE_CONFIG_XFADE]); + read_fade_config(cfgfile, section, "fc_manual", &config->fc[FADE_CONFIG_MANUAL]); + read_fade_config(cfgfile, section, "fc_album", &config->fc[FADE_CONFIG_ALBUM]); + read_fade_config(cfgfile, section, "fc_start", &config->fc[FADE_CONFIG_START]); + read_fade_config(cfgfile, section, "fc_stop", &config->fc[FADE_CONFIG_STOP]); + read_fade_config(cfgfile, section, "fc_eop", &config->fc[FADE_CONFIG_EOP]); + read_fade_config(cfgfile, section, "fc_seek", &config->fc[FADE_CONFIG_SEEK]); + read_fade_config(cfgfile, section, "fc_pause", &config->fc[FADE_CONFIG_PAUSE]); + + xmms_cfg_free(cfgfile); + DEBUG(("[crossfade] load_config: configuration loaded\n")); + } + else + DEBUG(("[crossfade] load_config: error loading config, using defaults\n")); + +#ifdef PRESET_SUPPORT + filename = g_strconcat(g_get_home_dir(), "/.xmms/xmms-crossfade-presets", NULL); + scan_presets(filename); + g_free(filename); +#endif +} + +void +xfade_save_config() +{ + gchar *section = "Crossfade"; + ConfigFile *cfgfile; + + if((cfgfile = xmms_cfg_open_default_file())) { + /* obsolete config items */ + xmms_cfg_remove_key(cfgfile, section, "underrun_pct"); + xmms_cfg_remove_key(cfgfile, section, "enable_crossfade"); + xmms_cfg_remove_key(cfgfile, section, "enable_gapkiller"); + xmms_cfg_remove_key(cfgfile, section, "mixer_use_master"); + xmms_cfg_remove_key(cfgfile, section, "late_effect"); + xmms_cfg_remove_key(cfgfile, section, "gap_lead_length"); + + /* config items used in v0.1 */ + xmms_cfg_write_int (cfgfile, section, "output_method", config->output_method); + xmms_cfg_write_int (cfgfile, section, "audio_device", config->oss_audio_device); + xmms_cfg_write_boolean(cfgfile, section, "use_alt_audio_device", config->oss_use_alt_audio_device); + xmms_cfg_write_string (cfgfile, section, "alt_audio_device", config->oss_alt_audio_device ? config->oss_alt_audio_device : DEFAULT_OSS_ALT_AUDIO_DEVICE); + xmms_cfg_write_int (cfgfile, section, "mixer_device", config->oss_mixer_device); + xmms_cfg_write_string (cfgfile, section, "output_plugin", config->op_name ? config->op_name : DEFAULT_OP_NAME); + xmms_cfg_write_string (cfgfile, section, "op_config_string", config->op_config_string ? config->op_config_string : DEFAULT_OP_CONFIG_STRING); + xmms_cfg_write_int (cfgfile, section, "buffer_size", config->mix_size_ms); + xmms_cfg_write_int (cfgfile, section, "sync_size", config->sync_size_ms); + xmms_cfg_write_int (cfgfile, section, "preload_size", config->preload_size_ms); + xmms_cfg_write_int (cfgfile, section, "songchange_timeout", config->songchange_timeout); + xmms_cfg_write_boolean(cfgfile, section, "enable_mixer", config->enable_mixer); + xmms_cfg_write_boolean(cfgfile, section, "mixer_reverse", config->mixer_reverse); + xmms_cfg_write_boolean(cfgfile, section, "enable_debug", config->enable_debug); + xmms_cfg_write_boolean(cfgfile, section, "enable_monitor", config->enable_monitor); + + /* config items introduced by v0.2 */ + xmms_cfg_write_int (cfgfile, section, "oss_buffer_size", config->oss_buffer_size_ms); + xmms_cfg_write_int (cfgfile, section, "oss_preload_size", config->oss_preload_size_ms); + xmms_cfg_write_boolean(cfgfile, section, "oss_mixer_use_master", config->oss_mixer_use_master); + xmms_cfg_write_boolean(cfgfile, section, "gap_lead_enable", config->gap_lead_enable); + xmms_cfg_write_int (cfgfile, section, "gap_lead_len_ms", config->gap_lead_len_ms); + xmms_cfg_write_int (cfgfile, section, "gap_lead_level", config->gap_lead_level); + xmms_cfg_write_boolean(cfgfile, section, "gap_trail_enable", config->gap_trail_enable); + xmms_cfg_write_int (cfgfile, section, "gap_trail_len_ms", config->gap_trail_len_ms); + xmms_cfg_write_int (cfgfile, section, "gap_trail_level", config->gap_trail_level); + xmms_cfg_write_int (cfgfile, section, "gap_trail_locked", config->gap_trail_locked); + + /* config items introduced by v0.2.1 */ + xmms_cfg_write_boolean(cfgfile, section, "buffer_size_auto", config->mix_size_auto); + + /* config items introduced by v0.2.3 */ + xmms_cfg_write_boolean(cfgfile, section, "album_detection", config->album_detection); + + /* config items introduced by v0.2.4 */ + xmms_cfg_write_boolean(cfgfile, section, "http_workaround", config->enable_http_workaround); + xmms_cfg_write_boolean(cfgfile, section, "enable_op_max_used", config->enable_op_max_used); + xmms_cfg_write_int (cfgfile, section, "op_max_used_ms", config->op_max_used_ms); + + /* config items introduced by v0.2.6 */ + xmms_cfg_write_string (cfgfile, section, "effect_plugin", config->ep_name ? config->ep_name : DEFAULT_EP_NAME); + xmms_cfg_write_boolean(cfgfile, section, "effect_enable", config->ep_enable); + xmms_cfg_write_int (cfgfile, section, "output_rate", config->output_rate); + + /* config items introduced by v0.2.7 */ + xmms_cfg_write_boolean(cfgfile, section, "oss_maxbuf_enable", config->oss_maxbuf_enable); + + /* config items introduced by v0.3.0 */ + xmms_cfg_write_boolean(cfgfile, section, "use_alt_mixer_device", config->oss_use_alt_mixer_device); + xmms_cfg_write_int (cfgfile, section, "oss_fragments", config->oss_fragments); + xmms_cfg_write_int (cfgfile, section, "oss_fragment_size", config->oss_fragment_size); +#ifdef VOLUME_NORMALIZER + xmms_cfg_write_boolean(cfgfile, section, "volnorm_enable", config->volnorm_enable); + xmms_cfg_write_boolean(cfgfile, section, "volnorm_use_qa", config->volnorm_use_qa); + xmms_cfg_write_int (cfgfile, section, "volnorm_target", config->volnorm_target); +#endif + xmms_cfg_write_boolean(cfgfile, section, "output_keep_opened", config->output_keep_opened); + xmms_cfg_write_boolean(cfgfile, section, "mixer_software", config->mixer_software); + xmms_cfg_write_int (cfgfile, section, "mixer_vol_left", config->mixer_vol_left); + xmms_cfg_write_int (cfgfile, section, "mixer_vol_right", config->mixer_vol_right); + + /* config items introduced by v0.3.2 */ + xmms_cfg_write_boolean(cfgfile, section, "no_xfade_if_same_file",config->no_xfade_if_same_file); + + /* config items introduced by v0.3.2 */ + xmms_cfg_write_string (cfgfile, section, "alt_mixer_device", config->oss_alt_mixer_device ? config->oss_alt_mixer_device : DEFAULT_OSS_ALT_MIXER_DEVICE); + xmms_cfg_write_boolean(cfgfile, section, "gap_crossing", config->gap_crossing); + + /* config items introduced by v0.3.6 */ + xmms_cfg_write_int (cfgfile, section, "output_quality", config->output_quality); + + /* fade configs */ + write_fade_config(cfgfile, section, "fc_xfade", &config->fc[FADE_CONFIG_XFADE]); + write_fade_config(cfgfile, section, "fc_manual", &config->fc[FADE_CONFIG_MANUAL]); + write_fade_config(cfgfile, section, "fc_album", &config->fc[FADE_CONFIG_ALBUM]); + write_fade_config(cfgfile, section, "fc_start", &config->fc[FADE_CONFIG_START]); + write_fade_config(cfgfile, section, "fc_stop", &config->fc[FADE_CONFIG_STOP]); + write_fade_config(cfgfile, section, "fc_eop", &config->fc[FADE_CONFIG_EOP]); + write_fade_config(cfgfile, section, "fc_seek", &config->fc[FADE_CONFIG_SEEK]); + write_fade_config(cfgfile, section, "fc_pause", &config->fc[FADE_CONFIG_PAUSE]); + + xmms_cfg_write_default_file(cfgfile); + xmms_cfg_free (cfgfile); + DEBUG(("[crossfade] save_config: configuration saved\n")); + } + else + DEBUG(("[crossfade] save_config: error saving configuration!\n")); +} + +#define SAFE_FREE(x) if(x) { g_free(x); x = NULL; } +void +xfade_free_config() +{ + SAFE_FREE(cfg->oss_alt_audio_device); + SAFE_FREE(cfg->oss_alt_mixer_device); + SAFE_FREE(cfg->op_config_string); + SAFE_FREE(cfg->op_name); + + g_list_foreach(config->presets, g_free_f, NULL); + g_list_free(config->presets); + config->presets = NULL; +} + +void +xfade_load_plugin_config(gchar *config_string, + gchar *plugin_name, + plugin_config_t *plugin_config) +{ + update_plugin_config(&config_string, plugin_name, plugin_config, FALSE); +} + +void +xfade_save_plugin_config(gchar **config_string, + gchar *plugin_name, + plugin_config_t *plugin_config) +{ + update_plugin_config(config_string, plugin_name, plugin_config, TRUE); +} + +/*** helpers *****************************************************************/ + +gint +xfade_cfg_fadeout_len(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_SIMPLE_XF: + return fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + return fc->out_enable ? fc->out_len_ms : 0; + case FADE_TYPE_FADEOUT: + case FADE_TYPE_PAUSE_ADV: + return fc->out_len_ms; + } + return 0; +} + +gint +xfade_cfg_fadeout_volume(fade_config_t *fc) +{ + gint volume; + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_ADVANCED_XF: + case FADE_TYPE_FADEOUT: + volume = fc->out_volume; + if(volume < 0) volume = 0; + if(volume > 100) volume = 100; + return volume; + } + return 0; +} + +gint +xfade_cfg_offset(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + return fc->flush_pause_enable ? fc->flush_pause_len_ms : 0; + case FADE_TYPE_PAUSE: + return fc->pause_len_ms; + case FADE_TYPE_SIMPLE_XF: + return -fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + switch(fc->ofs_type) { + case FC_OFFSET_LOCK_OUT: + return -fc->out_len_ms; + case FC_OFFSET_LOCK_IN: + return -fc->in_len_ms; + case FC_OFFSET_CUSTOM: + return fc->ofs_custom_ms; + } + return 0; + case FADE_TYPE_FADEOUT: + case FADE_TYPE_PAUSE_ADV: + return fc->ofs_custom_ms; + } + return 0; +} + +gint +xfade_cfg_fadein_len(fade_config_t *fc) +{ + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + return fc->flush_in_enable ? fc->flush_in_len_ms : 0; + case FADE_TYPE_SIMPLE_XF: + return fc->simple_len_ms; + case FADE_TYPE_ADVANCED_XF: + return + fc->in_locked + ? (fc->out_enable ? fc->out_len_ms : 0) + : (fc->in_enable ? fc->in_len_ms : 0); + case FADE_TYPE_FADEIN: + case FADE_TYPE_PAUSE_ADV: + return fc->in_len_ms; + } + return 0; +} + +gint +xfade_cfg_fadein_volume(fade_config_t *fc) +{ + gint volume; + if(!fc) return 0; + switch(fc->type) { + case FADE_TYPE_FLUSH: + volume = fc->flush_in_volume; + break; + case FADE_TYPE_ADVANCED_XF: + volume = fc->in_locked ? fc->out_volume : fc->in_volume; + break; + case FADE_TYPE_FADEIN: + volume = fc->in_volume; + break; + default: + volume = 0; + } + if(volume < 0) volume = 0; + if(volume > 100) volume = 100; + return volume; +} + +gboolean +xfade_cfg_gap_trail_enable(config_t *cfg) +{ + return cfg->gap_trail_locked + ? cfg->gap_lead_enable + : cfg->gap_trail_enable; +} + +gint +xfade_cfg_gap_trail_len(config_t *cfg) +{ + if(!xfade_cfg_gap_trail_enable(cfg)) return 0; + return cfg->gap_trail_locked + ? cfg->gap_lead_len_ms + : cfg->gap_trail_len_ms; +} + +gint +xfade_cfg_gap_trail_level(config_t *cfg) +{ + return cfg->gap_trail_locked + ? cfg->gap_lead_level + : cfg->gap_trail_level; +} + +gint +xfade_mix_size_ms(config_t *cfg) +{ + if(cfg->mix_size_auto) { + gint i, min_size = 0; + + for(i=0; i<MAX_FADE_CONFIGS; i++) { + gint size = xfade_cfg_fadeout_len(&cfg->fc[i]); + gint offset = xfade_cfg_offset(&cfg->fc[i]); + + if(cfg->fc[i].type == FADE_TYPE_PAUSE_ADV) + size += xfade_cfg_fadein_len(&cfg->fc[i]); + + if(size < -offset) + size = -offset; + + if(size > min_size) + min_size = size; + } + return min_size += xfade_cfg_gap_trail_len(cfg) + + cfg->songchange_timeout; + } + else + return cfg->mix_size_ms; +} + +/*** internal helpers ********************************************************/ + +static void +add_menu_item(GtkWidget *menu, gchar *title, GtkSignalFunc func, gint index, gint **imap) +{ + GtkWidget *item; + if(!menu || !title || !func) return; + item = gtk_menu_item_new_with_label(title); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(func), (gpointer)index); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + if(imap) *((*imap)++) = index; +} + +/*** output method ***********************************************************/ + +/*-- callbacks --------------------------------------------------------------*/ + +void on_output_oss_radio_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + SET_PAGE("output_notebook", 0); + cfg->output_method = OUTPUT_METHOD_BUILTIN_OSS; +} + +void on_output_plugin_radio_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + SET_PAGE("output_notebook", 1); + cfg->output_method = OUTPUT_METHOD_PLUGIN; +} + +void on_output_none_radio_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + SET_PAGE("output_notebook", 2); + cfg->output_method = OUTPUT_METHOD_BUILTIN_NULL; +} + +static void resampling_rate_cb(GtkWidget *widget, gint index) +{ + cfg->output_rate = index; +} + +#ifdef HAVE_LIBSAMPLERATE +static void resampling_quality_cb(GtkWidget *widget, gint index) +{ + cfg->output_quality = index; +} +#endif + +/*** oss output **************************************************************/ + +static void +scan_devices(gchar *type, GtkWidget *option_menu, GtkSignalFunc signal_f) +{ +#ifdef HAVE_OSS + gchar buffer[256]; + FILE *file; + + GtkWidget *item; + gboolean found = FALSE; + gint type_len = strlen(type); +#endif + + GtkWidget *menu; + gint index = 0; + gint mixer = 0; + + menu = gtk_menu_new(); + +#ifdef HAVE_OSS + /* look for devices in /dev/sndstat or /proc/asound/sndstat (OSS style) */ + if((file = fopen("/dev/sndstat", "r")) || + (file = fopen("/proc/asound/sndstat", "r")) || + (file = fopen("/proc/asound/oss/sndstat", "r"))) { + while(fgets(buffer, sizeof(buffer), file)) { + gint i = strlen(buffer)-1; + while((i >= 0) && isspace(buffer[i])) buffer[i--] = 0; + if(found) { + if(!buffer[0] || !isdigit(buffer[0])) break; + if(index == 0) { + gchar *label, *p = strchr(buffer, ':'); + if(p) do p++; while(*p == ' '); + else p = buffer; + label = g_strdup_printf("Default (%s)", p); + item = gtk_menu_item_new_with_label(label); + g_free(label); + } + else item = gtk_menu_item_new_with_label(buffer); + + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(signal_f), + (gpointer)index); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + index++; + } + else if(!strcmp(buffer, type)) + found = TRUE; + else if(!strncmp(buffer, type, type_len)) + DEBUG(("[crossfade] scan_devices: %s\n", buffer)); + } + fclose(file); + + if(!found) + DEBUG(("[crossfade] scan_devices: section \"%s\" not found!\n", type)); + } + else { + DEBUG(("[crossfade] scan_devices: no sndstat found!\n")); +#ifdef SOUND_MIXER_INFO + /* from xmms-3dse7 by Frank Cornelis */ + DEBUG(("[crossfade] scan_devices: using alternate method...\n")); + for(;;) { + gchar dev_name[32]; + int fd; + mixer_info info; + gchar *label; + + if(mixer != 0) + sprintf(dev_name, "/dev/mixer%d", mixer); + else + strcpy(dev_name, "/dev/mixer"); + + if((fd = open(dev_name, O_RDONLY)) != -1) { + if(ioctl(fd, SOUND_MIXER_INFO, &info) != -1) { + label = g_strdup_printf(index ? "%s" : "Default (%s)", info.name); + add_menu_item(menu, label, signal_f, index, NULL); + g_free(label); + index++; + } + close(fd); + } + else break; + mixer++; + } +#endif + } +#endif /* HAVE_OSS */ + + /* create default entry if no device(s) could be found */ + if(index == 0) add_menu_item(menu, "Default", signal_f, 0, NULL); + + /* attach menu */ + gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu); +} + +/*-- oss output callbacks ---------------------------------------------------*/ + +void check_oss_dependencies() +{ + if(checking) return; + checking = TRUE; + + SET_SENSITIVE("oss_adevice_optionmenu", !cfg->oss_use_alt_audio_device); + SET_SENSITIVE("oss_adevice_alt_entry", cfg->oss_use_alt_audio_device); + + SET_SENSITIVE("oss_mdevice_optionmenu", !cfg->oss_use_alt_mixer_device); + SET_SENSITIVE("oss_mdevice_alt_entry", cfg->oss_use_alt_mixer_device); + + SET_SENSITIVE("osshwb_fragments_label", !cfg->oss_maxbuf_enable); + SET_SENSITIVE("osshwb_fragments_spin", !cfg->oss_maxbuf_enable); + SET_SENSITIVE("osshwb_fragsize_label", !cfg->oss_maxbuf_enable); + SET_SENSITIVE("osshwb_fragsize_spin", !cfg->oss_maxbuf_enable); + + checking = FALSE; +} + +void config_adevice_cb(GtkWidget *widget, gint device) +{ + cfg->oss_audio_device = device; +} + +void config_mdevice_cb(GtkWidget *widget, gint device) +{ + cfg->oss_mixer_device = device; +} + +void on_config_adevice_alt_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->oss_use_alt_audio_device = gtk_toggle_button_get_active(togglebutton); + check_oss_dependencies(); +} + +void on_config_mdevice_alt_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->oss_use_alt_mixer_device = gtk_toggle_button_get_active(togglebutton); + check_oss_dependencies(); +} + +void on_osshwb_maxbuf_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->oss_maxbuf_enable = gtk_toggle_button_get_active(togglebutton); + check_oss_dependencies(); +} + +/*** plugin output ***********************************************************/ + +static gchar * +strip(gchar *s) +{ + gchar *p; + if(!s) return NULL; + for(; *s == ' '; s++); + if(!*s) return s; + for(p = s+strlen(s)-1; *p == ' '; p--); + *++p = 0; + return s; +} + +static void +update_plugin_config(gchar **config_string, gchar *name, + plugin_config_t *pc, gboolean save) +{ + plugin_config_t default_pc = DEFAULT_OP_CONFIG; + + gchar *buffer = NULL; + gchar out[1024]; + + gboolean plugin_found = FALSE; + gchar *plugin, *next_plugin; + gchar *args; + + if(pc && !save) *pc = default_pc; + if(!config_string || !*config_string || !name || !pc) { + DEBUG(("[crossfade] update_plugin_config: missing arg!\n")); + return; + } + + buffer = g_strdup(*config_string); + out[0] = 0; + + for(plugin = buffer; plugin; plugin = next_plugin) { + if((next_plugin = strchr(plugin, ';'))) *next_plugin++ = 0; + if((args = strchr(plugin, '='))) *args++ = 0; + plugin = strip(plugin); + if(!*plugin || !args || !*args) continue; + + if(save) { + if(0 == strcmp(plugin, name)) continue; + if(*out) strcat(out, "; "); + strcat(out, plugin); + strcat(out, "="); + strcat(out, args); + continue; + } + else if(strcmp(plugin, name)) continue; + + args = strip(args); + sscanf(args, "%d,%d,%d,%d", + &pc->throttle_enable, + &pc->max_write_enable, + &pc->max_write_len, + &pc->force_reopen); + pc->max_write_len &= -4; + plugin_found = TRUE; + } + + if(save) { + /* only save if settings differ from defaults */ + if(( pc->throttle_enable != default_pc.throttle_enable) + ||(pc->max_write_enable != default_pc.max_write_enable) + ||(pc->max_write_len != default_pc.max_write_len) + ||(pc->force_reopen != default_pc.force_reopen)) { + if(*out) strcat(out, "; "); + sprintf(out + strlen(out), "%s=%d,%d,%d,%d", name, + pc->throttle_enable ? 1 : 0, + pc->max_write_enable ? 1 : 0, + pc->max_write_len, + pc->force_reopen); + } + if(*config_string) g_free(*config_string); + *config_string = g_strdup(out); + } + + g_free(buffer); +} + +static void +config_plugin_cb(GtkWidget *widget, gint index); + +static gint +scan_plugins(GtkWidget *option_menu, gchar *selected) +{ + GtkWidget *menu = gtk_menu_new(); + GList *list = g_list_first(get_output_list()); /* XMMS */ + gint index = 0; + gint sel_index = -1; + gint def_index = -1; + + /* sanity check */ + if(selected == NULL) selected = ""; + + /* parse module list */ + while(list) { + OutputPlugin *op = (OutputPlugin *)list->data; + GtkWidget *item = gtk_menu_item_new_with_label(op->description); + + if(op == get_crossfade_oplugin_info()) /* disable selecting ourselves */ + gtk_widget_set_sensitive(item, FALSE); + else { + if(def_index == -1) def_index = index; + if(selected && !strcmp(g_basename(op->filename), selected)) + sel_index = index; + } + + /* create menu item */ + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(config_plugin_cb), (gpointer)index++); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + /* advance to next module */ + list = g_list_next(list); + } + + /* attach menu */ + gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu); + + if(sel_index == -1) { + DEBUG(("[crossfade] scan_plugins: plugin not found (\"%s\")\n", selected)); + return def_index; /* use default (first entry) */ + } + return sel_index; +} + +/*-- plugin output callbacks ------------------------------------------------*/ + +static void +config_plugin_cb(GtkWidget *widget, gint index) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), index); /* XMMS */ + + /* get plugin options from gui */ + op_config.throttle_enable = GET_TOGGLE("op_throttle_check"); + op_config.max_write_enable = GET_TOGGLE("op_maxblock_check"); + op_config.max_write_len = GET_SPIN ("op_maxblock_spin"); + op_config.force_reopen = GET_TOGGLE("op_forcereopen_check"); + + /* config -> string */ + xfade_save_plugin_config(&cfg->op_config_string, cfg->op_name, &op_config); + + /* select new plugin */ + op_index = index; + + /* get new plugin's name */ + if(cfg->op_name) g_free(cfg->op_name); + cfg->op_name = (op && op->filename) + ? g_strdup(g_basename(op->filename)) : NULL; + + /* string -> config */ + xfade_load_plugin_config(cfg->op_config_string, cfg->op_name, &op_config); + + /* update gui */ + SET_SENSITIVE("op_configure_button", op && (op->configure != NULL)); + SET_SENSITIVE("op_about_button", op && (op->about != NULL)); + SET_TOGGLE ("op_throttle_check", op_config.throttle_enable); + SET_TOGGLE ("op_maxblock_check", op_config.max_write_enable); + SET_SPIN ("op_maxblock_spin", op_config.max_write_len); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); + SET_TOGGLE ("op_forcereopen_check", op_config.force_reopen); +} + +void on_output_plugin_configure_button_clicked (GtkButton *button, gpointer user_data) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + if((op == NULL) || (op->configure == NULL)) return; + op->configure(); +} + +void on_output_plugin_about_button_clicked(GtkButton *button, gpointer user_data) +{ + OutputPlugin *op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + if((op == NULL) || (op->about == NULL)) return; + op->about(); +} + +void on_op_throttle_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.throttle_enable = gtk_toggle_button_get_active(togglebutton); +} + +void on_op_maxblock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.max_write_enable = gtk_toggle_button_get_active(togglebutton); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); +} + +void on_op_maxblock_spin_changed(GtkEditable *editable, gpointer user_data) +{ + op_config.max_write_len = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +void on_op_forcereopen_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + op_config.max_write_enable = gtk_toggle_button_get_active(togglebutton); +} + +/*** effects *****************************************************************/ + +static void +config_effect_plugin_cb(GtkWidget *widget, gint index); + +static gint +scan_effect_plugins(GtkWidget *option_menu, gchar *selected) +{ + GtkWidget *menu = gtk_menu_new(); + GList *list = g_list_first(get_effect_list()); /* XMMS */ + gint index = 0; + gint sel_index = -1; + gint def_index = -1; + + /* sanity check */ + if(selected == NULL) selected = ""; + + /* parse module list */ + while(list) { + EffectPlugin *ep = (EffectPlugin *)list->data; + GtkWidget *item = gtk_menu_item_new_with_label(ep->description); + + if(def_index == -1) def_index = index; + if(selected && !strcmp(g_basename(ep->filename), selected)) + sel_index = index; + + /* create menu item */ + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(config_effect_plugin_cb), (gpointer)index++); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + /* advance to next module */ + list = g_list_next(list); + } + + /* attach menu */ + gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu); + + if(sel_index == -1) { + DEBUG(("[crossfade] scan_effect_plugins: plugin not found (\"%s\")\n", selected)); + return def_index; /* use default (first entry) */ + } + return sel_index; +} + +/*-- plugin output callbacks ------------------------------------------------*/ + +static void +config_effect_plugin_cb(GtkWidget *widget, gint index) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), index); /* XMMS */ + + /* select new plugin */ + ep_index = index; + + /* get new plugin's name */ + if(cfg->ep_name) g_free(cfg->ep_name); + cfg->ep_name = (ep && ep->filename) + ? g_strdup(g_basename(ep->filename)) : NULL; + + /* update gui */ + SET_SENSITIVE("ep_configure_button", ep && (ep->configure != NULL)); + SET_SENSITIVE("ep_about_button", ep && (ep->about != NULL)); + + /* 0.3.5: apply effect config immediatelly */ + if(config->ep_name) g_free(config->ep_name); + config->ep_name = g_strdup(cfg->ep_name); + xfade_realize_ep_config(); +} + +void on_ep_configure_button_clicked(GtkButton *button, gpointer user_data) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + if((ep == NULL) || (ep->configure == NULL)) return; + ep->configure(); +} + +void on_ep_about_button_clicked(GtkButton *button, gpointer user_data) +{ + EffectPlugin *ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + if((ep == NULL) || (ep->about == NULL)) return; + ep->about(); +} + +void on_ep_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + /* 0.3.5: apply effect config immediatelly */ + config->ep_enable = cfg->ep_enable = GET_TOGGLE("ep_enable_check"); + xfade_realize_ep_config(); +} + +/*-- volume normalizer ------------------------------------------------------*/ + +void check_effects_dependencies() +{ + if(checking) return; + checking = TRUE; + + SET_SENSITIVE("volnorm_target_spin", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_target_label", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_quantaudio_check", cfg->volnorm_enable); + SET_SENSITIVE("volnorm_target_spin", cfg->volnorm_enable); + + checking = FALSE; +} + +void on_volnorm_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->volnorm_enable = gtk_toggle_button_get_active(togglebutton); + check_effects_dependencies(); +} + +/*** crossfader **************************************************************/ + +static void xf_config_cb(GtkWidget *widget, gint index); +static void xf_type_cb (GtkWidget *widget, gint index); + +/* crude hack to keep track of menu items */ +static gint xf_config_index_map[MAX_FADE_CONFIGS]; +static gint xf_type_index_map [MAX_FADE_TYPES]; + +static void +create_crossfader_config_menu() +{ + GtkWidget *optionmenu, *menu; + gint i, *imap; + + if((optionmenu = lookup_widget(config_win, "xf_config_optionmenu"))) { + for(i=0; i<MAX_FADE_CONFIGS; i++) xf_config_index_map[i] = -1; + imap = xf_config_index_map; + menu = gtk_menu_new(); + add_menu_item(menu, "Start of playback", xf_config_cb, FADE_CONFIG_START, &imap); + add_menu_item(menu, "Automatic songchange", xf_config_cb, FADE_CONFIG_XFADE, &imap); +#if 0 + /* this should be FADE_TYPE_NONE all the time, anyway, + so no need to make it configureable by the user */ + add_menu_item(menu, "Automatic (gapless)", xf_config_cb, FADE_CONFIG_ALBUM, &imap); +#endif + add_menu_item(menu, "Manual songchange", xf_config_cb, FADE_CONFIG_MANUAL, &imap); + add_menu_item(menu, "Manual stop", xf_config_cb, FADE_CONFIG_STOP, &imap); + add_menu_item(menu, "End of playlist", xf_config_cb, FADE_CONFIG_EOP, &imap); + add_menu_item(menu, "Seeking", xf_config_cb, FADE_CONFIG_SEEK, &imap); + add_menu_item(menu, "Pause", xf_config_cb, FADE_CONFIG_PAUSE, &imap); + gtk_option_menu_set_menu(GTK_OPTION_MENU(optionmenu), menu); + } + +} + +static void +create_crossfader_type_menu() +{ + GtkWidget *optionmenu, *menu; + gint i, *imap; + guint32 mask; + + if((optionmenu = lookup_widget(config_win, "xf_type_optionmenu"))) { + for(i=0; i<MAX_FADE_TYPES; i++) xf_type_index_map[i] = -1; + imap = xf_type_index_map; + menu = gtk_menu_new(); + mask = cfg->fc[cfg->xf_index].type_mask; + if(mask & (1 << FADE_TYPE_REOPEN)) add_menu_item(menu, "Reopen output device", xf_type_cb, FADE_TYPE_REOPEN, &imap); + if(mask & (1 << FADE_TYPE_FLUSH)) add_menu_item(menu, "Flush output device", xf_type_cb, FADE_TYPE_FLUSH, &imap); + if(mask & (1 << FADE_TYPE_NONE)) add_menu_item(menu, "None (gapless/off)", xf_type_cb, FADE_TYPE_NONE, &imap); + if(mask & (1 << FADE_TYPE_PAUSE)) add_menu_item(menu, "Pause", xf_type_cb, FADE_TYPE_PAUSE, &imap); + if(mask & (1 << FADE_TYPE_SIMPLE_XF)) add_menu_item(menu, "Simple crossfade", xf_type_cb, FADE_TYPE_SIMPLE_XF, &imap); + if(mask & (1 << FADE_TYPE_ADVANCED_XF)) add_menu_item(menu, "Advanced crossfade", xf_type_cb, FADE_TYPE_ADVANCED_XF, &imap); + if(mask & (1 << FADE_TYPE_FADEIN)) add_menu_item(menu, "Fadein", xf_type_cb, FADE_TYPE_FADEIN, &imap); + if(mask & (1 << FADE_TYPE_FADEOUT)) add_menu_item(menu, "Fadeout", xf_type_cb, FADE_TYPE_FADEOUT, &imap); + if(mask & (1 << FADE_TYPE_PAUSE_NONE)) add_menu_item(menu, "None", xf_type_cb, FADE_TYPE_PAUSE_NONE, &imap); + if(mask & (1 << FADE_TYPE_PAUSE_ADV)) add_menu_item(menu, "Fadeout/Fadein", xf_type_cb, FADE_TYPE_PAUSE_ADV, &imap); + gtk_option_menu_set_menu(GTK_OPTION_MENU(optionmenu), menu); + } +} + +#define NONE 0x00000000L +#define XF_CONFIG 0x00000001L +#define XF_TYPE 0x00000002L +#define XF_MIX_SIZE 0x00000004L +#define XF_FADEOUT 0x00000008L +#define XF_OFFSET 0x00000010L +#define XF_FADEIN 0x00000020L +#define XF_PAGE 0x00000040L +#define XF_FLUSH 0x00000080L +#define ANY 0xffffffffL + +static void +check_crossfader_dependencies(guint32 mask) +{ + fade_config_t *fc = &cfg->fc[cfg->xf_index]; + gint i; + + /* HACK: avoid endless recursion */ + if(checking) return; + checking = TRUE; + + if(mask & XF_FLUSH) { + SET_TOGGLE ("xftfp_enable_check", fc->flush_pause_enable); + SET_SENSITIVE("xftfp_length_label", fc->flush_pause_enable); + SET_SENSITIVE("xftfp_length_spin", fc->flush_pause_enable); + SET_TOGGLE ("xftffi_enable_check", fc->flush_in_enable); + SET_SENSITIVE("xftffi_length_label", fc->flush_in_enable); + SET_SENSITIVE("xftffi_length_spin", fc->flush_in_enable); + SET_SENSITIVE("xftffi_volume_label", fc->flush_in_enable); + SET_SENSITIVE("xftffi_volume_spin", fc->flush_in_enable); + } + + if(mask & XF_MIX_SIZE) { + SET_TOGGLE ("xf_autobuf_check", cfg->mix_size_auto); + SET_SENSITIVE("xf_buffer_spin", !cfg->mix_size_auto); + SET_SPIN ("xf_buffer_spin", xfade_mix_size_ms(cfg)); + } + + if(mask & XF_CONFIG) { + for(i=0; i<MAX_FADE_CONFIGS && (xf_config_index_map[i] != cfg->xf_index); i++); + if(i == MAX_FADE_CONFIGS) i=0; + SET_HISTORY("xf_config_optionmenu", i); + } + + if(mask & XF_TYPE) { + create_crossfader_type_menu(); + for(i=0; i<MAX_FADE_TYPES && (xf_type_index_map[i] != fc->type); i++); + if(i == MAX_FADE_TYPES) { + fc->type = FADE_TYPE_NONE; + for(i=0; i<MAX_FADE_TYPES && (xf_type_index_map[i] != fc->type); i++); + if(i == MAX_FADE_CONFIGS) i=0; + } + SET_HISTORY("xf_type_optionmenu", i); + } + + if(mask & XF_PAGE) { + SET_PAGE("xf_type_notebook", fc->type); + SET_SPIN("pause_length_spin", fc->pause_len_ms); + SET_SPIN("simple_length_spin", fc->simple_len_ms); + if(fc->config == FADE_CONFIG_SEEK) { + HIDE("xftf_pause_frame"); + HIDE("xftf_fadein_frame"); + } + else { + SHOW("xftf_pause_frame"); + SHOW("xftf_fadein_frame"); + } + } + + if(mask & XF_FADEOUT) { + SET_TOGGLE ("fadeout_enable_check", fc->out_enable); + SET_SENSITIVE("fadeout_length_label", fc->out_enable); + SET_SENSITIVE("fadeout_length_spin", fc->out_enable); + SET_SPIN ("fadeout_length_spin", fc->out_len_ms); + SET_SENSITIVE("fadeout_volume_label", fc->out_enable); + SET_SENSITIVE("fadeout_volume_spin", fc->out_enable); + SET_SPIN ("fadeout_volume_spin", fc->out_volume); + SET_SPIN ("xftfo_length_spin", fc->out_len_ms); + SET_SPIN ("xftfo_volume_spin", fc->out_volume); + SET_SPIN ("xftfoi_fadeout_spin", fc->out_len_ms); + } + + if(mask & XF_FADEIN) { + SET_TOGGLE ("fadein_lock_check", fc->in_locked); + SET_SENSITIVE("fadein_enable_check", !fc->in_locked); + SET_TOGGLE ("fadein_enable_check", fc->in_locked ? fc->out_enable : fc->in_enable); + SET_SENSITIVE("fadein_length_label", !fc->in_locked && fc->in_enable); + SET_SENSITIVE("fadein_length_spin", !fc->in_locked && fc->in_enable); + SET_SPIN ("fadein_length_spin", fc->in_locked ? fc->out_len_ms : fc->in_len_ms); + SET_SENSITIVE("fadein_volume_label", !fc->in_locked && fc->in_enable); + SET_SENSITIVE("fadein_volume_spin", !fc->in_locked && fc->in_enable); + SET_SPIN ("fadein_volume_spin", fc->in_locked ? fc->out_volume : fc->in_volume); + SET_SPIN ("xftfi_length_spin", fc->in_len_ms); + SET_SPIN ("xftfi_volume_spin", fc->in_volume); + SET_SPIN ("xftfoi_fadein_spin", fc->in_len_ms); + } + + if(mask & XF_OFFSET) { + if(fc->out_enable) + SET_SENSITIVE("xfofs_lockout_radiobutton", TRUE); + if(!fc->in_locked && fc->in_enable) + SET_SENSITIVE("xfofs_lockin_radiobutton", TRUE); + + switch(fc->ofs_type) { + case FC_OFFSET_LOCK_OUT: + if(!fc->out_enable) { + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + } + break; + case FC_OFFSET_LOCK_IN: + if(!(!fc->in_locked && fc->in_enable)) { + if((fc->in_locked && fc->out_enable)) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } else { + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + } + } + break; + } + + switch(fc->ofs_type_wanted) { + case FC_OFFSET_NONE: + SET_TOGGLE("xfofs_none_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_NONE; + break; + case FC_OFFSET_LOCK_OUT: + if(fc->out_enable) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } + break; + case FC_OFFSET_LOCK_IN: + if(!fc->in_locked && fc->in_enable) { + SET_TOGGLE("xfofs_lockin_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_IN; + } + else if(fc->out_enable) { + SET_TOGGLE("xfofs_lockout_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_LOCK_OUT; + } + break; + case FC_OFFSET_CUSTOM: + SET_TOGGLE("xfofs_custom_radiobutton", TRUE); + fc->ofs_type = FC_OFFSET_CUSTOM; + break; + } + + if(!fc->out_enable) + SET_SENSITIVE("xfofs_lockout_radiobutton", FALSE); + if(!(!fc->in_locked && fc->in_enable)) + SET_SENSITIVE("xfofs_lockin_radiobutton", FALSE); + + SET_SENSITIVE("xfofs_custom_spin", fc->ofs_type == FC_OFFSET_CUSTOM); + SET_SPIN ("xfofs_custom_spin", xfade_cfg_offset(fc)); + SET_SPIN ("xftfo_silence_spin", xfade_cfg_offset(fc)); + SET_SPIN ("xftfoi_silence_spin", xfade_cfg_offset(fc)); + } + + checking = FALSE; +} + +/*-- crossfader callbacks ---------------------------------------------------*/ + +void on_xf_buffer_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->mix_size_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(NONE); +} + +void on_xf_autobuf_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + cfg->mix_size_auto = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - config/type - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void xf_config_cb(GtkWidget *widget, gint index) +{ + if(checking) return; + cfg->xf_index = index; + check_crossfader_dependencies(ANY & ~XF_CONFIG); +} + +void xf_type_cb(GtkWidget *widget, gint index) +{ + if(checking) return; + cfg->fc[cfg->xf_index].type = index; + check_crossfader_dependencies(ANY & ~XF_CONFIG); +} + +/* - flush - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_xftfp_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_pause_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_FLUSH|XF_MIX_SIZE); +} + +void on_xftfp_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_pause_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +void on_xftffi_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_FLUSH|XF_OFFSET|XF_FADEOUT|XF_FADEIN); +} + +void on_xftffi_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +void on_xftffi_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].flush_in_volume + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_FLUSH); +} + +/* - pause - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_pause_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].pause_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - simple - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_simple_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].simple_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - crossfade-fadeout - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_fadeout_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].out_enable + = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET|XF_FADEOUT|XF_FADEIN); +} + +void on_fadeout_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].out_len_ms + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET|XF_FADEIN); +} + +void on_fadeout_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + cfg->fc[cfg->xf_index].out_volume + = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +/* - crossfade-offset - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_xfofs_none_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_NONE; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_NONE; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_none_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_NONE; +} + +void on_xfofs_lockout_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_LOCK_OUT; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_OUT; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_lockout_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_OUT; +} + +void on_xfofs_lockin_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_LOCK_IN; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_IN; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_lockin_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_LOCK_IN; +} + +void on_xfofs_custom_radiobutton_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking || !gtk_toggle_button_get_active(togglebutton)) return; + cfg->fc[cfg->xf_index].ofs_type = FC_OFFSET_CUSTOM; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_CUSTOM; + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_xfofs_custom_radiobutton_clicked(GtkButton *button, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_type_wanted = FC_OFFSET_CUSTOM; +} + +void on_xfofs_custom_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].ofs_custom_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE); +} + +/* - crossfade-fadein - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ + +void on_fadein_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_locked = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +void on_fadein_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_enable = gtk_toggle_button_get_active(togglebutton); + check_crossfader_dependencies(XF_OFFSET|XF_FADEIN); +} + +void on_fadein_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(XF_MIX_SIZE|XF_OFFSET); +} + +void on_fadein_volume_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->fc[cfg->xf_index].in_volume = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_crossfader_dependencies(NONE); +} + +/*-- fadein -----------------------------------------------------------------*/ + +/* signal set to on_fadein_length_spin_changed */ +/* signal set to on_fadein_volume_spin_changed */ + +/*-- fadeout ----------------------------------------------------------------*/ + +/* signal set to on_fadeout_length_spin_changed */ +/* signal set to on_fadeout_volume_spin_changed */ + +/*-- fadeout/fadein ---------------------------------------------------------*/ + +/* signal set to on_fadeout_length_spin_changed */ +/* signal set to on_xfofs_custom_spin_changed */ +/* signal set to on_fadeout_volume_spin_changed */ + +/*** gap killer **************************************************************/ + +void check_gapkiller_dependencies() +{ + if(checking) return; + checking = TRUE; + + SET_SENSITIVE("lgap_length_spin", cfg->gap_lead_enable); + SET_SENSITIVE("lgap_level_spin", cfg->gap_lead_enable); + SET_SENSITIVE("tgap_enable_check", !cfg->gap_trail_locked); + SET_SENSITIVE("tgap_length_spin", !cfg->gap_trail_locked && cfg->gap_trail_enable); + SET_SENSITIVE("tgap_level_spin", !cfg->gap_trail_locked && cfg->gap_trail_enable); + + if(cfg->gap_trail_locked) { + SET_TOGGLE("tgap_enable_check", cfg->gap_lead_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_lead_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_lead_level); + } + else { + SET_TOGGLE("tgap_enable_check", cfg->gap_trail_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_trail_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_trail_level); + } + + if(cfg->mix_size_auto) + SET_SPIN("xf_buffer_spin", xfade_mix_size_ms(cfg)); + + checking = FALSE; +} + +/*-- gapkiller callbacks ----------------------------------------------------*/ + +void on_lgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_enable = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_lgap_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_gapkiller_dependencies(); +} + +void on_lgap_level_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_lead_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_gapkiller_dependencies(); +} + +void on_tgap_lock_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_locked = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_tgap_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_enable = gtk_toggle_button_get_active(togglebutton); + check_gapkiller_dependencies(); +} + +void on_tgap_length_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_len_ms = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +void on_tgap_level_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->gap_trail_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); +} + +/*** misc ********************************************************************/ + +void check_misc_dependencies() +{ + if(checking) return; + checking = TRUE; + + if(cfg->mix_size_auto) + SET_SPIN("xf_buffer_spin", xfade_mix_size_ms(cfg)); + + SET_SENSITIVE("moth_opmaxused_spin", cfg->enable_op_max_used); + + checking = FALSE; +} + +/*-- misc callbacks ---------------------------------------------------------*/ + +void on_config_mixopt_enable_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + SET_SENSITIVE("mixopt_reverse_check", gtk_toggle_button_get_active(togglebutton)); + SET_SENSITIVE("mixopt_software_check", gtk_toggle_button_get_active(togglebutton)); +} + +void on_moth_songchange_spin_changed(GtkEditable *editable, gpointer user_data) +{ + if(checking) return; + cfg->songchange_timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(editable)); + check_misc_dependencies(); +} + +void on_moth_opmaxused_check_toggled(GtkToggleButton *togglebutton, gpointer user_data) +{ + if(checking) return; + cfg->enable_op_max_used = gtk_toggle_button_get_active(togglebutton); + check_misc_dependencies(); +} + +/*** presets *****************************************************************/ + +void on_presets_list_click_column(GtkCList *clist, gint column, gpointer user_data) +{ + DEBUG(("*** column=%d\n", column)); +} + +/*** main config *************************************************************/ + +void on_config_apply_clicked(GtkButton *button, gpointer user_data) +{ + GtkWidget *widget; + + /* get current notebook page */ + if((widget = lookup_widget(config_win, "config_notebook"))) + cfg->page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget)); + + /* output method */ + + /* sample rate */ + + /* output method: builtin OSS */ + if((widget = lookup_widget(config_win, "output_oss_notebook"))) + cfg->oss_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(widget)); + + if((widget = lookup_widget(config_win, "oss_adevice_alt_entry"))) { + if(cfg->oss_alt_audio_device) g_free(cfg->oss_alt_audio_device); + cfg->oss_alt_audio_device = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1); + g_strstrip(cfg->oss_alt_audio_device); + } + + if((widget = lookup_widget(config_win, "oss_mdevice_alt_entry"))) { + if(cfg->oss_alt_mixer_device) g_free(cfg->oss_alt_mixer_device); + cfg->oss_alt_mixer_device = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1); + g_strstrip(cfg->oss_alt_mixer_device); + } + + cfg->oss_buffer_size_ms = GET_SPIN ("ossbuf_buffer_spin"); + cfg->oss_preload_size_ms = GET_SPIN ("ossbuf_preload_spin"); + + cfg->oss_fragments = GET_SPIN ("osshwb_fragments_spin"); + cfg->oss_fragment_size = GET_SPIN ("osshwb_fragsize_spin"); + cfg->oss_maxbuf_enable = GET_TOGGLE("osshwb_maxbuf_check"); + + cfg->oss_mixer_use_master = GET_TOGGLE("ossmixer_pcm_check"); + + /* output method: plugin */ + op_config.throttle_enable = GET_TOGGLE("op_throttle_check"); + op_config.max_write_enable = GET_TOGGLE("op_maxblock_check"); + op_config.max_write_len = GET_SPIN ("op_maxblock_spin"); + op_config.force_reopen = GET_TOGGLE("op_forcereopen_check"); + + xfade_save_plugin_config(&cfg->op_config_string, cfg->op_name, &op_config); + + /* output method: none: */ + + /* effects: pre-mixing effect plugin */ + + /* effects: volume normalizer */ + cfg->volnorm_target = GET_SPIN ("volnorm_target_spin"); + cfg->volnorm_use_qa = GET_TOGGLE("volnorm_quantaudio_check"); + + /* crossfader */ + cfg->mix_size_auto = GET_TOGGLE("xf_autobuf_check"); + + /* gap killer */ + cfg->gap_lead_enable = GET_TOGGLE("lgap_enable_check"); + cfg->gap_lead_len_ms = GET_SPIN ("lgap_length_spin"); + cfg->gap_lead_level = GET_SPIN ("lgap_level_spin"); + + cfg->gap_trail_locked = GET_TOGGLE("tgap_lock_check"); + + cfg->gap_crossing = GET_TOGGLE("gadv_crossing_check"); + + /* misc */ + cfg->enable_debug = GET_TOGGLE("debug_stderr_check"); + cfg->enable_monitor = GET_TOGGLE("debug_monitor_check"); + cfg->enable_mixer = GET_TOGGLE("mixopt_enable_check"); + cfg->mixer_reverse = GET_TOGGLE("mixopt_reverse_check"); + cfg->mixer_software = GET_TOGGLE("mixopt_software_check"); + cfg->preload_size_ms = GET_SPIN ("moth_preload_spin"); + cfg->album_detection = GET_TOGGLE("noxf_album_check"); + cfg->no_xfade_if_same_file = GET_TOGGLE("noxf_samefile_check"); + cfg->enable_http_workaround = GET_TOGGLE("moth_httpworkaround_check"); + cfg->op_max_used_ms = GET_SPIN ("moth_opmaxused_spin"); + cfg->output_keep_opened = GET_TOGGLE("moth_outputkeepopened_check"); + + /* presets */ + + /* lock buffer */ + g_static_mutex_lock(&buffer_mutex); + + /* free existing strings */ + if(config->oss_alt_audio_device) g_free(config->oss_alt_audio_device); + if(config->oss_alt_mixer_device) g_free(config->oss_alt_mixer_device); + if(config->op_config_string) g_free(config->op_config_string); + if(config->op_name) g_free(config->op_name); + if(config->ep_name) g_free(config->ep_name); + + /* copy current settings (dupping the strings) */ + *config = *cfg; + config->oss_alt_audio_device = g_strdup(cfg->oss_alt_audio_device); + config->oss_alt_mixer_device = g_strdup(cfg->oss_alt_mixer_device); + config->op_config_string = g_strdup(cfg->op_config_string); + config->op_name = g_strdup(cfg->op_name); + config->ep_name = g_strdup(cfg->ep_name); + + /* tell the engine that the config has changed */ + xfade_realize_config(); + + /* unlock buffer */ + g_static_mutex_unlock(&buffer_mutex); + + /* save configuration */ + xfade_save_config(); + + /* show/hide monitor win depending on config->enable_monitor */ + xfade_check_monitor_win(); +} + +void on_config_ok_clicked(GtkButton *button, gpointer user_data) +{ + /* apply and save config */ + on_config_apply_clicked(button, user_data); + + /* close and destroy window */ + gtk_widget_destroy(config_win); +} + +void xfade_configure() +{ + GtkWidget *widget; + + if(!config_win) { + /* create */ + if(!(config_win = create_config_win())) { + DEBUG(("[crossfade] plugin_configure: error creating window!\n")); + return; + } + + /* update config_win when window is destroyed */ + gtk_signal_connect(GTK_OBJECT(config_win), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &config_win); + + /* free any strings that might be left in our local copy of the config */ + if(cfg->oss_alt_audio_device) g_free(cfg->oss_alt_audio_device); + if(cfg->oss_alt_mixer_device) g_free(cfg->oss_alt_mixer_device); + if(cfg->op_config_string) g_free(cfg->op_config_string); + if(cfg->op_name) g_free(cfg->op_name); + if(cfg->ep_name) g_free(cfg->ep_name); + + /* copy current settings (dupping the strings) */ + *cfg = *config; + cfg->oss_alt_audio_device = g_strdup(config->oss_alt_audio_device); + cfg->oss_alt_mixer_device = g_strdup(config->oss_alt_mixer_device); + cfg->op_config_string = g_strdup(config->op_config_string); + cfg->op_name = g_strdup(config->op_name); + cfg->ep_name = g_strdup(config->ep_name); + + /* go to remembered notebook page */ + if((widget = lookup_widget(config_win, "config_notebook"))) + gtk_notebook_set_page(GTK_NOTEBOOK(widget), config->page); + + /* output: method */ +#ifdef HAVE_OSS + SET_SENSITIVE("output_oss_radio", TRUE); +#else + SET_SENSITIVE("output_oss_radio", FALSE); +#endif + + switch(cfg->output_method) { + case OUTPUT_METHOD_BUILTIN_OSS: + widget = lookup_widget(config_win, "output_oss_radio"); + break; + case OUTPUT_METHOD_PLUGIN: + widget = lookup_widget(config_win, "output_plugin_radio"); + break; + case OUTPUT_METHOD_BUILTIN_NULL: + widget = lookup_widget(config_win, "output_none_radio"); + break; + default: + widget = NULL; + } + if(widget) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE); + + if((widget = lookup_widget(config_win, "output_notebook"))) + gtk_notebook_set_page(GTK_NOTEBOOK(widget), cfg->output_method); + + /* output: resampling rate */ + if((widget = lookup_widget(config_win, "resampling_rate_optionmenu"))) { + GtkWidget *menu = gtk_menu_new(); + GtkWidget *item; + + item = gtk_menu_item_new_with_label("44100 Hz"); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(resampling_rate_cb), (gpointer)44100); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + item = gtk_menu_item_new_with_label("48000 Hz"); + gtk_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(resampling_rate_cb), (gpointer)48000); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + gtk_option_menu_set_menu(GTK_OPTION_MENU(widget), menu); + + switch(cfg->output_rate) { + default: + DEBUG(("[crossfade] plugin_configure: WARNING: invalid output sample rate (%d)!\n", cfg->output_rate)); + DEBUG(("[crossfade] plugin_configure: ... using default of 44100\n")); + cfg->output_rate = 44100; + case 44100: gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 0); break; + case 48000: gtk_option_menu_set_history(GTK_OPTION_MENU(widget), 1); break; + } + } + + /* output: resampling quality (libsamplerate setting) */ +#ifdef HAVE_LIBSAMPLERATE + if((widget = lookup_widget(config_win, "resampling_quality_optionmenu"))) { + GtkWidget *menu = gtk_menu_new(); + GtkWidget *item; + + GtkTooltips *tooltips = (GtkTooltips *)gtk_object_get_data(GTK_OBJECT(config_win), "tooltips"); + + int converter_type; + const char *name, *description; + for(converter_type = 0; (name = src_get_name(converter_type)); + converter_type++) { + description = src_get_description(converter_type); + + item = gtk_menu_item_new_with_label(name); + gtk_tooltips_set_tip(tooltips, item, description, NULL); + + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(resampling_quality_cb), (gpointer)converter_type); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + } + + gtk_option_menu_set_menu (GTK_OPTION_MENU(widget), menu); + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), cfg->output_quality); + } +#else + HIDE("resampling_quality_hbox"); + HIDE("resampling_quality_optionmenu"); +#endif + + /* output method: builtin OSS */ + if((widget = lookup_widget(config_win, "output_oss_notebook"))) + gtk_notebook_set_page(GTK_NOTEBOOK(widget), cfg->oss_page); + + if((widget = lookup_widget(config_win, "oss_adevice_optionmenu"))) { + scan_devices("Audio devices:", widget, config_adevice_cb); + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), + cfg->oss_audio_device); + gtk_widget_set_sensitive(widget, !cfg->oss_use_alt_audio_device); + } + SET_TOGGLE("oss_adevice_alt_check", cfg->oss_use_alt_audio_device); + if((widget = lookup_widget(config_win, "oss_adevice_alt_entry"))) { + gtk_entry_set_text(GTK_ENTRY(widget), cfg->oss_alt_audio_device + ? cfg->oss_alt_audio_device + : DEFAULT_OSS_ALT_AUDIO_DEVICE); + gtk_widget_set_sensitive(widget, cfg->oss_use_alt_audio_device); + } + + if((widget = lookup_widget(config_win, "oss_mdevice_optionmenu"))) { + scan_devices("Mixers:", widget, config_mdevice_cb); + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), + cfg->oss_mixer_device); + gtk_widget_set_sensitive(widget, !cfg->oss_use_alt_mixer_device); + } + SET_TOGGLE("oss_mdevice_alt_check", cfg->oss_use_alt_mixer_device); + if((widget = lookup_widget(config_win, "oss_mdevice_alt_entry"))) { + gtk_entry_set_text(GTK_ENTRY(widget), cfg->oss_alt_mixer_device + ? cfg->oss_alt_mixer_device + : DEFAULT_OSS_ALT_MIXER_DEVICE); + gtk_widget_set_sensitive(widget, cfg->oss_use_alt_mixer_device); + } + + SET_SPIN ("ossbuf_buffer_spin", cfg->oss_buffer_size_ms); + SET_SPIN ("ossbuf_preload_spin", cfg->oss_preload_size_ms); + + SET_SPIN ("osshwb_fragments_spin", cfg->oss_fragments); + SET_SPIN ("osshwb_fragsize_spin", cfg->oss_fragment_size); + SET_TOGGLE("osshwb_maxbuf_check", cfg->oss_maxbuf_enable); + + SET_TOGGLE("ossmixer_pcm_check", cfg->oss_mixer_use_master); + + check_oss_dependencies(); + + /* output method: plugin */ + xfade_load_plugin_config(cfg->op_config_string, cfg->op_name, &op_config); + SET_TOGGLE ("op_throttle_check", op_config.throttle_enable); + SET_TOGGLE ("op_maxblock_check", op_config.max_write_enable); + SET_SPIN ("op_maxblock_spin", op_config.max_write_len); + SET_SENSITIVE("op_maxblock_spin", op_config.max_write_enable); + SET_TOGGLE ("op_forcereopen_check", op_config.force_reopen); + + if((widget = lookup_widget(config_win, "op_plugin_optionmenu"))) { + OutputPlugin *op = NULL; + if((op_index = scan_plugins(widget, cfg->op_name)) >= 0) { + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), op_index); + op = g_list_nth_data(get_output_list(), op_index); /* XMMS */ + } + SET_SENSITIVE("op_configure_button", op && (op->configure != NULL)); + SET_SENSITIVE("op_about_button", op && (op->about != NULL)); + } + + /* output method: none */ + + /* effects: pre-mixing effect plugin */ + if((widget = lookup_widget(config_win, "ep_plugin_optionmenu"))) { + EffectPlugin *ep = NULL; + if((ep_index = scan_effect_plugins(widget, cfg->ep_name)) >= 0) { + gtk_option_menu_set_history(GTK_OPTION_MENU(widget), ep_index); + ep = g_list_nth_data(get_effect_list(), ep_index); /* XMMS */ + } + SET_SENSITIVE("ep_configure_button", ep && (ep->configure != NULL)); + SET_SENSITIVE("ep_about_button", ep && (ep->about != NULL)); + SET_TOGGLE ("ep_enable_check", cfg->ep_enable); + } + + /* effects: volume normalizer */ + SET_TOGGLE("volnorm_enable_check", cfg->volnorm_enable); + SET_TOGGLE("volnorm_quantaudio_check", cfg->volnorm_use_qa); + SET_SPIN ("volnorm_target_spin", cfg->volnorm_target); + + check_effects_dependencies(); + + /* crossfader */ + create_crossfader_config_menu(); + + if((cfg->xf_index < 0) || (cfg->xf_index >= MAX_FADE_CONFIGS)) { + DEBUG(("[crossfade] plugin_configure: crossfade index out of range (%d)!\n", cfg->xf_index)); + cfg->xf_index = CLAMP(cfg->xf_index, 0, MAX_FADE_CONFIGS); + } + + check_crossfader_dependencies(ANY); + + /* gap killer */ + SET_TOGGLE ("lgap_enable_check", cfg->gap_lead_enable); + SET_SPIN ("lgap_length_spin", cfg->gap_lead_len_ms); + SET_SPIN ("lgap_level_spin", cfg->gap_lead_level); + SET_TOGGLE ("tgap_lock_check", cfg->gap_trail_locked); + SET_TOGGLE ("tgap_enable_check", cfg->gap_trail_enable); + SET_SPIN ("tgap_length_spin", cfg->gap_trail_len_ms); + SET_SPIN ("tgap_level_spin", cfg->gap_trail_level); + SET_TOGGLE ("gadv_crossing_check", cfg->gap_crossing); + + check_gapkiller_dependencies(); + + /* misc */ + SET_TOGGLE("debug_stderr_check", cfg->enable_debug); + SET_TOGGLE("debug_monitor_check", cfg->enable_monitor); + SET_TOGGLE("mixopt_enable_check", cfg->enable_mixer); + SET_TOGGLE("mixopt_reverse_check", cfg->mixer_reverse); + SET_TOGGLE("mixopt_software_check", cfg->mixer_software); + SET_SPIN ("moth_songchange_spin", cfg->songchange_timeout); + SET_SPIN ("moth_preload_spin", cfg->preload_size_ms); + SET_TOGGLE("noxf_album_check", cfg->album_detection); + SET_TOGGLE("noxf_samefile_check", cfg->album_detection); + SET_TOGGLE("moth_httpworkaround_check", cfg->enable_http_workaround); + SET_TOGGLE("moth_opmaxused_check", cfg->enable_op_max_used); + SET_SPIN ("moth_opmaxused_spin", cfg->op_max_used_ms); + SET_TOGGLE("moth_outputkeepopened_check", cfg->output_keep_opened); + + check_misc_dependencies(); + + /* presets */ + if((set_wgt = lookup_widget(config_win, "presets_list_list"))) { + GList *item; + + for(item = config->presets; item; item = g_list_next(item)) { + gchar *name = (gchar *)item->data; + gchar *text[] = {name, "Default", "No"}; + gtk_clist_append(GTK_CLIST(set_wgt), text); + } + } + + /* show window near mouse pointer */ + gtk_window_set_position(GTK_WINDOW(config_win), GTK_WIN_POS_MOUSE); + gtk_widget_show(config_win); + } + else + /* bring window to front */ + gdk_window_raise(config_win->window); +} + +void xfade_about() +{ + if(!about_win) { + gchar *about_text = + "XMMS Crossfade Plugin "VERSION"\n" + "Copyright (C) 2000-2004 Peter Eisenlohr <peter@eisenlohr.org>\n" + "\n" + "based on the original OSS Output Plugin Copyright (C) 1998-2000\n" + "Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies\n" + "\n" + "This program is free software; you can redistribute it and/or modify\n" + "it under the terms of the GNU General Public License as published by\n" + "the Free Software Foundation; either version 2 of the License, or\n" + "(at your option) any later version.\n" + "\n" + "This program is distributed in the hope that it will be useful,\n" + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "GNU General Public License for more details.\n" + "\n" + "You should have received a copy of the GNU General Public License\n" + "along with this program; if not, write to the Free Software\n" + "Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,\n" + "USA."; + + about_win = create_about_win(); + + /* update about_win when window is destroyed */ + gtk_signal_connect(GTK_OBJECT(about_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &about_win); + + /* set about box text (this is done here and not in interface.c because + of the VERSION #define -- there is no way to do this with GLADE */ + if((set_wgt = lookup_widget(about_win, "about_label"))) + gtk_label_set_text(GTK_LABEL(set_wgt), about_text); + + /* show near mouse pointer */ + gtk_window_set_position(GTK_WINDOW(about_win), GTK_WIN_POS_MOUSE); + gtk_widget_show(about_win); + } + else + gdk_window_raise(about_win->window); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/configure.h Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,55 @@ +/* + * XMMS Crossfade Plugin + * Copyright (C) 2000-2004 Peter Eisenlohr <peter@eisenlohr.org> + * + * based on the original OSS Output Plugin + * Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifndef _CONFIGURE_H_ +#define _CONFIGURE_H_ + +#include "crossfade.h" + +void xfade_load_config(); +void xfade_save_config(); +void xfade_free_config(); + +void xfade_load_plugin_config(gchar *config_string, gchar *plugin_name, + plugin_config_t *plugin_config); +void xfade_save_plugin_config(gchar **config_string, gchar *plugin_name, + plugin_config_t *plugin_confg); + +/* some helper functions */ +gint xfade_mix_size_ms(config_t *cfg); + +gint xfade_cfg_fadeout_len (fade_config_t *fc); +gint xfade_cfg_fadeout_volume(fade_config_t *fc); +gint xfade_cfg_offset (fade_config_t *fc); +gint xfade_cfg_fadein_len (fade_config_t *fc); +gint xfade_cfg_fadein_volume (fade_config_t *fc); + +gboolean xfade_cfg_gap_trail_enable(config_t *cfg); +gint xfade_cfg_gap_trail_len (config_t *cfg); +gint xfade_cfg_gap_trail_level (config_t *cfg); + +/* xmms callback prototypes */ +void xfade_about (); +void xfade_configure(); + +#endif /* _CONFIGURE_H_ */
--- a/Plugins/Output/crossfade/crossfade.c Tue Dec 06 14:02:16 2005 -0800 +++ b/Plugins/Output/crossfade/crossfade.c Tue Dec 06 16:09:32 2005 -0800 @@ -36,9 +36,6 @@ #include "rate.h" #include "volume.h" #include "timing.h" -#ifdef HAVE_LIBFFTW -# include "fft.h" -#endif #include <stdio.h> #include <string.h> @@ -106,11 +103,7 @@ static gboolean *xmms_is_quitting = NULL; /* XMMS */ static gboolean (*input_stopped_for_restart)() = NULL; /* XMMS */ -#ifdef HAVE_CTOR void fini() __attribute__((destructor)); -#else -void _fini() { fini(); } -#endif /* local variables */ static gint session_id; @@ -200,9 +193,6 @@ static convert_context_t convert_context; static rate_context_t rate_context; static volume_context_t volume_context; -#ifdef HAVE_LIBFFTW -static fft_context_t fft_context; -#endif static config_t the_config; config_t *config = &the_config; @@ -456,9 +446,6 @@ convert_init(&convert_context); rate_init(&rate_context); volume_init(&volume_context); -#ifdef HAVE_LIBFFTW - fft_init(&fft_context); -#endif /* reset */ stopped = FALSE; @@ -570,9 +557,6 @@ g_static_mutex_unlock (&buffer_mutex); /* free contexts */ -#ifdef HAVE_LIBFFTW - fft_free(&fft_context); -#endif volume_free(&volume_context); rate_free(&rate_context); convert_free(&convert_context); @@ -1728,11 +1712,6 @@ && (blen > the_op_config.max_write_len)) blen = the_op_config.max_write_len; -#ifdef HAVE_LIBFFTW - /* fft playground */ - fft_flow(&fft_context, (gpointer)data, blen); -#endif - /* finally, write data */ the_op->write_audio(data, blen);
--- a/Plugins/Output/crossfade/crossfade.h Tue Dec 06 14:02:16 2005 -0800 +++ b/Plugins/Output/crossfade/crossfade.h Tue Dec 06 16:09:32 2005 -0800 @@ -335,11 +335,7 @@ /* xmms internal prototypes */ /* XMMS */ gint ctrlsocket_get_session_id(); -#ifndef HAVE_BEEP -gboolean get_input_playing(); -#else gboolean bmp_playback_get_playing(); -#endif GList *get_output_list(); GList *get_effect_list(); gint get_playlist_position();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/interface-2.0.c Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,2891 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <string.h> +#include <stdio.h> + +#include <gdk/gdkkeysyms.h> +#include <gtk/gtk.h> + +#include "callbacks.h" +#include "interface-2.0.h" +#include "support-2.0.h" + +#define GLADE_HOOKUP_OBJECT(component,widget,name) \ + g_object_set_data_full (G_OBJECT (component), name, \ + gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref) + +#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \ + g_object_set_data (G_OBJECT (component), name, widget) + +GtkWidget* +create_config_win (void) +{ + GtkWidget *config_win; + GtkWidget *config_vbox; + GtkWidget *config_notebook; + GtkWidget *config_output_page; + GtkWidget *output_options_hbox; + GtkWidget *output_method_frame; + GtkWidget *output_method_vbox; + GtkWidget *output_oss_radio; + GSList *output_oss_radio_group = NULL; + GtkWidget *output_plugin_radio; + GtkWidget *output_none_radio; + GtkWidget *label1; + GtkWidget *output_resampling_frame; + GtkWidget *output_resampling_table; + GtkWidget *resampling_rate_hbox; + GtkWidget *resampling_rate_label; + GtkWidget *resampling_quality_hbox; + GtkWidget *resampling_quality_label; + GtkWidget *resampling_rate_optionmenu; + GtkWidget *resampling_quality_optionmenu; + GtkWidget *output_resampling_label; + GtkWidget *output_notebook; + GtkWidget *output_oss_page; + GtkWidget *output_oss_notebook; + GtkWidget *oss_device_page; + GtkWidget *oss_adevice_frame; + GtkWidget *oss_adevice_vbox; + GtkWidget *oss_adevice_hbox; + GtkWidget *oss_adevice_optionmenu; + GtkWidget *convertwidget1; + GtkWidget *convertwidget2; + GtkWidget *oss_adevice_alt_hbox; + GtkWidget *oss_adevice_alt_check; + GtkWidget *oss_adevice_alt_entry; + GtkWidget *label3; + GtkWidget *oss_mdevice_frame; + GtkWidget *oss_mdevice_vbox; + GtkWidget *oss_mdevice_hbox; + GtkWidget *oss_mdevice_optionmenu; + GtkWidget *convertwidget3; + GtkWidget *convertwidget4; + GtkWidget *oss_mdevice_alt_hbox; + GtkWidget *oss_mdevice_alt_check; + GtkWidget *oss_mdevice_alt_entry; + GtkWidget *label4; + GtkWidget *oss_device_label; + GtkWidget *oss_buffer_page; + GtkWidget *oss_buffer_frame; + GtkWidget *oss_buffer_vbox; + GtkWidget *ossbuf_buffer_hbox; + GtkWidget *ossbuf_buffer_label; + GtkObject *ossbuf_buffer_spin_adj; + GtkWidget *ossbuf_buffer_spin; + GtkWidget *ossbuf_preload_hbox; + GtkWidget *ossbuf_preload_label; + GtkObject *ossbuf_preload_spin_adj; + GtkWidget *ossbuf_preload_spin; + GtkWidget *label5; + GtkWidget *oss_hwbuf_frame; + GtkWidget *oss_hwbuf_vbox; + GtkWidget *osshwb_maxbuf_check; + GtkWidget *osshwb_fragments_hbox; + GtkWidget *osshwb_fragments_label; + GtkObject *osshwb_fragments_spin_adj; + GtkWidget *osshwb_fragments_spin; + GtkWidget *osshwb_fragsize_hbox; + GtkWidget *osshwb_fragsize_label; + GtkObject *osshwb_fragsize_spin_adj; + GtkWidget *osshwb_fragsize_spin; + GtkWidget *label6; + GtkWidget *oss_buffer_label; + GtkWidget *oss_mixer_page; + GtkWidget *oss_mixer_frame; + GtkWidget *oss_mixer_vbox; + GtkWidget *ossmixer_pcm_check; + GtkWidget *label7; + GtkWidget *oss_mixer_label; + GtkWidget *label29; + GtkWidget *output_plugin_page; + GtkWidget *op_plugin_frame; + GtkWidget *op_plugin_vbox; + GtkWidget *op_plugin_optionmenu; + GtkWidget *convertwidget5; + GtkWidget *convertwidget6; + GtkWidget *op_plugin_buttonbox; + GtkWidget *op_configure_button; + GtkWidget *op_about_button; + GtkWidget *label8; + GtkWidget *op_options_frame; + GtkWidget *op_options_vbox; + GtkWidget *op_throttle_check; + GtkWidget *op_maxblock_hbox; + GtkWidget *op_maxblock_check; + GtkObject *op_maxblock_spin_adj; + GtkWidget *op_maxblock_spin; + GtkWidget *op_forcereopen_check; + GtkWidget *label9; + GtkWidget *label31; + GtkWidget *empty_notebook_page; + GtkWidget *label32; + GtkWidget *label33; + GtkWidget *label34; + GtkWidget *output_help_label; + GtkWidget *config_devices_label; + GtkWidget *config_effects_page; + GtkWidget *ep_plugin_frame; + GtkWidget *ep_plugin_vbox; + GtkWidget *ep_plugin_optionmenu; + GtkWidget *convertwidget7; + GtkWidget *convertwidget8; + GtkWidget *ep_plugin_buttonbox; + GtkWidget *ep_configure_button; + GtkWidget *ep_about_button; + GtkWidget *ep_enable_check; + GtkWidget *label10; + GtkWidget *effects_volnorm_frame; + GtkWidget *effects_volnorm_table; + GtkWidget *volnorm_quantaudio_check; + GtkObject *volnorm_target_spin_adj; + GtkWidget *volnorm_target_spin; + GtkWidget *volnorm_target_hbox; + GtkWidget *volnorm_target_label; + GtkWidget *volnorm_enable_check; + GtkWidget *volnorm_rva2_check; + GtkWidget *label11; + GtkWidget *effects_help_label; + GtkWidget *config_effects_label; + GtkWidget *config_crossfader_page; + GtkWidget *xf_bufsize_hbox; + GtkWidget *xf_bufsize_label; + GtkObject *xf_buffer_spin_adj; + GtkWidget *xf_buffer_spin; + GtkWidget *xf_autobuf_check; + GtkWidget *xf_config_hbox; + GtkWidget *xf_config_label; + GtkWidget *xf_config_optionmenu; + GtkWidget *convertwidget9; + GtkWidget *convertwidget10; + GtkWidget *xf_type_hbox; + GtkWidget *xf_type_label; + GtkWidget *xf_type_optionmenu; + GtkWidget *convertwidget11; + GtkWidget *convertwidget12; + GtkWidget *xf_type_notebook; + GtkWidget *xft_reopen_label; + GtkWidget *xft_flush_page; + GtkWidget *xftf_pause_frame; + GtkWidget *xftf_pause_table; + GtkWidget *xftfp_length_label; + GtkObject *xftfp_length_spin_adj; + GtkWidget *xftfp_length_spin; + GtkWidget *xftfp_enable_check; + GtkWidget *label12; + GtkWidget *xftf_fadein_frame; + GtkWidget *xftf_fadein_table; + GtkWidget *xftffi_length_hbox; + GtkWidget *xftffi_length_label; + GtkWidget *xftffi_volume_hbox; + GtkWidget *xftffi_volume_label; + GtkObject *xftffi_length_spin_adj; + GtkWidget *xftffi_length_spin; + GtkWidget *xftffi_enable_check; + GtkObject *xftffi_volume_spin_adj; + GtkWidget *xftffi_volume_spin; + GtkWidget *label13; + GtkWidget *xft_flush_label; + GtkWidget *xft_none_label; + GtkWidget *xft_pause_page; + GtkWidget *xf_pause_frame; + GtkWidget *xf_pause_table; + GtkWidget *pause_length_hbox; + GtkWidget *pause_length_label; + GtkObject *pause_length_spin_adj; + GtkWidget *pause_length_spin; + GtkWidget *label14; + GtkWidget *xft_pause_label; + GtkWidget *xft_simplexf_page; + GtkWidget *xf_simple_frame; + GtkWidget *xf_simple_table; + GtkWidget *simple_length_hbox; + GtkWidget *simple_length_label; + GtkObject *simple_length_spin_adj; + GtkWidget *simple_length_spin; + GtkWidget *label15; + GtkWidget *xft_simplexf_label; + GtkWidget *xft_advancedxf_page; + GtkWidget *xf_fadeout_frame; + GtkWidget *xf_fadeout_table; + GtkWidget *fadeout_length_hbox; + GtkWidget *fadeout_length_label; + GtkObject *fadeout_length_spin_adj; + GtkWidget *fadeout_length_spin; + GtkWidget *fadeout_volume_hbox; + GtkWidget *fadeout_volume_label; + GtkObject *fadeout_volume_spin_adj; + GtkWidget *fadeout_volume_spin; + GtkWidget *fadeout_options_hbox; + GtkWidget *fadeout_enable_check; + GtkWidget *label16; + GtkWidget *xf_offset_frame; + GtkWidget *xf_offset_table; + GtkWidget *xfofs_custom_hbox; + GtkWidget *xfofs_custom_radiobutton; + GSList *xfofs_custom_radiobutton_group = NULL; + GtkObject *xfofs_custom_spin_adj; + GtkWidget *xfofs_custom_spin; + GtkWidget *xfofs_none_radiobutton; + GtkWidget *xfofs_lockout_radiobutton; + GtkWidget *xfofs_lockin_radiobutton; + GtkWidget *label17; + GtkWidget *xf_fadein_frame; + GtkWidget *xf_fadein_table; + GtkWidget *fadein_length_hbox; + GtkWidget *fadein_length_label; + GtkWidget *fadein_volume_hbox; + GtkWidget *fadein_volume_label; + GtkObject *fadein_length_spin_adj; + GtkWidget *fadein_length_spin; + GtkWidget *fadein_enable_check; + GtkWidget *fadein_lock_check; + GtkObject *fadein_volume_spin_adj; + GtkWidget *fadein_volume_spin; + GtkWidget *label18; + GtkWidget *xft_advancedxf_label; + GtkWidget *xft_fadein_page; + GtkWidget *xftfi_fadein_frame; + GtkWidget *xftfi_fadein_table; + GtkWidget *xftfi_length_hbox; + GtkWidget *xftfi_length_label; + GtkWidget *xftfi_volume_hbox; + GtkWidget *xftfi_volume_label; + GtkObject *xftfi_length_spin_adj; + GtkWidget *xftfi_length_spin; + GtkObject *xftfi_volume_spin_adj; + GtkWidget *xftfi_volume_spin; + GtkWidget *label19; + GtkWidget *xft_fadein_label; + GtkWidget *xft_fadeout_page; + GtkWidget *xftfo_fadeout_frame; + GtkWidget *xftfo_fadeout_table; + GtkWidget *xftfo_length_hbox; + GtkWidget *xftfo_length_label; + GtkObject *xftfo_length_spin_adj; + GtkWidget *xftfo_length_spin; + GtkWidget *xftfo_volume_hbox; + GtkWidget *xftfo_volume_label; + GtkObject *xftfo_volume_spin_adj; + GtkWidget *xftfo_volume_spin; + GtkWidget *label20; + GtkWidget *xftfo_silence_frame; + GtkWidget *xftfo_silence_table; + GtkWidget *xftfo_silence_hbox; + GtkWidget *xftfo_silence_label; + GtkObject *xftfo_silence_spin_adj; + GtkWidget *xftfo_silence_spin; + GtkWidget *label21; + GtkWidget *xft_fadeout_label; + GtkWidget *xft_pause_none_label; + GtkWidget *xft_pause_adv_page; + GtkWidget *xft_fadeoutin_frame; + GtkWidget *xft_fadeoutin_table; + GtkObject *xftfoi_fadeout_spin_adj; + GtkWidget *xftfoi_fadeout_spin; + GtkObject *xftfoi_silence_spin_adj; + GtkWidget *xftfoi_silence_spin; + GtkObject *xftfoi_fadein_spin_adj; + GtkWidget *xftfoi_fadein_spin; + GtkWidget *xftfoi_fadein_hbox; + GtkWidget *xftfoi_fadein_label; + GtkWidget *xftfoi_silence_hbox; + GtkWidget *xftfoi_silence_label; + GtkWidget *xftfoi_fadeout_hbox; + GtkWidget *xftfoi_fadeout_label; + GtkWidget *label22; + GtkWidget *xft_pause_adv_label; + GtkWidget *config_crossfade_label; + GtkWidget *config_gapkiller_page; + GtkWidget *gap_leading_frame; + GtkWidget *gap_leading_table; + GtkObject *lgap_length_spin_adj; + GtkWidget *lgap_length_spin; + GtkObject *lgap_level_spin_adj; + GtkWidget *lgap_level_spin; + GtkWidget *lgap_length_hbox; + GtkWidget *lgap_length_label; + GtkWidget *lgap_level_hbox; + GtkWidget *lgap_level_label; + GtkWidget *lgap_enable_check; + GtkWidget *label23; + GtkWidget *gap_trailing_frame; + GtkWidget *gap_trailing_table; + GtkWidget *tgap_length_hbox; + GtkWidget *tgap_length_label; + GtkWidget *tgap_level_hbox; + GtkWidget *tgap_level_label; + GtkObject *tgap_length_spin_adj; + GtkWidget *tgap_length_spin; + GtkObject *tgap_level_spin_adj; + GtkWidget *tgap_level_spin; + GtkWidget *tgap_lock_check; + GtkWidget *tgap_enable_check; + GtkWidget *label24; + GtkWidget *gap_advanced_frame; + GtkWidget *gap_advanced_vbox; + GtkWidget *gadv_crossing_check; + GtkWidget *label25; + GtkWidget *config_gapkiller_label; + GtkWidget *config_misc_page; + GtkWidget *misc_debug_frame; + GtkWidget *misc_debug_vbox; + GtkWidget *debug_stderr_check; + GtkWidget *debug_monitor_check; + GtkWidget *label26; + GtkWidget *misc_mixopt_frame; + GtkWidget *misc_mixopt_vbox; + GtkWidget *mixopt_enable_check; + GtkWidget *mixopt_reverse_check; + GtkWidget *mixopt_software_check; + GtkWidget *label27; + GtkWidget *misc_other_frame; + GtkWidget *misc_other_vbox; + GtkWidget *moth_songchange_hbox; + GtkWidget *moth_songchange_label; + GtkObject *moth_songchange_spin_adj; + GtkWidget *moth_songchange_spin; + GtkWidget *moth_preload_hbox; + GtkWidget *moth_preload_label; + GtkObject *moth_preload_spin_adj; + GtkWidget *moth_preload_spin; + GtkWidget *moth_noxf_hbox; + GtkWidget *moth_noxf_label; + GtkWidget *noxf_album_check; + GtkWidget *noxf_samefile_check; + GtkWidget *moth_httpworkaround_check; + GtkWidget *moth_opmaxused_hbox; + GtkWidget *moth_opmaxused_check; + GtkObject *moth_opmaxused_spin_adj; + GtkWidget *moth_opmaxused_spin; + GtkWidget *moth_quantaudio_check; + GtkWidget *moth_outputkeepopened_check; + GtkWidget *label28; + GtkWidget *config_misc_label; + GtkWidget *config_presets_page; + GtkWidget *presets_name_hbox; + GtkWidget *presets_name_entry; + GtkWidget *presets_delete_button; + GtkWidget *presets_new_button; + GtkWidget *presets_list_scrolledwindow; + GtkWidget *presets_list_list; + GtkWidget *presets_list_bbox; + GtkWidget *presets_load_button; + GtkWidget *presets_save_button; + GtkWidget *config_presets_label; + GtkWidget *config_bbox; + GtkWidget *config_ok; + GtkWidget *config_cancel; + GtkWidget *config_apply; + GtkTooltips *tooltips; + + tooltips = gtk_tooltips_new (); + + config_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (config_win), "Crossfade Configuration"); + + config_vbox = gtk_vbox_new (FALSE, 10); + gtk_widget_show (config_vbox); + gtk_container_add (GTK_CONTAINER (config_win), config_vbox); + gtk_container_set_border_width (GTK_CONTAINER (config_vbox), 10); + + config_notebook = gtk_notebook_new (); + gtk_widget_show (config_notebook); + gtk_box_pack_start (GTK_BOX (config_vbox), config_notebook, TRUE, TRUE, 0); + + config_output_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_output_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_output_page); + gtk_container_set_border_width (GTK_CONTAINER (config_output_page), 5); + + output_options_hbox = gtk_hbox_new (FALSE, 6); + gtk_widget_show (output_options_hbox); + gtk_box_pack_start (GTK_BOX (config_output_page), output_options_hbox, FALSE, TRUE, 0); + + output_method_frame = gtk_frame_new (NULL); + gtk_widget_show (output_method_frame); + gtk_box_pack_start (GTK_BOX (output_options_hbox), output_method_frame, TRUE, TRUE, 0); + + output_method_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (output_method_vbox); + gtk_container_add (GTK_CONTAINER (output_method_frame), output_method_vbox); + gtk_container_set_border_width (GTK_CONTAINER (output_method_vbox), 5); + + output_oss_radio = gtk_radio_button_new_with_mnemonic (NULL, "Builtin OSS driver"); + gtk_widget_show (output_oss_radio); + gtk_box_pack_start (GTK_BOX (output_method_vbox), output_oss_radio, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, output_oss_radio, "Use XMMS-crossfade's builtin OSS driver for output.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (output_oss_radio), output_oss_radio_group); + output_oss_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_oss_radio)); + + output_plugin_radio = gtk_radio_button_new_with_mnemonic (NULL, "Output plugin"); + gtk_widget_show (output_plugin_radio); + gtk_box_pack_start (GTK_BOX (output_method_vbox), output_plugin_radio, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, output_plugin_radio, "Use an existing plugin for output.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (output_plugin_radio), output_oss_radio_group); + output_oss_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_plugin_radio)); + + output_none_radio = gtk_radio_button_new_with_mnemonic (NULL, "None [not implemented]"); + gtk_box_pack_start (GTK_BOX (output_method_vbox), output_none_radio, FALSE, FALSE, 0); + gtk_widget_set_sensitive (output_none_radio, FALSE); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (output_none_radio), output_oss_radio_group); + output_oss_radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (output_none_radio)); + + label1 = gtk_label_new ("Output method"); + gtk_widget_show (label1); + gtk_frame_set_label_widget (GTK_FRAME (output_method_frame), label1); + + output_resampling_frame = gtk_frame_new (NULL); + gtk_widget_show (output_resampling_frame); + gtk_box_pack_start (GTK_BOX (output_options_hbox), output_resampling_frame, FALSE, FALSE, 0); + + output_resampling_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (output_resampling_table); + gtk_container_add (GTK_CONTAINER (output_resampling_frame), output_resampling_table); + gtk_container_set_border_width (GTK_CONTAINER (output_resampling_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (output_resampling_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (output_resampling_table), 2); + + resampling_rate_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (resampling_rate_hbox); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_rate_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + resampling_rate_label = gtk_label_new ("Rate:"); + gtk_widget_show (resampling_rate_label); + gtk_box_pack_end (GTK_BOX (resampling_rate_hbox), resampling_rate_label, FALSE, FALSE, 0); + + resampling_quality_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (resampling_quality_hbox); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_quality_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + resampling_quality_label = gtk_label_new ("Quality:"); + gtk_widget_show (resampling_quality_label); + gtk_box_pack_end (GTK_BOX (resampling_quality_hbox), resampling_quality_label, FALSE, FALSE, 0); + + resampling_rate_optionmenu = gtk_option_menu_new (); + gtk_widget_show (resampling_rate_optionmenu); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_rate_optionmenu, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + resampling_quality_optionmenu = gtk_option_menu_new (); + gtk_widget_show (resampling_quality_optionmenu); + gtk_table_attach (GTK_TABLE (output_resampling_table), resampling_quality_optionmenu, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + output_resampling_label = gtk_label_new ("Resampling"); + gtk_widget_show (output_resampling_label); + gtk_frame_set_label_widget (GTK_FRAME (output_resampling_frame), output_resampling_label); + + output_notebook = gtk_notebook_new (); + gtk_widget_show (output_notebook); + gtk_box_pack_start (GTK_BOX (config_output_page), output_notebook, FALSE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (output_notebook, GTK_CAN_FOCUS); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (output_notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (output_notebook), FALSE); + + output_oss_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (output_oss_page); + gtk_container_add (GTK_CONTAINER (output_notebook), output_oss_page); + + output_oss_notebook = gtk_notebook_new (); + gtk_widget_show (output_oss_notebook); + gtk_box_pack_start (GTK_BOX (output_oss_page), output_oss_notebook, FALSE, FALSE, 0); + + oss_device_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (oss_device_page); + gtk_container_add (GTK_CONTAINER (output_oss_notebook), oss_device_page); + gtk_container_set_border_width (GTK_CONTAINER (oss_device_page), 5); + + oss_adevice_frame = gtk_frame_new (NULL); + gtk_widget_show (oss_adevice_frame); + gtk_box_pack_start (GTK_BOX (oss_device_page), oss_adevice_frame, FALSE, FALSE, 0); + + oss_adevice_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (oss_adevice_vbox); + gtk_container_add (GTK_CONTAINER (oss_adevice_frame), oss_adevice_vbox); + gtk_container_set_border_width (GTK_CONTAINER (oss_adevice_vbox), 5); + + oss_adevice_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (oss_adevice_hbox); + gtk_box_pack_start (GTK_BOX (oss_adevice_vbox), oss_adevice_hbox, TRUE, TRUE, 0); + + oss_adevice_optionmenu = gtk_option_menu_new (); + gtk_widget_show (oss_adevice_optionmenu); + gtk_box_pack_start (GTK_BOX (oss_adevice_hbox), oss_adevice_optionmenu, TRUE, TRUE, 0); + + convertwidget1 = gtk_menu_new (); + + convertwidget2 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget2); + gtk_container_add (GTK_CONTAINER (convertwidget1), convertwidget2); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (oss_adevice_optionmenu), convertwidget1); + + oss_adevice_alt_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (oss_adevice_alt_hbox); + gtk_box_pack_start (GTK_BOX (oss_adevice_vbox), oss_adevice_alt_hbox, TRUE, TRUE, 0); + + oss_adevice_alt_check = gtk_check_button_new_with_mnemonic ("Use alternate device:"); + gtk_widget_show (oss_adevice_alt_check); + gtk_box_pack_start (GTK_BOX (oss_adevice_alt_hbox), oss_adevice_alt_check, FALSE, FALSE, 0); + + oss_adevice_alt_entry = gtk_entry_new (); + gtk_widget_show (oss_adevice_alt_entry); + gtk_box_pack_start (GTK_BOX (oss_adevice_alt_hbox), oss_adevice_alt_entry, TRUE, TRUE, 0); + + label3 = gtk_label_new ("Audio device"); + gtk_widget_show (label3); + gtk_frame_set_label_widget (GTK_FRAME (oss_adevice_frame), label3); + + oss_mdevice_frame = gtk_frame_new (NULL); + gtk_widget_show (oss_mdevice_frame); + gtk_box_pack_start (GTK_BOX (oss_device_page), oss_mdevice_frame, FALSE, FALSE, 0); + + oss_mdevice_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (oss_mdevice_vbox); + gtk_container_add (GTK_CONTAINER (oss_mdevice_frame), oss_mdevice_vbox); + gtk_container_set_border_width (GTK_CONTAINER (oss_mdevice_vbox), 5); + + oss_mdevice_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (oss_mdevice_hbox); + gtk_box_pack_start (GTK_BOX (oss_mdevice_vbox), oss_mdevice_hbox, TRUE, TRUE, 0); + + oss_mdevice_optionmenu = gtk_option_menu_new (); + gtk_widget_show (oss_mdevice_optionmenu); + gtk_box_pack_start (GTK_BOX (oss_mdevice_hbox), oss_mdevice_optionmenu, TRUE, TRUE, 0); + + convertwidget3 = gtk_menu_new (); + + convertwidget4 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget4); + gtk_container_add (GTK_CONTAINER (convertwidget3), convertwidget4); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (oss_mdevice_optionmenu), convertwidget3); + + oss_mdevice_alt_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (oss_mdevice_alt_hbox); + gtk_box_pack_start (GTK_BOX (oss_mdevice_vbox), oss_mdevice_alt_hbox, FALSE, FALSE, 0); + + oss_mdevice_alt_check = gtk_check_button_new_with_mnemonic ("Use alternate device:"); + gtk_widget_show (oss_mdevice_alt_check); + gtk_box_pack_start (GTK_BOX (oss_mdevice_alt_hbox), oss_mdevice_alt_check, FALSE, FALSE, 0); + + oss_mdevice_alt_entry = gtk_entry_new (); + gtk_widget_show (oss_mdevice_alt_entry); + gtk_box_pack_start (GTK_BOX (oss_mdevice_alt_hbox), oss_mdevice_alt_entry, TRUE, TRUE, 0); + + label4 = gtk_label_new ("Mixer device"); + gtk_widget_show (label4); + gtk_frame_set_label_widget (GTK_FRAME (oss_mdevice_frame), label4); + + oss_device_label = gtk_label_new ("Device"); + gtk_widget_show (oss_device_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_oss_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_oss_notebook), 0), oss_device_label); + gtk_label_set_justify (GTK_LABEL (oss_device_label), GTK_JUSTIFY_CENTER); + + oss_buffer_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (oss_buffer_page); + gtk_container_add (GTK_CONTAINER (output_oss_notebook), oss_buffer_page); + gtk_container_set_border_width (GTK_CONTAINER (oss_buffer_page), 5); + + oss_buffer_frame = gtk_frame_new (NULL); + gtk_widget_show (oss_buffer_frame); + gtk_box_pack_start (GTK_BOX (oss_buffer_page), oss_buffer_frame, FALSE, FALSE, 0); + + oss_buffer_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (oss_buffer_vbox); + gtk_container_add (GTK_CONTAINER (oss_buffer_frame), oss_buffer_vbox); + gtk_container_set_border_width (GTK_CONTAINER (oss_buffer_vbox), 5); + + ossbuf_buffer_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (ossbuf_buffer_hbox); + gtk_box_pack_start (GTK_BOX (oss_buffer_vbox), ossbuf_buffer_hbox, FALSE, FALSE, 0); + + ossbuf_buffer_label = gtk_label_new ("Buffer size (ms):"); + gtk_widget_show (ossbuf_buffer_label); + gtk_box_pack_start (GTK_BOX (ossbuf_buffer_hbox), ossbuf_buffer_label, FALSE, FALSE, 0); + + ossbuf_buffer_spin_adj = gtk_adjustment_new (0, 0, 60000, 10, 100, 10); + ossbuf_buffer_spin = gtk_spin_button_new (GTK_ADJUSTMENT (ossbuf_buffer_spin_adj), 0, 0); + gtk_widget_show (ossbuf_buffer_spin); + gtk_box_pack_start (GTK_BOX (ossbuf_buffer_hbox), ossbuf_buffer_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (ossbuf_buffer_spin), TRUE); + + ossbuf_preload_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (ossbuf_preload_hbox); + gtk_box_pack_start (GTK_BOX (oss_buffer_vbox), ossbuf_preload_hbox, TRUE, TRUE, 0); + + ossbuf_preload_label = gtk_label_new ("Preload size (ms):"); + gtk_widget_show (ossbuf_preload_label); + gtk_box_pack_start (GTK_BOX (ossbuf_preload_hbox), ossbuf_preload_label, FALSE, FALSE, 0); + + ossbuf_preload_spin_adj = gtk_adjustment_new (1500, 0, 60000, 10, 100, 10); + ossbuf_preload_spin = gtk_spin_button_new (GTK_ADJUSTMENT (ossbuf_preload_spin_adj), 0, 0); + gtk_widget_show (ossbuf_preload_spin); + gtk_box_pack_start (GTK_BOX (ossbuf_preload_hbox), ossbuf_preload_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (ossbuf_preload_spin), TRUE); + + label5 = gtk_label_new ("Software buffer"); + gtk_widget_show (label5); + gtk_frame_set_label_widget (GTK_FRAME (oss_buffer_frame), label5); + + oss_hwbuf_frame = gtk_frame_new (NULL); + gtk_widget_show (oss_hwbuf_frame); + gtk_box_pack_start (GTK_BOX (oss_buffer_page), oss_hwbuf_frame, TRUE, TRUE, 0); + + oss_hwbuf_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (oss_hwbuf_vbox); + gtk_container_add (GTK_CONTAINER (oss_hwbuf_frame), oss_hwbuf_vbox); + gtk_container_set_border_width (GTK_CONTAINER (oss_hwbuf_vbox), 5); + + osshwb_maxbuf_check = gtk_check_button_new_with_mnemonic ("Maximum device buffer size"); + gtk_widget_show (osshwb_maxbuf_check); + gtk_box_pack_start (GTK_BOX (oss_hwbuf_vbox), osshwb_maxbuf_check, FALSE, FALSE, 0); + + osshwb_fragments_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (osshwb_fragments_hbox); + gtk_box_pack_start (GTK_BOX (oss_hwbuf_vbox), osshwb_fragments_hbox, FALSE, FALSE, 0); + + osshwb_fragments_label = gtk_label_new ("Number of Fragments:"); + gtk_widget_show (osshwb_fragments_label); + gtk_box_pack_start (GTK_BOX (osshwb_fragments_hbox), osshwb_fragments_label, FALSE, FALSE, 0); + + osshwb_fragments_spin_adj = gtk_adjustment_new (50, 2, 65535, 1, 10, 10); + osshwb_fragments_spin = gtk_spin_button_new (GTK_ADJUSTMENT (osshwb_fragments_spin_adj), 0, 0); + gtk_widget_show (osshwb_fragments_spin); + gtk_box_pack_start (GTK_BOX (osshwb_fragments_hbox), osshwb_fragments_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (osshwb_fragments_spin), TRUE); + + osshwb_fragsize_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (osshwb_fragsize_hbox); + gtk_box_pack_start (GTK_BOX (oss_hwbuf_vbox), osshwb_fragsize_hbox, TRUE, TRUE, 0); + + osshwb_fragsize_label = gtk_label_new ("Fragment size (2^x bytes):"); + gtk_widget_show (osshwb_fragsize_label); + gtk_box_pack_start (GTK_BOX (osshwb_fragsize_hbox), osshwb_fragsize_label, FALSE, FALSE, 0); + + osshwb_fragsize_spin_adj = gtk_adjustment_new (11, 4, 16, 1, 10, 10); + osshwb_fragsize_spin = gtk_spin_button_new (GTK_ADJUSTMENT (osshwb_fragsize_spin_adj), 0, 0); + gtk_widget_show (osshwb_fragsize_spin); + gtk_box_pack_start (GTK_BOX (osshwb_fragsize_hbox), osshwb_fragsize_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (osshwb_fragsize_spin), TRUE); + + label6 = gtk_label_new ("Hardware device buffer"); + gtk_widget_show (label6); + gtk_frame_set_label_widget (GTK_FRAME (oss_hwbuf_frame), label6); + + oss_buffer_label = gtk_label_new ("Buffer"); + gtk_widget_show (oss_buffer_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_oss_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_oss_notebook), 1), oss_buffer_label); + gtk_label_set_justify (GTK_LABEL (oss_buffer_label), GTK_JUSTIFY_CENTER); + + oss_mixer_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (oss_mixer_page); + gtk_container_add (GTK_CONTAINER (output_oss_notebook), oss_mixer_page); + gtk_container_set_border_width (GTK_CONTAINER (oss_mixer_page), 5); + + oss_mixer_frame = gtk_frame_new (NULL); + gtk_widget_show (oss_mixer_frame); + gtk_box_pack_start (GTK_BOX (oss_mixer_page), oss_mixer_frame, FALSE, FALSE, 0); + + oss_mixer_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (oss_mixer_vbox); + gtk_container_add (GTK_CONTAINER (oss_mixer_frame), oss_mixer_vbox); + gtk_container_set_border_width (GTK_CONTAINER (oss_mixer_vbox), 5); + + ossmixer_pcm_check = gtk_check_button_new_with_mnemonic ("Volume controls Master not PCM"); + gtk_widget_show (ossmixer_pcm_check); + gtk_box_pack_start (GTK_BOX (oss_mixer_vbox), ossmixer_pcm_check, FALSE, FALSE, 0); + + label7 = gtk_label_new ("Mixer options"); + gtk_widget_show (label7); + gtk_frame_set_label_widget (GTK_FRAME (oss_mixer_frame), label7); + + oss_mixer_label = gtk_label_new ("Mixer"); + gtk_widget_show (oss_mixer_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_oss_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_oss_notebook), 2), oss_mixer_label); + gtk_label_set_justify (GTK_LABEL (oss_mixer_label), GTK_JUSTIFY_CENTER); + + label29 = gtk_label_new (""); + gtk_widget_show (label29); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 0), label29); + + output_plugin_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (output_plugin_page); + gtk_container_add (GTK_CONTAINER (output_notebook), output_plugin_page); + + op_plugin_frame = gtk_frame_new (NULL); + gtk_widget_show (op_plugin_frame); + gtk_box_pack_start (GTK_BOX (output_plugin_page), op_plugin_frame, FALSE, TRUE, 0); + + op_plugin_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (op_plugin_vbox); + gtk_container_add (GTK_CONTAINER (op_plugin_frame), op_plugin_vbox); + gtk_container_set_border_width (GTK_CONTAINER (op_plugin_vbox), 5); + + op_plugin_optionmenu = gtk_option_menu_new (); + gtk_widget_show (op_plugin_optionmenu); + gtk_box_pack_start (GTK_BOX (op_plugin_vbox), op_plugin_optionmenu, FALSE, FALSE, 0); + + convertwidget5 = gtk_menu_new (); + + convertwidget6 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget6); + gtk_container_add (GTK_CONTAINER (convertwidget5), convertwidget6); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (op_plugin_optionmenu), convertwidget5); + + op_plugin_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (op_plugin_buttonbox); + gtk_box_pack_start (GTK_BOX (op_plugin_vbox), op_plugin_buttonbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (op_plugin_buttonbox), GTK_BUTTONBOX_START); + gtk_box_set_spacing (GTK_BOX (op_plugin_buttonbox), 5); + + op_configure_button = gtk_button_new_with_mnemonic ("Configure"); + gtk_widget_show (op_configure_button); + gtk_container_add (GTK_CONTAINER (op_plugin_buttonbox), op_configure_button); + GTK_WIDGET_SET_FLAGS (op_configure_button, GTK_CAN_DEFAULT); + + op_about_button = gtk_button_new_with_mnemonic ("About"); + gtk_widget_show (op_about_button); + gtk_container_add (GTK_CONTAINER (op_plugin_buttonbox), op_about_button); + GTK_WIDGET_SET_FLAGS (op_about_button, GTK_CAN_DEFAULT); + + label8 = gtk_label_new ("Output plugin"); + gtk_widget_show (label8); + gtk_frame_set_label_widget (GTK_FRAME (op_plugin_frame), label8); + + op_options_frame = gtk_frame_new (NULL); + gtk_widget_show (op_options_frame); + gtk_box_pack_start (GTK_BOX (output_plugin_page), op_options_frame, FALSE, TRUE, 0); + + op_options_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (op_options_vbox); + gtk_container_add (GTK_CONTAINER (op_options_frame), op_options_vbox); + gtk_container_set_border_width (GTK_CONTAINER (op_options_vbox), 5); + + op_throttle_check = gtk_check_button_new_with_mnemonic ("Throttle Output"); + gtk_widget_show (op_throttle_check); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_throttle_check, FALSE, FALSE, 0); + + op_maxblock_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (op_maxblock_hbox); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_maxblock_hbox, TRUE, TRUE, 0); + + op_maxblock_check = gtk_check_button_new_with_mnemonic ("Max block size (bytes):"); + gtk_widget_show (op_maxblock_check); + gtk_box_pack_start (GTK_BOX (op_maxblock_hbox), op_maxblock_check, FALSE, FALSE, 0); + + op_maxblock_spin_adj = gtk_adjustment_new (1024, 4, 1048580, 4, 16, 10); + op_maxblock_spin = gtk_spin_button_new (GTK_ADJUSTMENT (op_maxblock_spin_adj), 10, 0); + gtk_widget_show (op_maxblock_spin); + gtk_box_pack_start (GTK_BOX (op_maxblock_hbox), op_maxblock_spin, TRUE, TRUE, 0); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (op_maxblock_spin), TRUE); + gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (op_maxblock_spin), TRUE); + + op_forcereopen_check = gtk_check_button_new_with_mnemonic ("Force close/reopen on songchange"); + gtk_widget_show (op_forcereopen_check); + gtk_box_pack_start (GTK_BOX (op_options_vbox), op_forcereopen_check, FALSE, FALSE, 0); + + label9 = gtk_label_new ("Plugin compatibility options"); + gtk_widget_show (label9); + gtk_frame_set_label_widget (GTK_FRAME (op_options_frame), label9); + + label31 = gtk_label_new (""); + gtk_widget_show (label31); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 1), label31); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label32 = gtk_label_new (""); + gtk_widget_show (label32); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 2), label32); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label33 = gtk_label_new (""); + gtk_widget_show (label33); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 3), label33); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (output_notebook), empty_notebook_page); + + label34 = gtk_label_new (""); + gtk_widget_show (label34); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (output_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (output_notebook), 4), label34); + + output_help_label = gtk_label_new ("When modifying the Output Options or the Mixing buffer size, you need to stop/restart playback for the settings to take effect."); + gtk_widget_show (output_help_label); + gtk_box_pack_end (GTK_BOX (config_output_page), output_help_label, TRUE, TRUE, 0); + gtk_label_set_line_wrap (GTK_LABEL (output_help_label), TRUE); + + config_devices_label = gtk_label_new ("Output"); + gtk_widget_show (config_devices_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 0), config_devices_label); + gtk_label_set_justify (GTK_LABEL (config_devices_label), GTK_JUSTIFY_CENTER); + + config_effects_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_effects_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_effects_page); + gtk_container_set_border_width (GTK_CONTAINER (config_effects_page), 5); + + ep_plugin_frame = gtk_frame_new (NULL); + gtk_widget_show (ep_plugin_frame); + gtk_box_pack_start (GTK_BOX (config_effects_page), ep_plugin_frame, FALSE, TRUE, 0); + + ep_plugin_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (ep_plugin_vbox); + gtk_container_add (GTK_CONTAINER (ep_plugin_frame), ep_plugin_vbox); + gtk_container_set_border_width (GTK_CONTAINER (ep_plugin_vbox), 5); + + ep_plugin_optionmenu = gtk_option_menu_new (); + gtk_widget_show (ep_plugin_optionmenu); + gtk_box_pack_start (GTK_BOX (ep_plugin_vbox), ep_plugin_optionmenu, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, ep_plugin_optionmenu, "Select an effect plugin. Take care not to use the same plugin as selected in XMMS' configuration dialog.", NULL); + + convertwidget7 = gtk_menu_new (); + + convertwidget8 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget8); + gtk_container_add (GTK_CONTAINER (convertwidget7), convertwidget8); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (ep_plugin_optionmenu), convertwidget7); + + ep_plugin_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (ep_plugin_buttonbox); + gtk_box_pack_start (GTK_BOX (ep_plugin_vbox), ep_plugin_buttonbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (ep_plugin_buttonbox), GTK_BUTTONBOX_START); + gtk_box_set_spacing (GTK_BOX (ep_plugin_buttonbox), 5); + + ep_configure_button = gtk_button_new_with_mnemonic ("Configure"); + gtk_widget_show (ep_configure_button); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_configure_button); + GTK_WIDGET_SET_FLAGS (ep_configure_button, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, ep_configure_button, "Open the configuration dialog of the plugin selected above.", NULL); + + ep_about_button = gtk_button_new_with_mnemonic ("About"); + gtk_widget_show (ep_about_button); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_about_button); + GTK_WIDGET_SET_FLAGS (ep_about_button, GTK_CAN_DEFAULT); + gtk_tooltips_set_tip (tooltips, ep_about_button, "Open the about dialog of the plugin selected above.", NULL); + + ep_enable_check = gtk_check_button_new_with_mnemonic ("Use plugin"); + gtk_widget_show (ep_enable_check); + gtk_container_add (GTK_CONTAINER (ep_plugin_buttonbox), ep_enable_check); + gtk_tooltips_set_tip (tooltips, ep_enable_check, "Enable the selected plugin. Note that after pressing 'Apply' it may take a while until you can hear the effect, since it is applied before the audio data goes into the buffer.", NULL); + + label10 = gtk_label_new ("Pre-mixing effect plugin"); + gtk_widget_show (label10); + gtk_frame_set_label_widget (GTK_FRAME (ep_plugin_frame), label10); + + effects_volnorm_frame = gtk_frame_new (NULL); + gtk_box_pack_start (GTK_BOX (config_effects_page), effects_volnorm_frame, FALSE, FALSE, 0); + + effects_volnorm_table = gtk_table_new (4, 2, FALSE); + gtk_widget_show (effects_volnorm_table); + gtk_container_add (GTK_CONTAINER (effects_volnorm_frame), effects_volnorm_table); + gtk_container_set_border_width (GTK_CONTAINER (effects_volnorm_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (effects_volnorm_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (effects_volnorm_table), 5); + + volnorm_quantaudio_check = gtk_check_button_new_with_mnemonic ("Read Quantaudio comment field"); + gtk_widget_show (volnorm_quantaudio_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_quantaudio_check, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + volnorm_target_spin_adj = gtk_adjustment_new (8000, 0, 32768, 100, 1000, 10); + volnorm_target_spin = gtk_spin_button_new (GTK_ADJUSTMENT (volnorm_target_spin_adj), 0, 0); + gtk_widget_show (volnorm_target_spin); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_target_spin, 1, 2, 3, 4, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, volnorm_target_spin, "Set the maximum length for gaps at the end of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (volnorm_target_spin), TRUE); + + volnorm_target_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (volnorm_target_hbox); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_target_hbox, 0, 1, 3, 4, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + volnorm_target_label = gtk_label_new ("Target RMS:"); + gtk_widget_show (volnorm_target_label); + gtk_box_pack_start (GTK_BOX (volnorm_target_hbox), volnorm_target_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (volnorm_target_label), GTK_JUSTIFY_CENTER); + + volnorm_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (volnorm_enable_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + volnorm_rva2_check = gtk_check_button_new_with_mnemonic ("Read ID3V2 RVA2 Tag"); + gtk_widget_show (volnorm_rva2_check); + gtk_table_attach (GTK_TABLE (effects_volnorm_table), volnorm_rva2_check, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label11 = gtk_label_new ("Volume normalizer"); + gtk_widget_show (label11); + gtk_frame_set_label_widget (GTK_FRAME (effects_volnorm_frame), label11); + + effects_help_label = gtk_label_new ("You do not need to press 'Apply' after making changes to the effect plugin settings. It may take a while though until you can hear the change, since the plugin is applied before the mixing buffer."); + gtk_widget_show (effects_help_label); + gtk_box_pack_start (GTK_BOX (config_effects_page), effects_help_label, TRUE, TRUE, 0); + gtk_label_set_line_wrap (GTK_LABEL (effects_help_label), TRUE); + + config_effects_label = gtk_label_new ("Effects"); + gtk_widget_show (config_effects_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 1), config_effects_label); + gtk_label_set_justify (GTK_LABEL (config_effects_label), GTK_JUSTIFY_CENTER); + + config_crossfader_page = gtk_vbox_new (FALSE, 2); + gtk_widget_show (config_crossfader_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_crossfader_page); + gtk_container_set_border_width (GTK_CONTAINER (config_crossfader_page), 5); + + xf_bufsize_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_bufsize_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_bufsize_hbox, FALSE, FALSE, 0); + + xf_bufsize_label = gtk_label_new ("Mixing buffer size (ms):"); + gtk_widget_show (xf_bufsize_label); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_bufsize_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_bufsize_label), GTK_JUSTIFY_CENTER); + + xf_buffer_spin_adj = gtk_adjustment_new (8500, 0, 60000, 100, 1000, 10); + xf_buffer_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xf_buffer_spin_adj), 0, 0); + gtk_widget_show (xf_buffer_spin); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_buffer_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_buffer_spin, "Specify the size of the mixing buffer. Mixing buffer space is required for pauses, fade-outs, offsetting (i.e. interleaving the end and beginning of two songs) and killing trailing gaps. Fade-ins and killing leading gaps are done on-the-fly and do not depend on mixing buffer space.\nDefault: n/a - calculated automatically", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xf_buffer_spin), TRUE); + + xf_autobuf_check = gtk_check_button_new_with_mnemonic ("auto"); + gtk_widget_show (xf_autobuf_check); + gtk_box_pack_start (GTK_BOX (xf_bufsize_hbox), xf_autobuf_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, xf_autobuf_check, "Automatically calculate an optimal buffer size.\nDefault: On", NULL); + + xf_config_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_config_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_config_hbox, FALSE, FALSE, 0); + + xf_config_label = gtk_label_new ("Set parameters for:"); + gtk_widget_show (xf_config_label); + gtk_box_pack_start (GTK_BOX (xf_config_hbox), xf_config_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_config_label), GTK_JUSTIFY_CENTER); + + xf_config_optionmenu = gtk_option_menu_new (); + gtk_widget_show (xf_config_optionmenu); + gtk_box_pack_start (GTK_BOX (xf_config_hbox), xf_config_optionmenu, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_config_optionmenu, "Select the type of songchange you want to configure:\n* Start of playback: When starting playback by pressing PLAY\n* Automatic songchange: When reaching the end of a song and the playlist advances to the next song\n* Manual songchange: When manually selecting another song, for example by pressing NEXT/PREV\n* Manual stop: When pressing the STOP button\n* End of playlist: After the last song in the playlist has been played\n* Seeking: When seeking within the current song", NULL); + + convertwidget9 = gtk_menu_new (); + + convertwidget10 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget10); + gtk_container_add (GTK_CONTAINER (convertwidget9), convertwidget10); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (xf_config_optionmenu), convertwidget9); + + xf_type_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xf_type_hbox); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_type_hbox, FALSE, FALSE, 0); + + xf_type_label = gtk_label_new ("Crossfade/Transition type:"); + gtk_widget_show (xf_type_label); + gtk_box_pack_start (GTK_BOX (xf_type_hbox), xf_type_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (xf_type_label), GTK_JUSTIFY_CENTER); + + xf_type_optionmenu = gtk_option_menu_new (); + gtk_widget_show (xf_type_optionmenu); + gtk_box_pack_start (GTK_BOX (xf_type_hbox), xf_type_optionmenu, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xf_type_optionmenu, "Select the transition to be used for the songchange type selected above:\n* Fade-in: Fade-in at 'Start of playback'\n* Reopen output device: Force a close/open on the output plugin. This will most certainly re-introduce gaps and clicks, but might be usefull with some plugins.\n* Flush output device: Keeps the output plugin opened, but flushes its buffers. This will give you almost instant reaction when pressing NEXT/PREV.\n* None (gapless/off): Gapless mode. Keeps the device opened, but does not do any fading.\n* Simple crossfade: Does a simple crossfade between the previous and the next song.\n* Advanced crossfade: Allows you to configure the crossfade in more detail.\n* Fade-out: Fade-out at 'Manual stop' or 'End of playlist'.", NULL); + + convertwidget11 = gtk_menu_new (); + + convertwidget12 = gtk_menu_item_new_with_mnemonic ("dummy"); + gtk_widget_show (convertwidget12); + gtk_container_add (GTK_CONTAINER (convertwidget11), convertwidget12); + + gtk_option_menu_set_menu (GTK_OPTION_MENU (xf_type_optionmenu), convertwidget11); + + xf_type_notebook = gtk_notebook_new (); + gtk_widget_show (xf_type_notebook); + gtk_box_pack_start (GTK_BOX (config_crossfader_page), xf_type_notebook, FALSE, FALSE, 0); + GTK_WIDGET_UNSET_FLAGS (xf_type_notebook, GTK_CAN_FOCUS); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (xf_type_notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (xf_type_notebook), FALSE); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_reopen_label = gtk_label_new ("Reopen"); + gtk_widget_show (xft_reopen_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 0), xft_reopen_label); + gtk_label_set_justify (GTK_LABEL (xft_reopen_label), GTK_JUSTIFY_CENTER); + + xft_flush_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_flush_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_flush_page); + + xftf_pause_frame = gtk_frame_new (NULL); + gtk_widget_show (xftf_pause_frame); + gtk_box_pack_start (GTK_BOX (xft_flush_page), xftf_pause_frame, FALSE, FALSE, 0); + + xftf_pause_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftf_pause_table); + gtk_container_add (GTK_CONTAINER (xftf_pause_frame), xftf_pause_table); + gtk_container_set_border_width (GTK_CONTAINER (xftf_pause_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftf_pause_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftf_pause_table), 5); + + xftfp_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfp_length_label); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_length_label, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfp_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + xftfp_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfp_length_spin_adj), 0, 0); + gtk_widget_show (xftfp_length_spin); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfp_length_spin, "Specify the length of the silence to be inserted between the tracks.\nDefault: 2000", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfp_length_spin), TRUE); + + xftfp_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (xftfp_enable_check); + gtk_table_attach (GTK_TABLE (xftf_pause_table), xftfp_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label12 = gtk_label_new ("Pause"); + gtk_widget_show (label12); + gtk_frame_set_label_widget (GTK_FRAME (xftf_pause_frame), label12); + + xftf_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xftf_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_flush_page), xftf_fadein_frame, FALSE, FALSE, 0); + + xftf_fadein_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xftf_fadein_table); + gtk_container_add (GTK_CONTAINER (xftf_fadein_frame), xftf_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xftf_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftf_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftf_fadein_table), 5); + + xftffi_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftffi_length_hbox); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftffi_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftffi_length_label); + gtk_box_pack_start (GTK_BOX (xftffi_length_hbox), xftffi_length_label, FALSE, FALSE, 0); + + xftffi_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftffi_volume_hbox); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftffi_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (xftffi_volume_label); + gtk_box_pack_start (GTK_BOX (xftffi_volume_hbox), xftffi_volume_label, FALSE, FALSE, 0); + + xftffi_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + xftffi_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftffi_length_spin_adj), 0, 0); + gtk_widget_show (xftffi_length_spin); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftffi_length_spin, "Set the duration for the fadein of the next song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftffi_length_spin), TRUE); + + xftffi_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (xftffi_enable_check); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftffi_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftffi_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftffi_volume_spin_adj), 0, 0); + gtk_widget_show (xftffi_volume_spin); + gtk_table_attach (GTK_TABLE (xftf_fadein_table), xftffi_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftffi_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftffi_volume_spin), TRUE); + + label13 = gtk_label_new ("Fade in"); + gtk_widget_show (label13); + gtk_frame_set_label_widget (GTK_FRAME (xftf_fadein_frame), label13); + + xft_flush_label = gtk_label_new ("Flush"); + gtk_widget_show (xft_flush_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 1), xft_flush_label); + gtk_label_set_justify (GTK_LABEL (xft_flush_label), GTK_JUSTIFY_CENTER); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_none_label = gtk_label_new ("None"); + gtk_widget_show (xft_none_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 2), xft_none_label); + gtk_label_set_justify (GTK_LABEL (xft_none_label), GTK_JUSTIFY_CENTER); + + xft_pause_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_pause_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_pause_page); + + xf_pause_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_pause_frame); + gtk_box_pack_start (GTK_BOX (xft_pause_page), xf_pause_frame, FALSE, FALSE, 0); + + xf_pause_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xf_pause_table); + gtk_container_add (GTK_CONTAINER (xf_pause_frame), xf_pause_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_pause_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_pause_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_pause_table), 5); + + pause_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (pause_length_hbox); + gtk_table_attach (GTK_TABLE (xf_pause_table), pause_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + pause_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (pause_length_label); + gtk_box_pack_start (GTK_BOX (pause_length_hbox), pause_length_label, FALSE, FALSE, 0); + + pause_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + pause_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pause_length_spin_adj), 0, 0); + gtk_widget_show (pause_length_spin); + gtk_table_attach (GTK_TABLE (xf_pause_table), pause_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, pause_length_spin, "Specify the length of the silence to be inserted between the tracks.\nDefault: 2000", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pause_length_spin), TRUE); + + label14 = gtk_label_new ("Pause"); + gtk_widget_show (label14); + gtk_frame_set_label_widget (GTK_FRAME (xf_pause_frame), label14); + + xft_pause_label = gtk_label_new ("Pause"); + gtk_widget_show (xft_pause_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 3), xft_pause_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_label), GTK_JUSTIFY_CENTER); + + xft_simplexf_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_simplexf_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_simplexf_page); + + xf_simple_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_simple_frame); + gtk_box_pack_start (GTK_BOX (xft_simplexf_page), xf_simple_frame, FALSE, FALSE, 0); + + xf_simple_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xf_simple_table); + gtk_container_add (GTK_CONTAINER (xf_simple_frame), xf_simple_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_simple_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_simple_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_simple_table), 5); + + simple_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (simple_length_hbox); + gtk_table_attach (GTK_TABLE (xf_simple_table), simple_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + simple_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (simple_length_label); + gtk_box_pack_start (GTK_BOX (simple_length_hbox), simple_length_label, FALSE, FALSE, 0); + + simple_length_spin_adj = gtk_adjustment_new (1500, 0, 60000, 100, 1000, 10); + simple_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (simple_length_spin_adj), 0, 0); + gtk_widget_show (simple_length_spin); + gtk_table_attach (GTK_TABLE (xf_simple_table), simple_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, simple_length_spin, "Specify the length of the crosssfade.\nDefault: depends on songchange type", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (simple_length_spin), TRUE); + + label15 = gtk_label_new ("Crossfade"); + gtk_widget_show (label15); + gtk_frame_set_label_widget (GTK_FRAME (xf_simple_frame), label15); + + xft_simplexf_label = gtk_label_new ("Simple XF"); + gtk_widget_show (xft_simplexf_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 4), xft_simplexf_label); + gtk_label_set_justify (GTK_LABEL (xft_simplexf_label), GTK_JUSTIFY_CENTER); + + xft_advancedxf_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_advancedxf_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_advancedxf_page); + + xf_fadeout_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_fadeout_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_fadeout_frame, FALSE, FALSE, 0); + + xf_fadeout_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xf_fadeout_table); + gtk_container_add (GTK_CONTAINER (xf_fadeout_frame), xf_fadeout_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_fadeout_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_fadeout_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_fadeout_table), 5); + + fadeout_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadeout_length_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (fadeout_length_label); + gtk_box_pack_start (GTK_BOX (fadeout_length_hbox), fadeout_length_label, FALSE, FALSE, 0); + + fadeout_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + fadeout_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadeout_length_spin_adj), 0, 0); + gtk_widget_show (fadeout_length_spin); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadeout_length_spin, "Set the duration for the fadeout of the previous song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadeout_length_spin), TRUE); + + fadeout_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadeout_volume_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_volume_label = gtk_label_new ("End volume (%):"); + gtk_widget_show (fadeout_volume_label); + gtk_box_pack_start (GTK_BOX (fadeout_volume_hbox), fadeout_volume_label, FALSE, FALSE, 0); + + fadeout_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + fadeout_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadeout_volume_spin_adj), 0, 0); + gtk_widget_show (fadeout_volume_spin); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadeout_volume_spin, "Set the end volume. XMMS-crossfade will fade from 100% to this volume during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadeout_volume_spin), TRUE); + + fadeout_options_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (fadeout_options_hbox); + gtk_table_attach (GTK_TABLE (xf_fadeout_table), fadeout_options_hbox, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadeout_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (fadeout_enable_check); + gtk_box_pack_start (GTK_BOX (fadeout_options_hbox), fadeout_enable_check, FALSE, FALSE, 0); + + label16 = gtk_label_new ("Fade out"); + gtk_widget_show (label16); + gtk_frame_set_label_widget (GTK_FRAME (xf_fadeout_frame), label16); + + xf_offset_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_offset_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_offset_frame, FALSE, FALSE, 0); + + xf_offset_table = gtk_table_new (4, 1, FALSE); + gtk_widget_show (xf_offset_table); + gtk_container_add (GTK_CONTAINER (xf_offset_frame), xf_offset_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_offset_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_offset_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_offset_table), 5); + + xfofs_custom_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (xfofs_custom_hbox); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_custom_hbox, 0, 1, 3, 4, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xfofs_custom_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Custom (ms):"); + gtk_widget_show (xfofs_custom_radiobutton); + gtk_box_pack_start (GTK_BOX (xfofs_custom_hbox), xfofs_custom_radiobutton, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, xfofs_custom_radiobutton, "Set a custom offset.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_custom_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_custom_radiobutton)); + + xfofs_custom_spin_adj = gtk_adjustment_new (-2000, -60000, 60000, 100, 1000, 10); + xfofs_custom_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xfofs_custom_spin_adj), 0, 0); + gtk_widget_show (xfofs_custom_spin); + gtk_box_pack_start (GTK_BOX (xfofs_custom_hbox), xfofs_custom_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, xfofs_custom_spin, "Set how much the end of the previous and the beginning of the next song should overlap.\n* Negative values indicate that the next song should start before the previous has reached the end.\n* A value of 0 means that the songs are concatenated seamlessly.\n* Positive values will yield insert silence inbetween..", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xfofs_custom_spin), TRUE); + + xfofs_none_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "None (0 ms)"); + gtk_widget_show (xfofs_none_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_none_radiobutton, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_none_radiobutton, "Don't overlap the two songs. The next song will start immediatelly after the previous has ended.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_none_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_none_radiobutton)); + + xfofs_lockout_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Lock to fadeout length"); + gtk_widget_show (xfofs_lockout_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_lockout_radiobutton, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_lockout_radiobutton, "Overlap by the fadeout duration specified above.", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_lockout_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_lockout_radiobutton)); + + xfofs_lockin_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "Lock to fadein length"); + gtk_widget_show (xfofs_lockin_radiobutton); + gtk_table_attach (GTK_TABLE (xf_offset_table), xfofs_lockin_radiobutton, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xfofs_lockin_radiobutton, "Overlap by the fadein duration specified below..", NULL); + gtk_radio_button_set_group (GTK_RADIO_BUTTON (xfofs_lockin_radiobutton), xfofs_custom_radiobutton_group); + xfofs_custom_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (xfofs_lockin_radiobutton)); + + label17 = gtk_label_new ("Offset"); + gtk_widget_show (label17); + gtk_frame_set_label_widget (GTK_FRAME (xf_offset_frame), label17); + + xf_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xf_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_advancedxf_page), xf_fadein_frame, FALSE, FALSE, 0); + + xf_fadein_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xf_fadein_table); + gtk_container_add (GTK_CONTAINER (xf_fadein_frame), xf_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xf_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xf_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xf_fadein_table), 5); + + fadein_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadein_length_hbox); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadein_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (fadein_length_label); + gtk_box_pack_start (GTK_BOX (fadein_length_hbox), fadein_length_label, FALSE, FALSE, 0); + + fadein_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (fadein_volume_hbox); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_volume_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + fadein_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (fadein_volume_label); + gtk_box_pack_start (GTK_BOX (fadein_volume_hbox), fadein_volume_label, FALSE, FALSE, 0); + + fadein_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 100, 1000, 10); + fadein_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadein_length_spin_adj), 0, 0); + gtk_widget_show (fadein_length_spin); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_length_spin, "Set the duration for the fadein of the next song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadein_length_spin), TRUE); + + fadein_enable_check = gtk_check_button_new_with_mnemonic (" Enable"); + gtk_widget_show (fadein_enable_check); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + fadein_lock_check = gtk_check_button_new_with_mnemonic ("Lock to Fade-out"); + gtk_widget_show (fadein_lock_check); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_lock_check, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_lock_check, "Use the same settings as fade-out.", NULL); + + fadein_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + fadein_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (fadein_volume_spin_adj), 0, 0); + gtk_widget_show (fadein_volume_spin); + gtk_table_attach (GTK_TABLE (xf_fadein_table), fadein_volume_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, fadein_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fadein_volume_spin), TRUE); + + label18 = gtk_label_new ("Fade in"); + gtk_widget_show (label18); + gtk_frame_set_label_widget (GTK_FRAME (xf_fadein_frame), label18); + + xft_advancedxf_label = gtk_label_new ("Advanced XF"); + gtk_widget_show (xft_advancedxf_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 5), xft_advancedxf_label); + gtk_label_set_justify (GTK_LABEL (xft_advancedxf_label), GTK_JUSTIFY_CENTER); + + xft_fadein_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (xft_fadein_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_fadein_page); + + xftfi_fadein_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfi_fadein_frame); + gtk_box_pack_start (GTK_BOX (xft_fadein_page), xftfi_fadein_frame, FALSE, FALSE, 0); + + xftfi_fadein_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftfi_fadein_table); + gtk_container_add (GTK_CONTAINER (xftfi_fadein_frame), xftfi_fadein_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfi_fadein_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfi_fadein_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfi_fadein_table), 5); + + xftfi_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfi_length_hbox); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfi_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfi_length_label); + gtk_box_pack_start (GTK_BOX (xftfi_length_hbox), xftfi_length_label, FALSE, FALSE, 0); + + xftfi_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfi_volume_hbox); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_volume_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfi_volume_label = gtk_label_new ("Start volume (%):"); + gtk_widget_show (xftfi_volume_label); + gtk_box_pack_start (GTK_BOX (xftfi_volume_hbox), xftfi_volume_label, FALSE, FALSE, 0); + + xftfi_length_spin_adj = gtk_adjustment_new (1000, 0, 60000, 10, 100, 10); + xftfi_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfi_length_spin_adj), 0, 0); + gtk_widget_show (xftfi_length_spin); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfi_length_spin, "Set the duration for the fadein when starting playback.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfi_length_spin), TRUE); + + xftfi_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftfi_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfi_volume_spin_adj), 0, 0); + gtk_widget_show (xftfi_volume_spin); + gtk_table_attach (GTK_TABLE (xftfi_fadein_table), xftfi_volume_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfi_volume_spin, "Set the start volume. XMMS-crossfade will fade from this volume to 100% during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfi_volume_spin), TRUE); + + label19 = gtk_label_new ("Fade in"); + gtk_widget_show (label19); + gtk_frame_set_label_widget (GTK_FRAME (xftfi_fadein_frame), label19); + + xft_fadein_label = gtk_label_new ("Fade in"); + gtk_widget_show (xft_fadein_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 6), xft_fadein_label); + gtk_label_set_justify (GTK_LABEL (xft_fadein_label), GTK_JUSTIFY_CENTER); + + xft_fadeout_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_fadeout_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_fadeout_page); + + xftfo_fadeout_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfo_fadeout_frame); + gtk_box_pack_start (GTK_BOX (xft_fadeout_page), xftfo_fadeout_frame, FALSE, FALSE, 0); + + xftfo_fadeout_table = gtk_table_new (2, 2, FALSE); + gtk_widget_show (xftfo_fadeout_table); + gtk_container_add (GTK_CONTAINER (xftfo_fadeout_frame), xftfo_fadeout_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfo_fadeout_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfo_fadeout_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfo_fadeout_table), 5); + + xftfo_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_length_hbox); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_length_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_length_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfo_length_label); + gtk_box_pack_start (GTK_BOX (xftfo_length_hbox), xftfo_length_label, FALSE, FALSE, 0); + + xftfo_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + xftfo_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_length_spin_adj), 0, 0); + gtk_widget_show (xftfo_length_spin); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_length_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_length_spin, "Set the duration for the fadeout of the last song.", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_length_spin), TRUE); + + xftfo_volume_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_volume_hbox); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_volume_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_volume_label = gtk_label_new ("End volume (%):"); + gtk_widget_show (xftfo_volume_label); + gtk_box_pack_start (GTK_BOX (xftfo_volume_hbox), xftfo_volume_label, FALSE, FALSE, 0); + + xftfo_volume_spin_adj = gtk_adjustment_new (0, 0, 100, 1, 10, 10); + xftfo_volume_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_volume_spin_adj), 0, 0); + gtk_widget_show (xftfo_volume_spin); + gtk_table_attach (GTK_TABLE (xftfo_fadeout_table), xftfo_volume_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_volume_spin, "Set the end volume. XMMS-crossfade will fade from 100% to this volume during the time specified above.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_volume_spin), TRUE); + + label20 = gtk_label_new ("Fade out"); + gtk_widget_show (label20); + gtk_frame_set_label_widget (GTK_FRAME (xftfo_fadeout_frame), label20); + + xftfo_silence_frame = gtk_frame_new (NULL); + gtk_widget_show (xftfo_silence_frame); + gtk_box_pack_start (GTK_BOX (xft_fadeout_page), xftfo_silence_frame, FALSE, FALSE, 0); + + xftfo_silence_table = gtk_table_new (1, 2, FALSE); + gtk_widget_show (xftfo_silence_table); + gtk_container_add (GTK_CONTAINER (xftfo_silence_frame), xftfo_silence_table); + gtk_container_set_border_width (GTK_CONTAINER (xftfo_silence_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xftfo_silence_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xftfo_silence_table), 5); + + xftfo_silence_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfo_silence_hbox); + gtk_table_attach (GTK_TABLE (xftfo_silence_table), xftfo_silence_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + xftfo_silence_label = gtk_label_new ("Length (ms):"); + gtk_widget_show (xftfo_silence_label); + gtk_box_pack_start (GTK_BOX (xftfo_silence_hbox), xftfo_silence_label, FALSE, FALSE, 0); + + xftfo_silence_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfo_silence_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfo_silence_spin_adj), 0, 0); + gtk_widget_show (xftfo_silence_spin); + gtk_table_attach (GTK_TABLE (xftfo_silence_table), xftfo_silence_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfo_silence_spin, "Set how much additional silence should be played after the end of the last song. This way, you can avoid the clicks some soundcards produce when being shut down during playback.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfo_silence_spin), TRUE); + + label21 = gtk_label_new ("Additional silence"); + gtk_widget_show (label21); + gtk_frame_set_label_widget (GTK_FRAME (xftfo_silence_frame), label21); + + xft_fadeout_label = gtk_label_new ("Fade out"); + gtk_widget_show (xft_fadeout_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 7), xft_fadeout_label); + gtk_label_set_justify (GTK_LABEL (xft_fadeout_label), GTK_JUSTIFY_CENTER); + + empty_notebook_page = gtk_vbox_new (FALSE, 0); + gtk_widget_show (empty_notebook_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), empty_notebook_page); + + xft_pause_none_label = gtk_label_new ("None"); + gtk_widget_show (xft_pause_none_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 8), xft_pause_none_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_none_label), GTK_JUSTIFY_CENTER); + + xft_pause_adv_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (xft_pause_adv_page); + gtk_container_add (GTK_CONTAINER (xf_type_notebook), xft_pause_adv_page); + + xft_fadeoutin_frame = gtk_frame_new (NULL); + gtk_widget_show (xft_fadeoutin_frame); + gtk_box_pack_start (GTK_BOX (xft_pause_adv_page), xft_fadeoutin_frame, FALSE, FALSE, 0); + + xft_fadeoutin_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (xft_fadeoutin_table); + gtk_container_add (GTK_CONTAINER (xft_fadeoutin_frame), xft_fadeoutin_table); + gtk_container_set_border_width (GTK_CONTAINER (xft_fadeoutin_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (xft_fadeoutin_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (xft_fadeoutin_table), 5); + + xftfoi_fadeout_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_fadeout_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_fadeout_spin_adj), 0, 0); + gtk_widget_show (xftfoi_fadeout_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadeout_spin, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_fadeout_spin, "Set the duration for the fadeout when pausing.\nDefault: 100\n", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_fadeout_spin), TRUE); + + xftfoi_silence_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_silence_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_silence_spin_adj), 0, 0); + gtk_widget_show (xftfoi_silence_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_silence_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_silence_spin, "Set how much additional silence should be played after pausing. This way, you can avoid the clicks some soundcards produce when entering pause.\nDefault: 100", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_silence_spin), TRUE); + + xftfoi_fadein_spin_adj = gtk_adjustment_new (100, 0, 60000, 10, 100, 10); + xftfoi_fadein_spin = gtk_spin_button_new (GTK_ADJUSTMENT (xftfoi_fadein_spin_adj), 0, 0); + gtk_widget_show (xftfoi_fadein_spin); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadein_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, xftfoi_fadein_spin, "Set the duration for the fadein when unpausing.\nDefault: 100", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (xftfoi_fadein_spin), TRUE); + + xftfoi_fadein_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_fadein_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadein_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_fadein_label = gtk_label_new ("Fade out (ms):"); + gtk_widget_show (xftfoi_fadein_label); + gtk_box_pack_start (GTK_BOX (xftfoi_fadein_hbox), xftfoi_fadein_label, FALSE, FALSE, 0); + + xftfoi_silence_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_silence_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_silence_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_silence_label = gtk_label_new ("Silence (ms):"); + gtk_widget_show (xftfoi_silence_label); + gtk_box_pack_start (GTK_BOX (xftfoi_silence_hbox), xftfoi_silence_label, FALSE, FALSE, 0); + + xftfoi_fadeout_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (xftfoi_fadeout_hbox); + gtk_table_attach (GTK_TABLE (xft_fadeoutin_table), xftfoi_fadeout_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + xftfoi_fadeout_label = gtk_label_new ("Fade in (ms):"); + gtk_widget_show (xftfoi_fadeout_label); + gtk_box_pack_start (GTK_BOX (xftfoi_fadeout_hbox), xftfoi_fadeout_label, FALSE, FALSE, 0); + + label22 = gtk_label_new ("Fade out / Fade in"); + gtk_widget_show (label22); + gtk_frame_set_label_widget (GTK_FRAME (xft_fadeoutin_frame), label22); + + xft_pause_adv_label = gtk_label_new ("Fade out / Fade in"); + gtk_widget_show (xft_pause_adv_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (xf_type_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (xf_type_notebook), 9), xft_pause_adv_label); + gtk_label_set_justify (GTK_LABEL (xft_pause_adv_label), GTK_JUSTIFY_CENTER); + + config_crossfade_label = gtk_label_new ("Crossfader"); + gtk_widget_show (config_crossfade_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 2), config_crossfade_label); + gtk_label_set_justify (GTK_LABEL (config_crossfade_label), GTK_JUSTIFY_CENTER); + + config_gapkiller_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_gapkiller_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_gapkiller_page); + gtk_container_set_border_width (GTK_CONTAINER (config_gapkiller_page), 5); + + gap_leading_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_leading_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_leading_frame, FALSE, TRUE, 0); + + gap_leading_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (gap_leading_table); + gtk_container_add (GTK_CONTAINER (gap_leading_frame), gap_leading_table); + gtk_container_set_border_width (GTK_CONTAINER (gap_leading_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (gap_leading_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (gap_leading_table), 5); + + lgap_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + lgap_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (lgap_length_spin_adj), 0, 0); + gtk_widget_show (lgap_length_spin); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, lgap_length_spin, "Set the maximum length for gaps at the beginning of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (lgap_length_spin), TRUE); + + lgap_level_spin_adj = gtk_adjustment_new (512, 0, 32767, 16, 256, 10); + lgap_level_spin = gtk_spin_button_new (GTK_ADJUSTMENT (lgap_level_spin_adj), 0, 0); + gtk_widget_show (lgap_level_spin); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_level_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, lgap_level_spin, "Set the maximum volume for gaps at the beginning of a stream. All samples below this value are considered as silent.\nDefault: 512", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (lgap_level_spin), TRUE); + + lgap_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (lgap_length_hbox); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + lgap_length_label = gtk_label_new ("Max. length (ms):"); + gtk_widget_show (lgap_length_label); + gtk_box_pack_start (GTK_BOX (lgap_length_hbox), lgap_length_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (lgap_length_label), GTK_JUSTIFY_CENTER); + + lgap_level_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (lgap_level_hbox); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_level_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + lgap_level_label = gtk_label_new ("Max. level (16bit sample):"); + gtk_widget_show (lgap_level_label); + gtk_box_pack_start (GTK_BOX (lgap_level_hbox), lgap_level_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (lgap_level_label), GTK_JUSTIFY_CENTER); + + lgap_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (lgap_enable_check); + gtk_table_attach (GTK_TABLE (gap_leading_table), lgap_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label23 = gtk_label_new ("Leading gap killer"); + gtk_widget_show (label23); + gtk_frame_set_label_widget (GTK_FRAME (gap_leading_frame), label23); + + gap_trailing_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_trailing_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_trailing_frame, FALSE, TRUE, 0); + + gap_trailing_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (gap_trailing_table); + gtk_container_add (GTK_CONTAINER (gap_trailing_frame), gap_trailing_table); + gtk_container_set_border_width (GTK_CONTAINER (gap_trailing_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (gap_trailing_table), 2); + gtk_table_set_col_spacings (GTK_TABLE (gap_trailing_table), 5); + + tgap_length_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (tgap_length_hbox); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_length_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + tgap_length_label = gtk_label_new ("Max. length (ms):"); + gtk_widget_show (tgap_length_label); + gtk_box_pack_start (GTK_BOX (tgap_length_hbox), tgap_length_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (tgap_length_label), GTK_JUSTIFY_CENTER); + + tgap_level_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (tgap_level_hbox); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_level_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + tgap_level_label = gtk_label_new ("Max. level (16bit sample):"); + gtk_widget_show (tgap_level_label); + gtk_box_pack_start (GTK_BOX (tgap_level_hbox), tgap_level_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (tgap_level_label), GTK_JUSTIFY_CENTER); + + tgap_length_spin_adj = gtk_adjustment_new (500, 0, 60000, 10, 100, 10); + tgap_length_spin = gtk_spin_button_new (GTK_ADJUSTMENT (tgap_length_spin_adj), 0, 0); + gtk_widget_show (tgap_length_spin); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_length_spin, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_length_spin, "Set the maximum length for gaps at the end of a stream.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tgap_length_spin), TRUE); + + tgap_level_spin_adj = gtk_adjustment_new (512, 0, 32767, 1, 16, 10); + tgap_level_spin = gtk_spin_button_new (GTK_ADJUSTMENT (tgap_level_spin_adj), 0, 0); + gtk_widget_show (tgap_level_spin); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_level_spin, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_level_spin, "Set the maximum volume for gaps at the end of a stream. All samples below this value are considered as silent.\nDefault: 512", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (tgap_level_spin), TRUE); + + tgap_lock_check = gtk_check_button_new_with_mnemonic ("Lock to Leading"); + gtk_widget_show (tgap_lock_check); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_lock_check, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + gtk_tooltips_set_tip (tooltips, tgap_lock_check, "Use the same settings as above.", NULL); + + tgap_enable_check = gtk_check_button_new_with_mnemonic ("Enable"); + gtk_widget_show (tgap_enable_check); + gtk_table_attach (GTK_TABLE (gap_trailing_table), tgap_enable_check, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + label24 = gtk_label_new ("Trailing gap killer"); + gtk_widget_show (label24); + gtk_frame_set_label_widget (GTK_FRAME (gap_trailing_frame), label24); + + gap_advanced_frame = gtk_frame_new (NULL); + gtk_widget_show (gap_advanced_frame); + gtk_box_pack_start (GTK_BOX (config_gapkiller_page), gap_advanced_frame, FALSE, FALSE, 0); + + gap_advanced_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (gap_advanced_vbox); + gtk_container_add (GTK_CONTAINER (gap_advanced_frame), gap_advanced_vbox); + gtk_container_set_border_width (GTK_CONTAINER (gap_advanced_vbox), 5); + + gadv_crossing_check = gtk_check_button_new_with_mnemonic ("Skip to next zero crossing"); + gtk_widget_show (gadv_crossing_check); + gtk_box_pack_start (GTK_BOX (gap_advanced_vbox), gadv_crossing_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, gadv_crossing_check, "If enabled, XMMS-crossfade will take additional care to avoid clicks with pre-faded (gapless) tracks. XMMS-crossfade will cut off the end of the previous song (the beginning of the next song) only at a zero-crossing of the sample values.\nDefault: On", NULL); + + label25 = gtk_label_new ("Advanced"); + gtk_widget_show (label25); + gtk_frame_set_label_widget (GTK_FRAME (gap_advanced_frame), label25); + + config_gapkiller_label = gtk_label_new ("Gap Killer"); + gtk_widget_show (config_gapkiller_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 3), config_gapkiller_label); + gtk_label_set_justify (GTK_LABEL (config_gapkiller_label), GTK_JUSTIFY_CENTER); + + config_misc_page = gtk_vbox_new (FALSE, 5); + gtk_widget_show (config_misc_page); + gtk_container_add (GTK_CONTAINER (config_notebook), config_misc_page); + gtk_container_set_border_width (GTK_CONTAINER (config_misc_page), 5); + + misc_debug_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_debug_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_debug_frame, FALSE, FALSE, 0); + + misc_debug_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_debug_vbox); + gtk_container_add (GTK_CONTAINER (misc_debug_frame), misc_debug_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_debug_vbox), 5); + + debug_stderr_check = gtk_check_button_new_with_mnemonic ("Write debug output to <stderr>"); + gtk_widget_show (debug_stderr_check); + gtk_box_pack_start (GTK_BOX (misc_debug_vbox), debug_stderr_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, debug_stderr_check, "Monitors what is going on in XMMS-crossfade. If you think you found a bug in XMMS-crossfade, please enable this option and send me the output.\nNote that you should disable debug output if you start XMMS from within Netscape. Netscape will spam you with dialogs containing the debug output captured from <stderr>.\nDefault: Off", NULL); + + debug_monitor_check = gtk_check_button_new_with_mnemonic ("Show Buffer Monitor"); + gtk_widget_show (debug_monitor_check); + gtk_box_pack_start (GTK_BOX (misc_debug_vbox), debug_monitor_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, debug_monitor_check, "Enables the Buffer Monitor. This is a small window which shows how much data is in the buffers. The top display belongs to the mixing buffer, the bottom shows how much data is being buffered by the output plugin.\nDefault: Off", NULL); + + label26 = gtk_label_new ("Debug options"); + gtk_widget_show (label26); + gtk_frame_set_label_widget (GTK_FRAME (misc_debug_frame), label26); + + misc_mixopt_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_mixopt_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_mixopt_frame, FALSE, FALSE, 0); + + misc_mixopt_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_mixopt_vbox); + gtk_container_add (GTK_CONTAINER (misc_mixopt_frame), misc_mixopt_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_mixopt_vbox), 5); + + mixopt_enable_check = gtk_check_button_new_with_mnemonic ("Enable volume control"); + gtk_widget_show (mixopt_enable_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_enable_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_enable_check, "Enables/disables XMMS volume and balance controls.\nDefault: On", NULL); + + mixopt_reverse_check = gtk_check_button_new_with_mnemonic ("Reverse balance"); + gtk_widget_show (mixopt_reverse_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_reverse_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_reverse_check, "Reverses left and right with the balance control.\nDefault: Off", NULL); + + mixopt_software_check = gtk_check_button_new_with_mnemonic ("Software Mixer"); + gtk_widget_show (mixopt_software_check); + gtk_box_pack_start (GTK_BOX (misc_mixopt_vbox), mixopt_software_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, mixopt_software_check, "Enable software mixer. Usefull for output plugins without mixer support.\nDefault: Off", NULL); + + label27 = gtk_label_new ("Volume control options"); + gtk_widget_show (label27); + gtk_frame_set_label_widget (GTK_FRAME (misc_mixopt_frame), label27); + + misc_other_frame = gtk_frame_new (NULL); + gtk_widget_show (misc_other_frame); + gtk_box_pack_start (GTK_BOX (config_misc_page), misc_other_frame, FALSE, TRUE, 0); + + misc_other_vbox = gtk_vbox_new (FALSE, 2); + gtk_widget_show (misc_other_vbox); + gtk_container_add (GTK_CONTAINER (misc_other_frame), misc_other_vbox); + gtk_container_set_border_width (GTK_CONTAINER (misc_other_vbox), 5); + + moth_songchange_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_songchange_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_songchange_hbox, TRUE, TRUE, 0); + + moth_songchange_label = gtk_label_new ("Songchange timeout (ms):"); + gtk_widget_show (moth_songchange_label); + gtk_box_pack_start (GTK_BOX (moth_songchange_hbox), moth_songchange_label, FALSE, FALSE, 0); + gtk_widget_set_sensitive (moth_songchange_label, FALSE); + gtk_label_set_justify (GTK_LABEL (moth_songchange_label), GTK_JUSTIFY_CENTER); + + moth_songchange_spin_adj = gtk_adjustment_new (500, 10, 10000, 10, 100, 10); + moth_songchange_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_songchange_spin_adj), 0, 0); + gtk_widget_show (moth_songchange_spin); + gtk_box_pack_start (GTK_BOX (moth_songchange_hbox), moth_songchange_spin, TRUE, TRUE, 0); + gtk_widget_set_sensitive (moth_songchange_spin, FALSE); + gtk_tooltips_set_tip (tooltips, moth_songchange_spin, "The songchange timeout is the maximum time XMMS-crossfade waits for the next song. If this timeout is exceeded, the output plugin/device is closed.\nDefault: 500", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_songchange_spin), TRUE); + + moth_preload_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_preload_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_preload_hbox, TRUE, TRUE, 0); + + moth_preload_label = gtk_label_new ("Mixing buffer preload (ms):"); + gtk_widget_show (moth_preload_label); + gtk_box_pack_start (GTK_BOX (moth_preload_hbox), moth_preload_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (moth_preload_label), GTK_JUSTIFY_CENTER); + + moth_preload_spin_adj = gtk_adjustment_new (0, 0, 60000, 10, 100, 10); + moth_preload_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_preload_spin_adj), 0, 0); + gtk_widget_show (moth_preload_spin); + gtk_box_pack_start (GTK_BOX (moth_preload_hbox), moth_preload_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, moth_preload_spin, "Tells XMMS-crossfade how much data it should buffer before it starts writing to the output plugin/device. Usually, this value can be set to 0, because the output plugin does preloading on its own.\nDefault: 0", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_preload_spin), TRUE); + + moth_noxf_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_noxf_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_noxf_hbox, FALSE, FALSE, 0); + + moth_noxf_label = gtk_label_new ("Don't crossfade"); + gtk_widget_show (moth_noxf_label); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), moth_noxf_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (moth_noxf_label), GTK_JUSTIFY_CENTER); + + noxf_album_check = gtk_check_button_new_with_mnemonic ("successive tracks"); + gtk_widget_show (noxf_album_check); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), noxf_album_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, noxf_album_check, "This option enables the automatic detection of pre-faded or gapless tracks, like the tracks on some compilations or on most live albums. If such tracks are detected, crossfading will be disabled and only the gapkiller (if enabled) will be used for the songchange.\nDefault: On", NULL); + + noxf_samefile_check = gtk_check_button_new_with_mnemonic ("same file"); + gtk_widget_show (noxf_samefile_check); + gtk_box_pack_start (GTK_BOX (moth_noxf_hbox), noxf_samefile_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, noxf_samefile_check, "This option disables crossfading between the same file. This can happen if you have only one file in the playlist and 'repeat' turned on.\nDefault: Off", NULL); + + moth_httpworkaround_check = gtk_check_button_new_with_mnemonic ("Enable HTTP buffer underrun workaround"); + gtk_widget_show (moth_httpworkaround_check); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_httpworkaround_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_httpworkaround_check, "Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading.\nDefault: Off", NULL); + + moth_opmaxused_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (moth_opmaxused_hbox); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_opmaxused_hbox, TRUE, TRUE, 0); + + moth_opmaxused_check = gtk_check_button_new_with_mnemonic ("Limit OP buffer usage (ms):"); + gtk_widget_show (moth_opmaxused_check); + gtk_box_pack_start (GTK_BOX (moth_opmaxused_hbox), moth_opmaxused_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_opmaxused_check, "With this option enabled, XMMS-crossfade will limit the amount of data being buffered by the output plugin. This way, you can decrease the latency between pressing STOP/NEXT/PREV and the new song actually being played. \nDefault: Off", NULL); + + moth_opmaxused_spin_adj = gtk_adjustment_new (500, 10, 10000, 10, 100, 10); + moth_opmaxused_spin = gtk_spin_button_new (GTK_ADJUSTMENT (moth_opmaxused_spin_adj), 0, 0); + gtk_widget_show (moth_opmaxused_spin); + gtk_box_pack_start (GTK_BOX (moth_opmaxused_hbox), moth_opmaxused_spin, TRUE, TRUE, 0); + gtk_tooltips_set_tip (tooltips, moth_opmaxused_spin, "Beware that setting this value too low also increases the chance of buffer underruns.\nDefault: 250", NULL); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (moth_opmaxused_spin), TRUE); + + moth_quantaudio_check = gtk_check_button_new_with_mnemonic ("Use Quantaudio timing comments"); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_quantaudio_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_quantaudio_check, "Enable this when you have problems playing internet HTTP audio streams. Unfortunatelly, it also breaks crossfading.\nDefault: Off", NULL); + + moth_outputkeepopened_check = gtk_check_button_new_with_mnemonic ("Keep output opened"); + gtk_widget_show (moth_outputkeepopened_check); + gtk_box_pack_start (GTK_BOX (misc_other_vbox), moth_outputkeepopened_check, FALSE, FALSE, 0); + gtk_tooltips_set_tip (tooltips, moth_outputkeepopened_check, "Keep the output device opened all the time, even if XMMS is stopped. This way, you can avoid clicks caused by the soundcard when the device is opened or closed\nDefault: Off", NULL); + + label28 = gtk_label_new ("Advanced options"); + gtk_widget_show (label28); + gtk_frame_set_label_widget (GTK_FRAME (misc_other_frame), label28); + + config_misc_label = gtk_label_new ("Advanced"); + gtk_widget_show (config_misc_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 4), config_misc_label); + gtk_label_set_justify (GTK_LABEL (config_misc_label), GTK_JUSTIFY_CENTER); + + config_presets_page = gtk_vbox_new (FALSE, 5); + gtk_container_add (GTK_CONTAINER (config_notebook), config_presets_page); + gtk_container_set_border_width (GTK_CONTAINER (config_presets_page), 5); + + presets_name_hbox = gtk_hbox_new (FALSE, 5); + gtk_widget_show (presets_name_hbox); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_name_hbox, FALSE, FALSE, 0); + + presets_name_entry = gtk_entry_new (); + gtk_widget_show (presets_name_entry); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_name_entry, TRUE, TRUE, 0); + + presets_delete_button = gtk_button_new_with_mnemonic ("Delete"); + gtk_widget_show (presets_delete_button); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_delete_button, FALSE, FALSE, 0); + + presets_new_button = gtk_button_new_with_mnemonic ("New"); + gtk_widget_show (presets_new_button); + gtk_box_pack_start (GTK_BOX (presets_name_hbox), presets_new_button, FALSE, FALSE, 0); + + presets_list_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (presets_list_scrolledwindow); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_list_scrolledwindow, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (presets_list_scrolledwindow, GTK_CAN_FOCUS); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (presets_list_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (presets_list_scrolledwindow), GTK_SHADOW_IN); + + presets_list_list = gtk_tree_view_new (); + gtk_widget_show (presets_list_list); + gtk_container_add (GTK_CONTAINER (presets_list_scrolledwindow), presets_list_list); + + presets_list_bbox = gtk_hbutton_box_new (); + gtk_widget_show (presets_list_bbox); + gtk_box_pack_start (GTK_BOX (config_presets_page), presets_list_bbox, FALSE, FALSE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (presets_list_bbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (presets_list_bbox), 5); + + presets_load_button = gtk_button_new_with_mnemonic ("Load"); + gtk_widget_show (presets_load_button); + gtk_container_add (GTK_CONTAINER (presets_list_bbox), presets_load_button); + GTK_WIDGET_SET_FLAGS (presets_load_button, GTK_CAN_DEFAULT); + + presets_save_button = gtk_button_new_with_mnemonic ("Save"); + gtk_widget_show (presets_save_button); + gtk_container_add (GTK_CONTAINER (presets_list_bbox), presets_save_button); + GTK_WIDGET_SET_FLAGS (presets_save_button, GTK_CAN_DEFAULT); + + config_presets_label = gtk_label_new ("Presets"); + gtk_widget_show (config_presets_label); + gtk_notebook_set_tab_label (GTK_NOTEBOOK (config_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (config_notebook), 5), config_presets_label); + gtk_label_set_justify (GTK_LABEL (config_presets_label), GTK_JUSTIFY_CENTER); + + config_bbox = gtk_hbutton_box_new (); + gtk_widget_show (config_bbox); + gtk_box_pack_start (GTK_BOX (config_vbox), config_bbox, FALSE, TRUE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (config_bbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (config_bbox), 5); + + config_ok = gtk_button_new_with_mnemonic ("OK"); + gtk_widget_show (config_ok); + gtk_container_add (GTK_CONTAINER (config_bbox), config_ok); + GTK_WIDGET_SET_FLAGS (config_ok, GTK_CAN_DEFAULT); + + config_cancel = gtk_button_new_with_mnemonic ("Cancel"); + gtk_widget_show (config_cancel); + gtk_container_add (GTK_CONTAINER (config_bbox), config_cancel); + GTK_WIDGET_SET_FLAGS (config_cancel, GTK_CAN_DEFAULT); + + config_apply = gtk_button_new_with_mnemonic ("Apply"); + gtk_widget_show (config_apply); + gtk_container_add (GTK_CONTAINER (config_bbox), config_apply); + GTK_WIDGET_SET_FLAGS (config_apply, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) output_oss_radio, "toggled", + G_CALLBACK (on_output_oss_radio_toggled), + NULL); + g_signal_connect ((gpointer) output_plugin_radio, "toggled", + G_CALLBACK (on_output_plugin_radio_toggled), + NULL); + g_signal_connect ((gpointer) output_none_radio, "toggled", + G_CALLBACK (on_output_none_radio_toggled), + NULL); + g_signal_connect ((gpointer) oss_adevice_alt_check, "toggled", + G_CALLBACK (on_config_adevice_alt_check_toggled), + NULL); + g_signal_connect ((gpointer) oss_mdevice_alt_check, "toggled", + G_CALLBACK (on_config_mdevice_alt_check_toggled), + NULL); + g_signal_connect ((gpointer) osshwb_maxbuf_check, "toggled", + G_CALLBACK (on_osshwb_maxbuf_check_toggled), + NULL); + g_signal_connect ((gpointer) op_configure_button, "clicked", + G_CALLBACK (on_output_plugin_configure_button_clicked), + NULL); + g_signal_connect ((gpointer) op_about_button, "clicked", + G_CALLBACK (on_output_plugin_about_button_clicked), + NULL); + g_signal_connect ((gpointer) op_throttle_check, "toggled", + G_CALLBACK (on_op_throttle_check_toggled), + NULL); + g_signal_connect ((gpointer) op_maxblock_check, "toggled", + G_CALLBACK (on_op_maxblock_check_toggled), + NULL); + g_signal_connect ((gpointer) op_maxblock_spin, "changed", + G_CALLBACK (on_op_maxblock_spin_changed), + NULL); + g_signal_connect ((gpointer) op_forcereopen_check, "toggled", + G_CALLBACK (on_op_forcereopen_check_toggled), + NULL); + g_signal_connect ((gpointer) ep_configure_button, "clicked", + G_CALLBACK (on_ep_configure_button_clicked), + NULL); + g_signal_connect ((gpointer) ep_about_button, "clicked", + G_CALLBACK (on_ep_about_button_clicked), + NULL); + g_signal_connect ((gpointer) ep_enable_check, "toggled", + G_CALLBACK (on_ep_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) volnorm_enable_check, "toggled", + G_CALLBACK (on_volnorm_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xf_buffer_spin, "changed", + G_CALLBACK (on_xf_buffer_spin_changed), + NULL); + g_signal_connect ((gpointer) xf_autobuf_check, "toggled", + G_CALLBACK (on_xf_autobuf_check_toggled), + NULL); + g_signal_connect ((gpointer) xftfp_length_spin, "changed", + G_CALLBACK (on_xftfp_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfp_enable_check, "toggled", + G_CALLBACK (on_xftfp_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xftffi_length_spin, "changed", + G_CALLBACK (on_xftffi_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftffi_enable_check, "toggled", + G_CALLBACK (on_xftffi_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xftffi_volume_spin, "changed", + G_CALLBACK (on_xftffi_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) pause_length_spin, "changed", + G_CALLBACK (on_pause_length_spin_changed), + NULL); + g_signal_connect ((gpointer) simple_length_spin, "changed", + G_CALLBACK (on_simple_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_length_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_volume_spin, "changed", + G_CALLBACK (on_fadeout_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) fadeout_enable_check, "toggled", + G_CALLBACK (on_fadeout_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_custom_radiobutton, "toggled", + G_CALLBACK (on_xfofs_custom_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_custom_radiobutton, "clicked", + G_CALLBACK (on_xfofs_custom_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_custom_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xfofs_none_radiobutton, "clicked", + G_CALLBACK (on_xfofs_none_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_none_radiobutton, "toggled", + G_CALLBACK (on_xfofs_none_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockout_radiobutton, "toggled", + G_CALLBACK (on_xfofs_lockout_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockout_radiobutton, "clicked", + G_CALLBACK (on_xfofs_lockout_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) xfofs_lockin_radiobutton, "toggled", + G_CALLBACK (on_xfofs_lockin_radiobutton_toggled), + NULL); + g_signal_connect ((gpointer) xfofs_lockin_radiobutton, "clicked", + G_CALLBACK (on_xfofs_lockin_radiobutton_clicked), + NULL); + g_signal_connect ((gpointer) fadein_length_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) fadein_enable_check, "toggled", + G_CALLBACK (on_fadein_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) fadein_lock_check, "toggled", + G_CALLBACK (on_fadein_lock_check_toggled), + NULL); + g_signal_connect ((gpointer) fadein_volume_spin, "changed", + G_CALLBACK (on_fadein_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfi_length_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfi_volume_spin, "changed", + G_CALLBACK (on_fadein_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_length_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_volume_spin, "changed", + G_CALLBACK (on_fadeout_volume_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfo_silence_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_fadeout_spin, "changed", + G_CALLBACK (on_fadeout_length_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_silence_spin, "changed", + G_CALLBACK (on_xfofs_custom_spin_changed), + NULL); + g_signal_connect ((gpointer) xftfoi_fadein_spin, "changed", + G_CALLBACK (on_fadein_length_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_length_spin, "changed", + G_CALLBACK (on_lgap_length_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_level_spin, "changed", + G_CALLBACK (on_lgap_level_spin_changed), + NULL); + g_signal_connect ((gpointer) lgap_enable_check, "toggled", + G_CALLBACK (on_lgap_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) tgap_length_spin, "changed", + G_CALLBACK (on_tgap_length_spin_changed), + NULL); + g_signal_connect ((gpointer) tgap_level_spin, "changed", + G_CALLBACK (on_tgap_level_spin_changed), + NULL); + g_signal_connect ((gpointer) tgap_lock_check, "toggled", + G_CALLBACK (on_tgap_lock_check_toggled), + NULL); + g_signal_connect ((gpointer) tgap_enable_check, "toggled", + G_CALLBACK (on_tgap_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) mixopt_enable_check, "toggled", + G_CALLBACK (on_config_mixopt_enable_check_toggled), + NULL); + g_signal_connect ((gpointer) moth_songchange_spin, "changed", + G_CALLBACK (on_moth_songchange_spin_changed), + NULL); + g_signal_connect ((gpointer) moth_opmaxused_check, "toggled", + G_CALLBACK (on_moth_opmaxused_check_toggled), + NULL); + g_signal_connect ((gpointer) presets_list_list, "click_column", + G_CALLBACK (on_presets_list_click_column), + NULL); + g_signal_connect ((gpointer) config_ok, "clicked", + G_CALLBACK (on_config_ok_clicked), + NULL); + g_signal_connect_swapped ((gpointer) config_cancel, "clicked", + G_CALLBACK (gtk_widget_destroy), + GTK_OBJECT (config_win)); + g_signal_connect ((gpointer) config_apply, "clicked", + G_CALLBACK (on_config_apply_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (config_win, config_win, "config_win"); + GLADE_HOOKUP_OBJECT (config_win, config_vbox, "config_vbox"); + GLADE_HOOKUP_OBJECT (config_win, config_notebook, "config_notebook"); + GLADE_HOOKUP_OBJECT (config_win, config_output_page, "config_output_page"); + GLADE_HOOKUP_OBJECT (config_win, output_options_hbox, "output_options_hbox"); + GLADE_HOOKUP_OBJECT (config_win, output_method_frame, "output_method_frame"); + GLADE_HOOKUP_OBJECT (config_win, output_method_vbox, "output_method_vbox"); + GLADE_HOOKUP_OBJECT (config_win, output_oss_radio, "output_oss_radio"); + GLADE_HOOKUP_OBJECT (config_win, output_plugin_radio, "output_plugin_radio"); + GLADE_HOOKUP_OBJECT (config_win, output_none_radio, "output_none_radio"); + GLADE_HOOKUP_OBJECT (config_win, label1, "label1"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_frame, "output_resampling_frame"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_table, "output_resampling_table"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_hbox, "resampling_rate_hbox"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_label, "resampling_rate_label"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_hbox, "resampling_quality_hbox"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_label, "resampling_quality_label"); + GLADE_HOOKUP_OBJECT (config_win, resampling_rate_optionmenu, "resampling_rate_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, resampling_quality_optionmenu, "resampling_quality_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, output_resampling_label, "output_resampling_label"); + GLADE_HOOKUP_OBJECT (config_win, output_notebook, "output_notebook"); + GLADE_HOOKUP_OBJECT (config_win, output_oss_page, "output_oss_page"); + GLADE_HOOKUP_OBJECT (config_win, output_oss_notebook, "output_oss_notebook"); + GLADE_HOOKUP_OBJECT (config_win, oss_device_page, "oss_device_page"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_frame, "oss_adevice_frame"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_vbox, "oss_adevice_vbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_hbox, "oss_adevice_hbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_optionmenu, "oss_adevice_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget1, "convertwidget1"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget2, "convertwidget2"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_alt_hbox, "oss_adevice_alt_hbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_alt_check, "oss_adevice_alt_check"); + GLADE_HOOKUP_OBJECT (config_win, oss_adevice_alt_entry, "oss_adevice_alt_entry"); + GLADE_HOOKUP_OBJECT (config_win, label3, "label3"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_frame, "oss_mdevice_frame"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_vbox, "oss_mdevice_vbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_hbox, "oss_mdevice_hbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_optionmenu, "oss_mdevice_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget3, "convertwidget3"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget4, "convertwidget4"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_alt_hbox, "oss_mdevice_alt_hbox"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_alt_check, "oss_mdevice_alt_check"); + GLADE_HOOKUP_OBJECT (config_win, oss_mdevice_alt_entry, "oss_mdevice_alt_entry"); + GLADE_HOOKUP_OBJECT (config_win, label4, "label4"); + GLADE_HOOKUP_OBJECT (config_win, oss_device_label, "oss_device_label"); + GLADE_HOOKUP_OBJECT (config_win, oss_buffer_page, "oss_buffer_page"); + GLADE_HOOKUP_OBJECT (config_win, oss_buffer_frame, "oss_buffer_frame"); + GLADE_HOOKUP_OBJECT (config_win, oss_buffer_vbox, "oss_buffer_vbox"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_buffer_hbox, "ossbuf_buffer_hbox"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_buffer_label, "ossbuf_buffer_label"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_buffer_spin, "ossbuf_buffer_spin"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_preload_hbox, "ossbuf_preload_hbox"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_preload_label, "ossbuf_preload_label"); + GLADE_HOOKUP_OBJECT (config_win, ossbuf_preload_spin, "ossbuf_preload_spin"); + GLADE_HOOKUP_OBJECT (config_win, label5, "label5"); + GLADE_HOOKUP_OBJECT (config_win, oss_hwbuf_frame, "oss_hwbuf_frame"); + GLADE_HOOKUP_OBJECT (config_win, oss_hwbuf_vbox, "oss_hwbuf_vbox"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_maxbuf_check, "osshwb_maxbuf_check"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragments_hbox, "osshwb_fragments_hbox"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragments_label, "osshwb_fragments_label"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragments_spin, "osshwb_fragments_spin"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragsize_hbox, "osshwb_fragsize_hbox"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragsize_label, "osshwb_fragsize_label"); + GLADE_HOOKUP_OBJECT (config_win, osshwb_fragsize_spin, "osshwb_fragsize_spin"); + GLADE_HOOKUP_OBJECT (config_win, label6, "label6"); + GLADE_HOOKUP_OBJECT (config_win, oss_buffer_label, "oss_buffer_label"); + GLADE_HOOKUP_OBJECT (config_win, oss_mixer_page, "oss_mixer_page"); + GLADE_HOOKUP_OBJECT (config_win, oss_mixer_frame, "oss_mixer_frame"); + GLADE_HOOKUP_OBJECT (config_win, oss_mixer_vbox, "oss_mixer_vbox"); + GLADE_HOOKUP_OBJECT (config_win, ossmixer_pcm_check, "ossmixer_pcm_check"); + GLADE_HOOKUP_OBJECT (config_win, label7, "label7"); + GLADE_HOOKUP_OBJECT (config_win, oss_mixer_label, "oss_mixer_label"); + GLADE_HOOKUP_OBJECT (config_win, label29, "label29"); + GLADE_HOOKUP_OBJECT (config_win, output_plugin_page, "output_plugin_page"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_frame, "op_plugin_frame"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_vbox, "op_plugin_vbox"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_optionmenu, "op_plugin_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget5, "convertwidget5"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget6, "convertwidget6"); + GLADE_HOOKUP_OBJECT (config_win, op_plugin_buttonbox, "op_plugin_buttonbox"); + GLADE_HOOKUP_OBJECT (config_win, op_configure_button, "op_configure_button"); + GLADE_HOOKUP_OBJECT (config_win, op_about_button, "op_about_button"); + GLADE_HOOKUP_OBJECT (config_win, label8, "label8"); + GLADE_HOOKUP_OBJECT (config_win, op_options_frame, "op_options_frame"); + GLADE_HOOKUP_OBJECT (config_win, op_options_vbox, "op_options_vbox"); + GLADE_HOOKUP_OBJECT (config_win, op_throttle_check, "op_throttle_check"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_hbox, "op_maxblock_hbox"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_check, "op_maxblock_check"); + GLADE_HOOKUP_OBJECT (config_win, op_maxblock_spin, "op_maxblock_spin"); + GLADE_HOOKUP_OBJECT (config_win, op_forcereopen_check, "op_forcereopen_check"); + GLADE_HOOKUP_OBJECT (config_win, label9, "label9"); + GLADE_HOOKUP_OBJECT (config_win, label31, "label31"); + GLADE_HOOKUP_OBJECT (config_win, label32, "label32"); + GLADE_HOOKUP_OBJECT (config_win, label33, "label33"); + GLADE_HOOKUP_OBJECT (config_win, label34, "label34"); + GLADE_HOOKUP_OBJECT (config_win, output_help_label, "output_help_label"); + GLADE_HOOKUP_OBJECT (config_win, config_devices_label, "config_devices_label"); + GLADE_HOOKUP_OBJECT (config_win, config_effects_page, "config_effects_page"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_frame, "ep_plugin_frame"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_vbox, "ep_plugin_vbox"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_optionmenu, "ep_plugin_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget7, "convertwidget7"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget8, "convertwidget8"); + GLADE_HOOKUP_OBJECT (config_win, ep_plugin_buttonbox, "ep_plugin_buttonbox"); + GLADE_HOOKUP_OBJECT (config_win, ep_configure_button, "ep_configure_button"); + GLADE_HOOKUP_OBJECT (config_win, ep_about_button, "ep_about_button"); + GLADE_HOOKUP_OBJECT (config_win, ep_enable_check, "ep_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label10, "label10"); + GLADE_HOOKUP_OBJECT (config_win, effects_volnorm_frame, "effects_volnorm_frame"); + GLADE_HOOKUP_OBJECT (config_win, effects_volnorm_table, "effects_volnorm_table"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_quantaudio_check, "volnorm_quantaudio_check"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_spin, "volnorm_target_spin"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_hbox, "volnorm_target_hbox"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_target_label, "volnorm_target_label"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_enable_check, "volnorm_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, volnorm_rva2_check, "volnorm_rva2_check"); + GLADE_HOOKUP_OBJECT (config_win, label11, "label11"); + GLADE_HOOKUP_OBJECT (config_win, effects_help_label, "effects_help_label"); + GLADE_HOOKUP_OBJECT (config_win, config_effects_label, "config_effects_label"); + GLADE_HOOKUP_OBJECT (config_win, config_crossfader_page, "config_crossfader_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_bufsize_hbox, "xf_bufsize_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_bufsize_label, "xf_bufsize_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_buffer_spin, "xf_buffer_spin"); + GLADE_HOOKUP_OBJECT (config_win, xf_autobuf_check, "xf_autobuf_check"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_hbox, "xf_config_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_label, "xf_config_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_config_optionmenu, "xf_config_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget9, "convertwidget9"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget10, "convertwidget10"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_hbox, "xf_type_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_label, "xf_type_label"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_optionmenu, "xf_type_optionmenu"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget11, "convertwidget11"); + GLADE_HOOKUP_OBJECT (config_win, convertwidget12, "convertwidget12"); + GLADE_HOOKUP_OBJECT (config_win, xf_type_notebook, "xf_type_notebook"); + GLADE_HOOKUP_OBJECT (config_win, xft_reopen_label, "xft_reopen_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_flush_page, "xft_flush_page"); + GLADE_HOOKUP_OBJECT (config_win, xftf_pause_frame, "xftf_pause_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftf_pause_table, "xftf_pause_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_length_label, "xftfp_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_length_spin, "xftfp_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfp_enable_check, "xftfp_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label12, "label12"); + GLADE_HOOKUP_OBJECT (config_win, xftf_fadein_frame, "xftf_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftf_fadein_table, "xftf_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_hbox, "xftffi_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_label, "xftffi_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_hbox, "xftffi_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_label, "xftffi_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_length_spin, "xftffi_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_enable_check, "xftffi_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, xftffi_volume_spin, "xftffi_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label13, "label13"); + GLADE_HOOKUP_OBJECT (config_win, xft_flush_label, "xft_flush_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_none_label, "xft_none_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_page, "xft_pause_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_pause_frame, "xf_pause_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_pause_table, "xf_pause_table"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_hbox, "pause_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_label, "pause_length_label"); + GLADE_HOOKUP_OBJECT (config_win, pause_length_spin, "pause_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, label14, "label14"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_label, "xft_pause_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_simplexf_page, "xft_simplexf_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_simple_frame, "xf_simple_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_simple_table, "xf_simple_table"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_hbox, "simple_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_label, "simple_length_label"); + GLADE_HOOKUP_OBJECT (config_win, simple_length_spin, "simple_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, label15, "label15"); + GLADE_HOOKUP_OBJECT (config_win, xft_simplexf_label, "xft_simplexf_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_advancedxf_page, "xft_advancedxf_page"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadeout_frame, "xf_fadeout_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadeout_table, "xf_fadeout_table"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_hbox, "fadeout_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_label, "fadeout_length_label"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_length_spin, "fadeout_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_hbox, "fadeout_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_label, "fadeout_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_volume_spin, "fadeout_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_options_hbox, "fadeout_options_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadeout_enable_check, "fadeout_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label16, "label16"); + GLADE_HOOKUP_OBJECT (config_win, xf_offset_frame, "xf_offset_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_offset_table, "xf_offset_table"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_hbox, "xfofs_custom_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_radiobutton, "xfofs_custom_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_custom_spin, "xfofs_custom_spin"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_none_radiobutton, "xfofs_none_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_lockout_radiobutton, "xfofs_lockout_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, xfofs_lockin_radiobutton, "xfofs_lockin_radiobutton"); + GLADE_HOOKUP_OBJECT (config_win, label17, "label17"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadein_frame, "xf_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xf_fadein_table, "xf_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_hbox, "fadein_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_label, "fadein_length_label"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_hbox, "fadein_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_label, "fadein_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, fadein_length_spin, "fadein_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, fadein_enable_check, "fadein_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, fadein_lock_check, "fadein_lock_check"); + GLADE_HOOKUP_OBJECT (config_win, fadein_volume_spin, "fadein_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label18, "label18"); + GLADE_HOOKUP_OBJECT (config_win, xft_advancedxf_label, "xft_advancedxf_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadein_page, "xft_fadein_page"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_fadein_frame, "xftfi_fadein_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_fadein_table, "xftfi_fadein_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_hbox, "xftfi_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_label, "xftfi_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_hbox, "xftfi_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_label, "xftfi_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_length_spin, "xftfi_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfi_volume_spin, "xftfi_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label19, "label19"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadein_label, "xft_fadein_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeout_page, "xft_fadeout_page"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_fadeout_frame, "xftfo_fadeout_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_fadeout_table, "xftfo_fadeout_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_hbox, "xftfo_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_label, "xftfo_length_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_length_spin, "xftfo_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_hbox, "xftfo_volume_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_label, "xftfo_volume_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_volume_spin, "xftfo_volume_spin"); + GLADE_HOOKUP_OBJECT (config_win, label20, "label20"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_frame, "xftfo_silence_frame"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_table, "xftfo_silence_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_hbox, "xftfo_silence_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_label, "xftfo_silence_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfo_silence_spin, "xftfo_silence_spin"); + GLADE_HOOKUP_OBJECT (config_win, label21, "label21"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeout_label, "xft_fadeout_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_none_label, "xft_pause_none_label"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_adv_page, "xft_pause_adv_page"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeoutin_frame, "xft_fadeoutin_frame"); + GLADE_HOOKUP_OBJECT (config_win, xft_fadeoutin_table, "xft_fadeoutin_table"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_spin, "xftfoi_fadeout_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_spin, "xftfoi_silence_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_spin, "xftfoi_fadein_spin"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_hbox, "xftfoi_fadein_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadein_label, "xftfoi_fadein_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_hbox, "xftfoi_silence_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_silence_label, "xftfoi_silence_label"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_hbox, "xftfoi_fadeout_hbox"); + GLADE_HOOKUP_OBJECT (config_win, xftfoi_fadeout_label, "xftfoi_fadeout_label"); + GLADE_HOOKUP_OBJECT (config_win, label22, "label22"); + GLADE_HOOKUP_OBJECT (config_win, xft_pause_adv_label, "xft_pause_adv_label"); + GLADE_HOOKUP_OBJECT (config_win, config_crossfade_label, "config_crossfade_label"); + GLADE_HOOKUP_OBJECT (config_win, config_gapkiller_page, "config_gapkiller_page"); + GLADE_HOOKUP_OBJECT (config_win, gap_leading_frame, "gap_leading_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_leading_table, "gap_leading_table"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_spin, "lgap_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_spin, "lgap_level_spin"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_hbox, "lgap_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, lgap_length_label, "lgap_length_label"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_hbox, "lgap_level_hbox"); + GLADE_HOOKUP_OBJECT (config_win, lgap_level_label, "lgap_level_label"); + GLADE_HOOKUP_OBJECT (config_win, lgap_enable_check, "lgap_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label23, "label23"); + GLADE_HOOKUP_OBJECT (config_win, gap_trailing_frame, "gap_trailing_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_trailing_table, "gap_trailing_table"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_hbox, "tgap_length_hbox"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_label, "tgap_length_label"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_hbox, "tgap_level_hbox"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_label, "tgap_level_label"); + GLADE_HOOKUP_OBJECT (config_win, tgap_length_spin, "tgap_length_spin"); + GLADE_HOOKUP_OBJECT (config_win, tgap_level_spin, "tgap_level_spin"); + GLADE_HOOKUP_OBJECT (config_win, tgap_lock_check, "tgap_lock_check"); + GLADE_HOOKUP_OBJECT (config_win, tgap_enable_check, "tgap_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, label24, "label24"); + GLADE_HOOKUP_OBJECT (config_win, gap_advanced_frame, "gap_advanced_frame"); + GLADE_HOOKUP_OBJECT (config_win, gap_advanced_vbox, "gap_advanced_vbox"); + GLADE_HOOKUP_OBJECT (config_win, gadv_crossing_check, "gadv_crossing_check"); + GLADE_HOOKUP_OBJECT (config_win, label25, "label25"); + GLADE_HOOKUP_OBJECT (config_win, config_gapkiller_label, "config_gapkiller_label"); + GLADE_HOOKUP_OBJECT (config_win, config_misc_page, "config_misc_page"); + GLADE_HOOKUP_OBJECT (config_win, misc_debug_frame, "misc_debug_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_debug_vbox, "misc_debug_vbox"); + GLADE_HOOKUP_OBJECT (config_win, debug_stderr_check, "debug_stderr_check"); + GLADE_HOOKUP_OBJECT (config_win, debug_monitor_check, "debug_monitor_check"); + GLADE_HOOKUP_OBJECT (config_win, label26, "label26"); + GLADE_HOOKUP_OBJECT (config_win, misc_mixopt_frame, "misc_mixopt_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_mixopt_vbox, "misc_mixopt_vbox"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_enable_check, "mixopt_enable_check"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_reverse_check, "mixopt_reverse_check"); + GLADE_HOOKUP_OBJECT (config_win, mixopt_software_check, "mixopt_software_check"); + GLADE_HOOKUP_OBJECT (config_win, label27, "label27"); + GLADE_HOOKUP_OBJECT (config_win, misc_other_frame, "misc_other_frame"); + GLADE_HOOKUP_OBJECT (config_win, misc_other_vbox, "misc_other_vbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_hbox, "moth_songchange_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_label, "moth_songchange_label"); + GLADE_HOOKUP_OBJECT (config_win, moth_songchange_spin, "moth_songchange_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_hbox, "moth_preload_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_label, "moth_preload_label"); + GLADE_HOOKUP_OBJECT (config_win, moth_preload_spin, "moth_preload_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_noxf_hbox, "moth_noxf_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_noxf_label, "moth_noxf_label"); + GLADE_HOOKUP_OBJECT (config_win, noxf_album_check, "noxf_album_check"); + GLADE_HOOKUP_OBJECT (config_win, noxf_samefile_check, "noxf_samefile_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_httpworkaround_check, "moth_httpworkaround_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_hbox, "moth_opmaxused_hbox"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_check, "moth_opmaxused_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_opmaxused_spin, "moth_opmaxused_spin"); + GLADE_HOOKUP_OBJECT (config_win, moth_quantaudio_check, "moth_quantaudio_check"); + GLADE_HOOKUP_OBJECT (config_win, moth_outputkeepopened_check, "moth_outputkeepopened_check"); + GLADE_HOOKUP_OBJECT (config_win, label28, "label28"); + GLADE_HOOKUP_OBJECT (config_win, config_misc_label, "config_misc_label"); + GLADE_HOOKUP_OBJECT (config_win, config_presets_page, "config_presets_page"); + GLADE_HOOKUP_OBJECT (config_win, presets_name_hbox, "presets_name_hbox"); + GLADE_HOOKUP_OBJECT (config_win, presets_name_entry, "presets_name_entry"); + GLADE_HOOKUP_OBJECT (config_win, presets_delete_button, "presets_delete_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_new_button, "presets_new_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_scrolledwindow, "presets_list_scrolledwindow"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_list, "presets_list_list"); + GLADE_HOOKUP_OBJECT (config_win, presets_list_bbox, "presets_list_bbox"); + GLADE_HOOKUP_OBJECT (config_win, presets_load_button, "presets_load_button"); + GLADE_HOOKUP_OBJECT (config_win, presets_save_button, "presets_save_button"); + GLADE_HOOKUP_OBJECT (config_win, config_presets_label, "config_presets_label"); + GLADE_HOOKUP_OBJECT (config_win, config_bbox, "config_bbox"); + GLADE_HOOKUP_OBJECT (config_win, config_ok, "config_ok"); + GLADE_HOOKUP_OBJECT (config_win, config_cancel, "config_cancel"); + GLADE_HOOKUP_OBJECT (config_win, config_apply, "config_apply"); + GLADE_HOOKUP_OBJECT_NO_REF (config_win, tooltips, "tooltips"); + + return config_win; +} + +GtkWidget* +create_monitor_win (void) +{ + GtkWidget *monitor_win; + GtkWidget *monitor_table; + GtkWidget *monitor_output_hbox; + GtkWidget *monitor_output_progress; + GtkWidget *monitor_output_label2; + GtkWidget *monitor_displaylabel_hbox; + GtkWidget *monitor_display_label; + GtkWidget *monitor_position_hbox; + GtkWidget *monpos_position_label; + GtkWidget *monpos_label1; + GtkWidget *monpos_total_label; + GtkWidget *monpos_label2; + GtkWidget *monpos_left_label; + GtkWidget *monpos_label3; + GtkWidget *monpos_written_time_label; + GtkWidget *monpos_output_time_separator_label; + GtkWidget *monpos_output_time_label; + GtkWidget *monitor_outputlabel_hbox; + GtkWidget *monitor_output_label; + GtkWidget *monitor_positionlabel_hbox; + GtkWidget *monitor_position_label; + GtkWidget *monitor_display_frame; + GtkWidget *monitor_display_drawingarea; + + monitor_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (monitor_win), "Crossfade Buffer Monitor"); + gtk_window_set_default_size (GTK_WINDOW (monitor_win), 320, -1); + + monitor_table = gtk_table_new (3, 2, FALSE); + gtk_widget_show (monitor_table); + gtk_container_add (GTK_CONTAINER (monitor_win), monitor_table); + gtk_container_set_border_width (GTK_CONTAINER (monitor_table), 5); + gtk_table_set_row_spacings (GTK_TABLE (monitor_table), 3); + gtk_table_set_col_spacings (GTK_TABLE (monitor_table), 5); + + monitor_output_hbox = gtk_hbox_new (FALSE, 3); + gtk_widget_show (monitor_output_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_output_hbox, 1, 2, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_output_progress = gtk_progress_bar_new (); + gtk_widget_show (monitor_output_progress); + gtk_box_pack_start (GTK_BOX (monitor_output_hbox), monitor_output_progress, TRUE, TRUE, 0); + + monitor_output_label2 = gtk_label_new ("ms"); + gtk_widget_show (monitor_output_label2); + gtk_box_pack_start (GTK_BOX (monitor_output_hbox), monitor_output_label2, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_output_label2), GTK_JUSTIFY_CENTER); + + monitor_displaylabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_displaylabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_displaylabel_hbox, 0, 1, 0, 1, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_display_label = gtk_label_new ("Mixing Buffer:"); + gtk_widget_show (monitor_display_label); + gtk_box_pack_end (GTK_BOX (monitor_displaylabel_hbox), monitor_display_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_display_label), GTK_JUSTIFY_CENTER); + + monitor_position_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_position_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_position_hbox, 1, 2, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monpos_position_label = gtk_label_new ("-:--.-"); + gtk_widget_show (monpos_position_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_position_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_position_label), GTK_JUSTIFY_CENTER); + + monpos_label1 = gtk_label_new (" / "); + gtk_widget_show (monpos_label1); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label1, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label1), GTK_JUSTIFY_CENTER); + + monpos_total_label = gtk_label_new ("-:--"); + gtk_widget_show (monpos_total_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_total_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_total_label), GTK_JUSTIFY_CENTER); + + monpos_label2 = gtk_label_new (" total, "); + gtk_widget_show (monpos_label2); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label2, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label2), GTK_JUSTIFY_CENTER); + + monpos_left_label = gtk_label_new ("-:--"); + gtk_widget_show (monpos_left_label); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_left_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_left_label), GTK_JUSTIFY_CENTER); + + monpos_label3 = gtk_label_new (" left"); + gtk_widget_show (monpos_label3); + gtk_box_pack_start (GTK_BOX (monitor_position_hbox), monpos_label3, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_label3), GTK_JUSTIFY_CENTER); + + monpos_written_time_label = gtk_label_new ("-:--:--.-"); + gtk_widget_show (monpos_written_time_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_written_time_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_written_time_label), GTK_JUSTIFY_CENTER); + + monpos_output_time_separator_label = gtk_label_new (" / "); + gtk_widget_show (monpos_output_time_separator_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_output_time_separator_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_output_time_separator_label), GTK_JUSTIFY_CENTER); + + monpos_output_time_label = gtk_label_new ("-:--.---"); + gtk_widget_show (monpos_output_time_label); + gtk_box_pack_end (GTK_BOX (monitor_position_hbox), monpos_output_time_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monpos_output_time_label), GTK_JUSTIFY_CENTER); + + monitor_outputlabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_outputlabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_outputlabel_hbox, 0, 1, 1, 2, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (GTK_FILL), 0, 0); + + monitor_output_label = gtk_label_new ("Output Buffer:"); + gtk_widget_show (monitor_output_label); + gtk_box_pack_end (GTK_BOX (monitor_outputlabel_hbox), monitor_output_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_output_label), GTK_JUSTIFY_CENTER); + + monitor_positionlabel_hbox = gtk_hbox_new (FALSE, 0); + gtk_widget_show (monitor_positionlabel_hbox); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_positionlabel_hbox, 0, 1, 2, 3, + (GtkAttachOptions) (GTK_FILL), + (GtkAttachOptions) (0), 0, 0); + + monitor_position_label = gtk_label_new ("Position:"); + gtk_widget_show (monitor_position_label); + gtk_box_pack_end (GTK_BOX (monitor_positionlabel_hbox), monitor_position_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (monitor_position_label), GTK_JUSTIFY_CENTER); + + monitor_display_frame = gtk_frame_new (NULL); + gtk_widget_show (monitor_display_frame); + gtk_table_attach (GTK_TABLE (monitor_table), monitor_display_frame, 1, 2, 0, 1, + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), + (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); + + monitor_display_drawingarea = gtk_drawing_area_new (); + gtk_widget_show (monitor_display_drawingarea); + gtk_container_add (GTK_CONTAINER (monitor_display_frame), monitor_display_drawingarea); + + g_signal_connect ((gpointer) monitor_win, "delete_event", + G_CALLBACK (on_monitor_win_delete_event), + NULL); + g_signal_connect ((gpointer) monitor_display_drawingarea, "expose_event", + G_CALLBACK (on_monitor_display_drawingarea_expose_event), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (monitor_win, monitor_win, "monitor_win"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_table, "monitor_table"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_hbox, "monitor_output_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_progress, "monitor_output_progress"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_label2, "monitor_output_label2"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_displaylabel_hbox, "monitor_displaylabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_label, "monitor_display_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_position_hbox, "monitor_position_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_position_label, "monpos_position_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label1, "monpos_label1"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_total_label, "monpos_total_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label2, "monpos_label2"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_left_label, "monpos_left_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_label3, "monpos_label3"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_written_time_label, "monpos_written_time_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_output_time_separator_label, "monpos_output_time_separator_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monpos_output_time_label, "monpos_output_time_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_outputlabel_hbox, "monitor_outputlabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_output_label, "monitor_output_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_positionlabel_hbox, "monitor_positionlabel_hbox"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_position_label, "monitor_position_label"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_frame, "monitor_display_frame"); + GLADE_HOOKUP_OBJECT (monitor_win, monitor_display_drawingarea, "monitor_display_drawingarea"); + + return monitor_win; +} + +GtkWidget* +create_about_win (void) +{ + GtkWidget *about_win; + GtkWidget *about_vbox; + GtkWidget *about_label; + GtkWidget *about_actionarea; + GtkWidget *about_ok; + + about_win = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (about_win), "About XMMS Crossfade Plugin"); + gtk_window_set_type_hint (GTK_WINDOW (about_win), GDK_WINDOW_TYPE_HINT_DIALOG); + + about_vbox = GTK_DIALOG (about_win)->vbox; + gtk_widget_show (about_vbox); + + about_label = gtk_label_new ("dummy"); + gtk_widget_show (about_label); + gtk_box_pack_start (GTK_BOX (about_vbox), about_label, FALSE, FALSE, 0); + gtk_label_set_justify (GTK_LABEL (about_label), GTK_JUSTIFY_CENTER); + + about_actionarea = GTK_DIALOG (about_win)->action_area; + gtk_widget_show (about_actionarea); + gtk_button_box_set_layout (GTK_BUTTON_BOX (about_actionarea), GTK_BUTTONBOX_END); + + about_ok = gtk_button_new_with_mnemonic ("OK"); + gtk_widget_show (about_ok); + gtk_dialog_add_action_widget (GTK_DIALOG (about_win), about_ok, 0); + + g_signal_connect_swapped ((gpointer) about_ok, "clicked", + G_CALLBACK (gtk_widget_destroy), + GTK_OBJECT (about_win)); + g_signal_connect_after ((gpointer) about_ok, "leave", + G_CALLBACK (gtk_widget_hide), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_win, "about_win"); + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_vbox, "about_vbox"); + GLADE_HOOKUP_OBJECT (about_win, about_label, "about_label"); + GLADE_HOOKUP_OBJECT_NO_REF (about_win, about_actionarea, "about_actionarea"); + GLADE_HOOKUP_OBJECT (about_win, about_ok, "about_ok"); + + return about_win; +} + +GtkWidget* +create_help_win (void) +{ + GtkWidget *help_win; + GtkWidget *help_vbox; + GtkWidget *help_scrolledwindow; + GtkWidget *help_text; + GtkWidget *help_buttonbox; + GtkWidget *help_close_button; + + help_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (help_win), "Help"); + + help_vbox = gtk_vbox_new (FALSE, 0); + gtk_widget_show (help_vbox); + gtk_container_add (GTK_CONTAINER (help_win), help_vbox); + gtk_container_set_border_width (GTK_CONTAINER (help_vbox), 5); + + help_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (help_scrolledwindow); + gtk_box_pack_start (GTK_BOX (help_vbox), help_scrolledwindow, TRUE, TRUE, 0); + GTK_WIDGET_UNSET_FLAGS (help_scrolledwindow, GTK_CAN_FOCUS); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (help_scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (help_scrolledwindow), GTK_SHADOW_IN); + + help_text = gtk_text_view_new (); + gtk_widget_show (help_text); + gtk_container_add (GTK_CONTAINER (help_scrolledwindow), help_text); + gtk_text_view_set_editable (GTK_TEXT_VIEW (help_text), FALSE); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (help_text), GTK_WRAP_WORD); + gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (help_text)), "<dummy>\n", -1); + + help_buttonbox = gtk_hbutton_box_new (); + gtk_widget_show (help_buttonbox); + gtk_box_pack_start (GTK_BOX (help_vbox), help_buttonbox, FALSE, FALSE, 0); + gtk_button_box_set_layout (GTK_BUTTON_BOX (help_buttonbox), GTK_BUTTONBOX_END); + gtk_box_set_spacing (GTK_BOX (help_buttonbox), 30); + + help_close_button = gtk_button_new_with_mnemonic ("Close"); + gtk_widget_show (help_close_button); + gtk_container_add (GTK_CONTAINER (help_buttonbox), help_close_button); + GTK_WIDGET_SET_FLAGS (help_close_button, GTK_CAN_DEFAULT); + + g_signal_connect ((gpointer) help_close_button, "clicked", + G_CALLBACK (on_help_close_button_clicked), + NULL); + + /* Store pointers to all widgets, for use by lookup_widget(). */ + GLADE_HOOKUP_OBJECT_NO_REF (help_win, help_win, "help_win"); + GLADE_HOOKUP_OBJECT (help_win, help_vbox, "help_vbox"); + GLADE_HOOKUP_OBJECT (help_win, help_scrolledwindow, "help_scrolledwindow"); + GLADE_HOOKUP_OBJECT (help_win, help_text, "help_text"); + GLADE_HOOKUP_OBJECT (help_win, help_buttonbox, "help_buttonbox"); + GLADE_HOOKUP_OBJECT (help_win, help_close_button, "help_close_button"); + + return help_win; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/interface-2.0.h Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,8 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +GtkWidget* create_config_win (void); +GtkWidget* create_monitor_win (void); +GtkWidget* create_about_win (void); +GtkWidget* create_help_win (void);
--- a/Plugins/Output/crossfade/monitor.c Tue Dec 06 14:02:16 2005 -0800 +++ b/Plugins/Output/crossfade/monitor.c Tue Dec 06 16:09:32 2005 -0800 @@ -234,11 +234,7 @@ /*** Position ***/ if(1 || (monitor_position_label && monitor_total_label && monitor_left_label)) { -#ifndef HAVE_BEEP - if(!get_input_playing() || (monitor_closing == CLOSED)) { /* XMMS */ -#else if(!bmp_playback_get_playing() || (monitor_closing == CLOSED)) { /* XMMS */ -#endif gtk_label_set_text(monitor_position_label, default_position_str); gtk_label_set_text(monitor_total_label, default_total_str); gtk_label_set_text(monitor_left_label, default_left_str);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/support-2.0.c Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,144 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <string.h> +#include <stdio.h> + +#include <gtk/gtk.h> + +#include "support-2.0.h" + +GtkWidget* +lookup_widget (GtkWidget *widget, + const gchar *widget_name) +{ + GtkWidget *parent, *found_widget; + + for (;;) + { + if (GTK_IS_MENU (widget)) + parent = gtk_menu_get_attach_widget (GTK_MENU (widget)); + else + parent = widget->parent; + if (!parent) + parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey"); + if (parent == NULL) + break; + widget = parent; + } + + found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), + widget_name); + if (!found_widget) + g_warning ("Widget not found: %s", widget_name); + return found_widget; +} + +static GList *pixmaps_directories = NULL; + +/* Use this function to set the directory containing installed pixmaps. */ +void +add_pixmap_directory (const gchar *directory) +{ + pixmaps_directories = g_list_prepend (pixmaps_directories, + g_strdup (directory)); +} + +/* This is an internally used function to find pixmap files. */ +static gchar* +find_pixmap_file (const gchar *filename) +{ + GList *elem; + + /* We step through each of the pixmaps directory to find it. */ + elem = pixmaps_directories; + while (elem) + { + gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data, + G_DIR_SEPARATOR_S, filename); + if (g_file_test (pathname, G_FILE_TEST_EXISTS)) + return pathname; + g_free (pathname); + elem = elem->next; + } + return NULL; +} + +/* This is an internally used function to create pixmaps. */ +GtkWidget* +create_pixmap (GtkWidget *widget, + const gchar *filename) +{ + gchar *pathname = NULL; + GtkWidget *pixmap; + + if (!filename || !filename[0]) + return gtk_image_new (); + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return gtk_image_new (); + } + + pixmap = gtk_image_new_from_file (pathname); + g_free (pathname); + return pixmap; +} + +/* This is an internally used function to create pixmaps. */ +GdkPixbuf* +create_pixbuf (const gchar *filename) +{ + gchar *pathname = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + + if (!filename || !filename[0]) + return NULL; + + pathname = find_pixmap_file (filename); + + if (!pathname) + { + g_warning ("Couldn't find pixmap file: %s", filename); + return NULL; + } + + pixbuf = gdk_pixbuf_new_from_file (pathname, &error); + if (!pixbuf) + { + fprintf (stderr, "Failed to load pixbuf file: %s: %s\n", + pathname, error->message); + g_error_free (error); + } + g_free (pathname); + return pixbuf; +} + +/* This is used to set ATK action descriptions. */ +void +glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description) +{ + gint n_actions, i; + + n_actions = atk_action_get_n_actions (action); + for (i = 0; i < n_actions; i++) + { + if (!strcmp (atk_action_get_name (action, i), action_name)) + atk_action_set_description (action, i, description); + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Output/crossfade/support-2.0.h Tue Dec 06 16:09:32 2005 -0800 @@ -0,0 +1,44 @@ +/* + * DO NOT EDIT THIS FILE - it is generated by Glade. + */ + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include <gtk/gtk.h> + +/* + * Public Functions. + */ + +/* + * This function returns a widget in a component created by Glade. + * Call it with the toplevel widget in the component (i.e. a window/dialog), + * or alternatively any widget in the component, and the name of the widget + * you want returned. + */ +GtkWidget* lookup_widget (GtkWidget *widget, + const gchar *widget_name); + + +/* Use this function to set the directory containing installed pixmaps. */ +void add_pixmap_directory (const gchar *directory); + + +/* + * Private Functions. + */ + +/* This is used to create the pixmaps used in the interface. */ +GtkWidget* create_pixmap (GtkWidget *widget, + const gchar *filename); + +/* This is used to create the pixbufs used in the interface. */ +GdkPixbuf* create_pixbuf (const gchar *filename); + +/* This is used to set ATK action descriptions. */ +void glade_set_atk_action_description (AtkAction *action, + const gchar *action_name, + const gchar *description); +