Mercurial > hg > xmms-sid

comparison src/xs_config.c @ 660:b0743dc9165d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change tabs to 4 spaces, everywhere.
author Matti Hamalainen <ccr@tnsp.org>
date Wed, 02 Apr 2008 22:10:05 +0300
parents acaba070cf49
children 94186706beed
comparison
equal deleted inserted replaced
659:04ea91a61225 660:b0743dc9165d
22 */ 22 */
23 #include "xs_config.h" 23 #include "xs_config.h"
24 24
25 #ifdef AUDACIOUS_PLUGIN 25 #ifdef AUDACIOUS_PLUGIN
26 #include <audacious/plugin.h> 26 #include <audacious/plugin.h>
27 #define XS_CONFIG_FILE ConfigDb 27 #define XS_CONFIG_FILE ConfigDb
28 #define XS_CONFIG_OPEN aud_cfg_db_open 28 #define XS_CONFIG_OPEN aud_cfg_db_open
29 #define XS_CONFIG_FREE aud_cfg_db_close 29 #define XS_CONFIG_FREE aud_cfg_db_close
30 30
31 #define XS_CFG_SET_STRING aud_cfg_db_set_string 31 #define XS_CFG_SET_STRING aud_cfg_db_set_string
32 #define XS_CFG_SET_FLOAT aud_cfg_db_set_float 32 #define XS_CFG_SET_FLOAT aud_cfg_db_set_float
33 #define XS_CFG_SET_INT aud_cfg_db_set_int 33 #define XS_CFG_SET_INT aud_cfg_db_set_int
34 #define XS_CFG_SET_BOOL aud_cfg_db_set_bool 34 #define XS_CFG_SET_BOOL aud_cfg_db_set_bool
35 #define XS_CFG_GET_STRING aud_cfg_db_get_string 35 #define XS_CFG_GET_STRING aud_cfg_db_get_string
36 #define XS_CFG_GET_FLOAT aud_cfg_db_get_float 36 #define XS_CFG_GET_FLOAT aud_cfg_db_get_float
37 #define XS_CFG_GET_INT aud_cfg_db_get_int 37 #define XS_CFG_GET_INT aud_cfg_db_get_int
38 #define XS_CFG_GET_BOOL aud_cfg_db_get_bool 38 #define XS_CFG_GET_BOOL aud_cfg_db_get_bool
39 #else 39 #else
40 #include <xmms/configfile.h> 40 #include <xmms/configfile.h>
41 #define XS_CONFIG_FILE ConfigFile 41 #define XS_CONFIG_FILE ConfigFile
42 #define XS_CONFIG_OPEN xmms_cfg_open_default_file 42 #define XS_CONFIG_OPEN xmms_cfg_open_default_file
43 #define XS_CONFIG_FREE xmms_cfg_free 43 #define XS_CONFIG_FREE xmms_cfg_free
44 44
45 #define XS_CFG_SET_STRING xmms_cfg_write_string 45 #define XS_CFG_SET_STRING xmms_cfg_write_string
46 #define XS_CFG_SET_FLOAT xmms_cfg_write_float 46 #define XS_CFG_SET_FLOAT xmms_cfg_write_float
47 #define XS_CFG_SET_INT xmms_cfg_write_int 47 #define XS_CFG_SET_INT xmms_cfg_write_int
48 #define XS_CFG_SET_BOOL xmms_cfg_write_boolean 48 #define XS_CFG_SET_BOOL xmms_cfg_write_boolean
49 #define XS_CFG_GET_STRING xmms_cfg_read_string 49 #define XS_CFG_GET_STRING xmms_cfg_read_string
50 #define XS_CFG_GET_FLOAT xmms_cfg_read_float 50 #define XS_CFG_GET_FLOAT xmms_cfg_read_float
51 #define XS_CFG_GET_INT xmms_cfg_read_int 51 #define XS_CFG_GET_INT xmms_cfg_read_int
52 #define XS_CFG_GET_BOOL xmms_cfg_read_boolean 52 #define XS_CFG_GET_BOOL xmms_cfg_read_boolean
53 #endif 53 #endif
54 #include <stdio.h> 54 #include <stdio.h>
55 #include <ctype.h> 55 #include <ctype.h>
56 #include "xs_glade.h" 56 #include "xs_glade.h"
57 #include "xs_interface.h" 57 #include "xs_interface.h"
60 60
61 /* 61 /*
62 * Global widgets 62 * Global widgets
63 */ 63 */
64 static GtkWidget *xs_configwin = NULL, 64 static GtkWidget *xs_configwin = NULL,
65 *xs_sldb_fileselector = NULL, 65 *xs_sldb_fileselector = NULL,
66 *xs_stil_fileselector = NULL, 66 *xs_stil_fileselector = NULL,
67 *xs_hvsc_selector = NULL, 67 *xs_hvsc_selector = NULL,
68 *xs_filt_importselector = NULL, 68 *xs_filt_importselector = NULL,
69 *xs_filt_exportselector = NULL; 69 *xs_filt_exportselector = NULL;
70 70
71 #define LUW(x) lookup_widget(xs_configwin, x) 71 #define LUW(x) lookup_widget(xs_configwin, x)
72 72
73 /* Samplerates 73 /* Samplerates
74 */ 74 */
75 static const gchar *xs_samplerates_table[] = { 75 static const gchar *xs_samplerates_table[] = {
76 "8000", "11025", "22050", 76 "8000", "11025", "22050",
77 "44100", "48000", "64000", 77 "44100", "48000", "64000",
78 "96000" 78 "96000"
79 }; 79 };
80 80
81 static const gint xs_nsamplerates_table = (sizeof(xs_samplerates_table) / sizeof(xs_samplerates_table[0])); 81 static const gint xs_nsamplerates_table = (sizeof(xs_samplerates_table) / sizeof(xs_samplerates_table[0]));
82 82
83 /* 83 /*
85 */ 85 */
86 XS_MUTEX(xs_cfg); 86 XS_MUTEX(xs_cfg);
87 struct t_xs_cfg xs_cfg; 87 struct t_xs_cfg xs_cfg;
88 88
89 static t_xs_cfg_item xs_cfgtable[] = { 89 static t_xs_cfg_item xs_cfgtable[] = {
90 { CTYPE_INT, &xs_cfg.audioBitsPerSample, "audioBitsPerSample" }, 90 { CTYPE_INT, &xs_cfg.audioBitsPerSample, "audioBitsPerSample" },
91 { CTYPE_INT, &xs_cfg.audioChannels, "audioChannels" }, 91 { CTYPE_INT, &xs_cfg.audioChannels, "audioChannels" },
92 { CTYPE_INT, &xs_cfg.audioFrequency, "audioFrequency" }, 92 { CTYPE_INT, &xs_cfg.audioFrequency, "audioFrequency" },
93 93
94 { CTYPE_BOOL, &xs_cfg.mos8580, "mos8580" }, 94 { CTYPE_BOOL, &xs_cfg.mos8580, "mos8580" },
95 { CTYPE_BOOL, &xs_cfg.forceModel, "forceModel" }, 95 { CTYPE_BOOL, &xs_cfg.forceModel, "forceModel" },
96 { CTYPE_BOOL, &xs_cfg.emulateFilters, "emulateFilters" }, 96 { CTYPE_BOOL, &xs_cfg.emulateFilters, "emulateFilters" },
97 { CTYPE_FLOAT, &xs_cfg.sid1FilterFs, "filterFs" }, 97 { CTYPE_FLOAT, &xs_cfg.sid1FilterFs, "filterFs" },
98 { CTYPE_FLOAT, &xs_cfg.sid1FilterFm, "filterFm" }, 98 { CTYPE_FLOAT, &xs_cfg.sid1FilterFm, "filterFm" },
99 { CTYPE_FLOAT, &xs_cfg.sid1FilterFt, "filterFt" }, 99 { CTYPE_FLOAT, &xs_cfg.sid1FilterFt, "filterFt" },
100 { CTYPE_INT, &xs_cfg.memoryMode, "memoryMode" }, 100 { CTYPE_INT, &xs_cfg.memoryMode, "memoryMode" },
101 { CTYPE_INT, &xs_cfg.clockSpeed, "clockSpeed" }, 101 { CTYPE_INT, &xs_cfg.clockSpeed, "clockSpeed" },
102 { CTYPE_BOOL, &xs_cfg.forceSpeed, "forceSpeed" }, 102 { CTYPE_BOOL, &xs_cfg.forceSpeed, "forceSpeed" },
103 103
104 { CTYPE_INT, &xs_cfg.playerEngine, "playerEngine" }, 104 { CTYPE_INT, &xs_cfg.playerEngine, "playerEngine" },
105 105
106 { CTYPE_INT, &xs_cfg.sid2Builder, "sid2Builder" }, 106 { CTYPE_INT, &xs_cfg.sid2Builder, "sid2Builder" },
107 { CTYPE_INT, &xs_cfg.sid2OptLevel, "sid2OptLevel" }, 107 { CTYPE_INT, &xs_cfg.sid2OptLevel, "sid2OptLevel" },
108 { CTYPE_INT, &xs_cfg.sid2NFilterPresets, "sid2NFilterPresets" }, 108 { CTYPE_INT, &xs_cfg.sid2NFilterPresets, "sid2NFilterPresets" },
109 109
110 { CTYPE_BOOL, &xs_cfg.oversampleEnable, "oversampleEnable" }, 110 { CTYPE_BOOL, &xs_cfg.oversampleEnable, "oversampleEnable" },
111 { CTYPE_INT, &xs_cfg.oversampleFactor, "oversampleFactor" }, 111 { CTYPE_INT, &xs_cfg.oversampleFactor, "oversampleFactor" },
112 112
113 { CTYPE_BOOL, &xs_cfg.playMaxTimeEnable, "playMaxTimeEnable" }, 113 { CTYPE_BOOL, &xs_cfg.playMaxTimeEnable, "playMaxTimeEnable" },
114 { CTYPE_BOOL, &xs_cfg.playMaxTimeUnknown, "playMaxTimeUnknown" }, 114 { CTYPE_BOOL, &xs_cfg.playMaxTimeUnknown, "playMaxTimeUnknown" },
115 { CTYPE_INT, &xs_cfg.playMaxTime, "playMaxTime" }, 115 { CTYPE_INT, &xs_cfg.playMaxTime, "playMaxTime" },
116 { CTYPE_BOOL, &xs_cfg.playMinTimeEnable, "playMinTimeEnable" }, 116 { CTYPE_BOOL, &xs_cfg.playMinTimeEnable, "playMinTimeEnable" },
117 { CTYPE_INT, &xs_cfg.playMinTime, "playMinTime" }, 117 { CTYPE_INT, &xs_cfg.playMinTime, "playMinTime" },
118 { CTYPE_BOOL, &xs_cfg.songlenDBEnable, "songlenDBEnable" }, 118 { CTYPE_BOOL, &xs_cfg.songlenDBEnable, "songlenDBEnable" },
119 { CTYPE_STR, &xs_cfg.songlenDBPath, "songlenDBPath" }, 119 { CTYPE_STR, &xs_cfg.songlenDBPath, "songlenDBPath" },
120 120
121 { CTYPE_BOOL, &xs_cfg.stilDBEnable, "stilDBEnable" }, 121 { CTYPE_BOOL, &xs_cfg.stilDBEnable, "stilDBEnable" },
122 { CTYPE_STR, &xs_cfg.stilDBPath, "stilDBPath" }, 122 { CTYPE_STR, &xs_cfg.stilDBPath, "stilDBPath" },
123 { CTYPE_STR, &xs_cfg.hvscPath, "hvscPath" }, 123 { CTYPE_STR, &xs_cfg.hvscPath, "hvscPath" },
124 124
125 #ifndef AUDACIOUS_PLUGIN 125 #ifndef AUDACIOUS_PLUGIN
126 { CTYPE_INT, &xs_cfg.subsongControl, "subsongControl" }, 126 { CTYPE_INT, &xs_cfg.subsongControl, "subsongControl" },
127 { CTYPE_BOOL, &xs_cfg.detectMagic, "detectMagic" }, 127 { CTYPE_BOOL, &xs_cfg.detectMagic, "detectMagic" },
128 #endif 128 #endif
129 129
130 { CTYPE_BOOL, &xs_cfg.titleOverride, "titleOverride" }, 130 { CTYPE_BOOL, &xs_cfg.titleOverride, "titleOverride" },
131 { CTYPE_STR, &xs_cfg.titleFormat, "titleFormat" }, 131 { CTYPE_STR, &xs_cfg.titleFormat, "titleFormat" },
132 132
133 { CTYPE_BOOL, &xs_cfg.subAutoEnable, "subAutoEnable" }, 133 { CTYPE_BOOL, &xs_cfg.subAutoEnable, "subAutoEnable" },
134 { CTYPE_BOOL, &xs_cfg.subAutoMinOnly, "subAutoMinOnly" }, 134 { CTYPE_BOOL, &xs_cfg.subAutoMinOnly, "subAutoMinOnly" },
135 { CTYPE_INT, &xs_cfg.subAutoMinTime, "subAutoMinTime" }, 135 { CTYPE_INT, &xs_cfg.subAutoMinTime, "subAutoMinTime" },
136 }; 136 };
137 137
138 static const gint xs_cfgtable_max = (sizeof(xs_cfgtable) / sizeof(t_xs_cfg_item)); 138 static const gint xs_cfgtable_max = (sizeof(xs_cfgtable) / sizeof(t_xs_cfg_item));
139 139
140 140
141 static t_xs_wid_item xs_widtable[] = { 141 static t_xs_wid_item xs_widtable[] = {
142 { WTYPE_BGROUP, CTYPE_INT, "cfg_res_16bit", &xs_cfg.audioBitsPerSample, XS_RES_16BIT }, 142 { WTYPE_BGROUP, CTYPE_INT, "cfg_res_16bit", &xs_cfg.audioBitsPerSample, XS_RES_16BIT },
143 { WTYPE_BGROUP, CTYPE_INT, "cfg_res_8bit", &xs_cfg.audioBitsPerSample, XS_RES_8BIT }, 143 { WTYPE_BGROUP, CTYPE_INT, "cfg_res_8bit", &xs_cfg.audioBitsPerSample, XS_RES_8BIT },
144 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_mono", &xs_cfg.audioChannels, XS_CHN_MONO }, 144 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_mono", &xs_cfg.audioChannels, XS_CHN_MONO },
145 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_stereo", &xs_cfg.audioChannels, XS_CHN_STEREO }, 145 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_stereo", &xs_cfg.audioChannels, XS_CHN_STEREO },
146 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_autopan", &xs_cfg.audioChannels, XS_CHN_AUTOPAN }, 146 { WTYPE_BGROUP, CTYPE_INT, "cfg_chn_autopan", &xs_cfg.audioChannels, XS_CHN_AUTOPAN },
147 { WTYPE_COMBO, CTYPE_INT, "cfg_samplerate", &xs_cfg.audioFrequency, XS_AUDIO_FREQ }, 147 { WTYPE_COMBO, CTYPE_INT, "cfg_samplerate", &xs_cfg.audioFrequency, XS_AUDIO_FREQ },
148 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_oversample", &xs_cfg.oversampleEnable, 0 }, 148 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_oversample", &xs_cfg.oversampleEnable, 0 },
149 { WTYPE_SPIN, CTYPE_INT, "cfg_oversample_factor",&xs_cfg.oversampleFactor, 0 }, 149 { WTYPE_SPIN, CTYPE_INT, "cfg_oversample_factor",&xs_cfg.oversampleFactor, 0 },
150 150
151 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay1", &xs_cfg.playerEngine, XS_ENG_SIDPLAY1 }, 151 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay1", &xs_cfg.playerEngine, XS_ENG_SIDPLAY1 },
152 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay2", &xs_cfg.playerEngine, XS_ENG_SIDPLAY2 }, 152 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sidplay2", &xs_cfg.playerEngine, XS_ENG_SIDPLAY2 },
153 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_real", &xs_cfg.memoryMode, XS_MPU_REAL }, 153 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_real", &xs_cfg.memoryMode, XS_MPU_REAL },
154 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_banksw", &xs_cfg.memoryMode, XS_MPU_BANK_SWITCHING }, 154 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_banksw", &xs_cfg.memoryMode, XS_MPU_BANK_SWITCHING },
155 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_transrom", &xs_cfg.memoryMode, XS_MPU_TRANSPARENT_ROM }, 155 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_transrom", &xs_cfg.memoryMode, XS_MPU_TRANSPARENT_ROM },
156 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_playsid", &xs_cfg.memoryMode, XS_MPU_PLAYSID_ENVIRONMENT }, 156 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_mem_playsid", &xs_cfg.memoryMode, XS_MPU_PLAYSID_ENVIRONMENT },
157 157
158 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_mos8580", &xs_cfg.mos8580, 0 }, 158 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_mos8580", &xs_cfg.mos8580, 0 },
159 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_sid_force", &xs_cfg.forceModel, 0 }, 159 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_sid_force", &xs_cfg.forceModel, 0 },
160 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_ntsc", &xs_cfg.clockSpeed, XS_CLOCK_NTSC }, 160 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_ntsc", &xs_cfg.clockSpeed, XS_CLOCK_NTSC },
161 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_pal", &xs_cfg.clockSpeed, XS_CLOCK_PAL }, 161 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_clock_pal", &xs_cfg.clockSpeed, XS_CLOCK_PAL },
162 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_clock_force", &xs_cfg.forceSpeed, 0 }, 162 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_clock_force", &xs_cfg.forceSpeed, 0 },
163 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_sp2_opt", &xs_cfg.sid2OptLevel, 0 }, 163 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_sp2_opt", &xs_cfg.sid2OptLevel, 0 },
164 164
165 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sp2_resid", &xs_cfg.sid2Builder, XS_BLD_RESID }, 165 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sp2_resid", &xs_cfg.sid2Builder, XS_BLD_RESID },
166 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sp2_hardsid", &xs_cfg.sid2Builder, XS_BLD_HARDSID }, 166 { WTYPE_BGROUP, CTYPE_INT, "cfg_emu_sp2_hardsid", &xs_cfg.sid2Builder, XS_BLD_HARDSID },
167 167
168 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_filters", &xs_cfg.emulateFilters, 0 }, 168 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_emu_filters", &xs_cfg.emulateFilters, 0 },
169 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_fs", &xs_cfg.sid1FilterFs, 0 }, 169 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_fs", &xs_cfg.sid1FilterFs, 0 },
170 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_fm", &xs_cfg.sid1FilterFm, 0 }, 170 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_fm", &xs_cfg.sid1FilterFm, 0 },
171 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_ft", &xs_cfg.sid1FilterFt, 0 }, 171 { WTYPE_SCALE, CTYPE_FLOAT, "cfg_sp1_filter_ft", &xs_cfg.sid1FilterFt, 0 },
172 172
173 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_enable", &xs_cfg.playMaxTimeEnable, 0 }, 173 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_enable", &xs_cfg.playMaxTimeEnable, 0 },
174 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_unknown", &xs_cfg.playMaxTimeUnknown, 0 }, 174 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_maxtime_unknown", &xs_cfg.playMaxTimeUnknown, 0 },
175 { WTYPE_SPIN, CTYPE_INT, "cfg_maxtime", &xs_cfg.playMaxTime, 0 }, 175 { WTYPE_SPIN, CTYPE_INT, "cfg_maxtime", &xs_cfg.playMaxTime, 0 },
176 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_mintime_enable", &xs_cfg.playMinTimeEnable, 0 }, 176 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_mintime_enable", &xs_cfg.playMinTimeEnable, 0 },
177 { WTYPE_SPIN, CTYPE_INT, "cfg_mintime", &xs_cfg.playMinTime, 0 }, 177 { WTYPE_SPIN, CTYPE_INT, "cfg_mintime", &xs_cfg.playMinTime, 0 },
178 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_sld_enable", &xs_cfg.songlenDBEnable, 0 }, 178 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_sld_enable", &xs_cfg.songlenDBEnable, 0 },
179 { WTYPE_TEXT, CTYPE_STR, "cfg_sld_dbpath", &xs_cfg.songlenDBPath, 0 }, 179 { WTYPE_TEXT, CTYPE_STR, "cfg_sld_dbpath", &xs_cfg.songlenDBPath, 0 },
180 180
181 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_stil_enable", &xs_cfg.stilDBEnable, 0 }, 181 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_stil_enable", &xs_cfg.stilDBEnable, 0 },
182 { WTYPE_TEXT, CTYPE_STR, "cfg_stil_dbpath", &xs_cfg.stilDBPath, 0 }, 182 { WTYPE_TEXT, CTYPE_STR, "cfg_stil_dbpath", &xs_cfg.stilDBPath, 0 },
183 { WTYPE_TEXT, CTYPE_STR, "cfg_hvsc_path", &xs_cfg.hvscPath, 0 }, 183 { WTYPE_TEXT, CTYPE_STR, "cfg_hvsc_path", &xs_cfg.hvscPath, 0 },
184 184
185 #ifndef AUDACIOUS_PLUGIN 185 #ifndef AUDACIOUS_PLUGIN
186 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_none", &xs_cfg.subsongControl, XS_SSC_NONE }, 186 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_none", &xs_cfg.subsongControl, XS_SSC_NONE },
187 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_seek", &xs_cfg.subsongControl, XS_SSC_SEEK }, 187 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_seek", &xs_cfg.subsongControl, XS_SSC_SEEK },
188 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_popup", &xs_cfg.subsongControl, XS_SSC_POPUP }, 188 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_popup", &xs_cfg.subsongControl, XS_SSC_POPUP },
189 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_patch", &xs_cfg.subsongControl, XS_SSC_PATCH }, 189 { WTYPE_BGROUP, CTYPE_INT, "cfg_subctrl_patch", &xs_cfg.subsongControl, XS_SSC_PATCH },
190 190
191 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_detectmagic", &xs_cfg.detectMagic, 0 }, 191 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_detectmagic", &xs_cfg.detectMagic, 0 },
192 #endif 192 #endif
193 193
194 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_ftitle_override", &xs_cfg.titleOverride, 0 }, 194 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_ftitle_override", &xs_cfg.titleOverride, 0 },
195 { WTYPE_TEXT, CTYPE_STR, "cfg_ftitle_format", &xs_cfg.titleFormat, 0 }, 195 { WTYPE_TEXT, CTYPE_STR, "cfg_ftitle_format", &xs_cfg.titleFormat, 0 },
196 196
197 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_enable", &xs_cfg.subAutoEnable, 0 }, 197 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_enable", &xs_cfg.subAutoEnable, 0 },
198 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_min_only", &xs_cfg.subAutoMinOnly, 0 }, 198 { WTYPE_BUTTON, CTYPE_BOOL, "cfg_subauto_min_only", &xs_cfg.subAutoMinOnly, 0 },
199 { WTYPE_SPIN, CTYPE_INT, "cfg_subauto_mintime", &xs_cfg.subAutoMinTime, 0 }, 199 { WTYPE_SPIN, CTYPE_INT, "cfg_subauto_mintime", &xs_cfg.subAutoMinTime, 0 },
200 }; 200 };
201 201
202 static const gint xs_widtable_max = (sizeof(xs_widtable) / sizeof(t_xs_wid_item)); 202 static const gint xs_widtable_max = (sizeof(xs_widtable) / sizeof(t_xs_wid_item));
203 203
204 204
205 /* Reset/initialize the configuration 205 /* Reset/initialize the configuration
206 */ 206 */
207 void xs_init_configuration(void) 207 void xs_init_configuration(void)
208 { 208 {
209 /* Lock configuration mutex */ 209 /* Lock configuration mutex */
210 XSDEBUG("initializing configuration ...\n"); 210 XSDEBUG("initializing configuration ...\n");
211 XS_MUTEX_LOCK(xs_cfg); 211 XS_MUTEX_LOCK(xs_cfg);
212 212
213 memset(&xs_cfg, 0, sizeof(xs_cfg)); 213 memset(&xs_cfg, 0, sizeof(xs_cfg));
214 214
215 /* Initialize values with sensible defaults */ 215 /* Initialize values with sensible defaults */
216 xs_cfg.audioBitsPerSample = XS_RES_16BIT; 216 xs_cfg.audioBitsPerSample = XS_RES_16BIT;
217 xs_cfg.audioChannels = XS_CHN_MONO; 217 xs_cfg.audioChannels = XS_CHN_MONO;
218 xs_cfg.audioFrequency = XS_AUDIO_FREQ; 218 xs_cfg.audioFrequency = XS_AUDIO_FREQ;
219 219
220 xs_cfg.mos8580 = FALSE; 220 xs_cfg.mos8580 = FALSE;
221 xs_cfg.forceModel = FALSE; 221 xs_cfg.forceModel = FALSE;
222 222
223 /* Filter values */ 223 /* Filter values */
224 xs_cfg.emulateFilters = TRUE; 224 xs_cfg.emulateFilters = TRUE;
225 xs_cfg.sid1FilterFs = XS_SIDPLAY1_FS; 225 xs_cfg.sid1FilterFs = XS_SIDPLAY1_FS;
226 xs_cfg.sid1FilterFm = XS_SIDPLAY1_FM; 226 xs_cfg.sid1FilterFm = XS_SIDPLAY1_FM;
227 xs_cfg.sid1FilterFt = XS_SIDPLAY1_FT; 227 xs_cfg.sid1FilterFt = XS_SIDPLAY1_FT;
228 228
229 #ifdef HAVE_SIDPLAY2 229 #ifdef HAVE_SIDPLAY2
230 xs_cfg.playerEngine = XS_ENG_SIDPLAY2; 230 xs_cfg.playerEngine = XS_ENG_SIDPLAY2;
231 xs_cfg.memoryMode = XS_MPU_REAL; 231 xs_cfg.memoryMode = XS_MPU_REAL;
232 #else 232 #else
233 #ifdef HAVE_SIDPLAY1 233 #ifdef HAVE_SIDPLAY1
234 xs_cfg.playerEngine = XS_ENG_SIDPLAY1; 234 xs_cfg.playerEngine = XS_ENG_SIDPLAY1;
235 xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING; 235 xs_cfg.memoryMode = XS_MPU_BANK_SWITCHING;
236 #else 236 #else
237 #error This should not happen! No emulator engines configured in! 237 #error This should not happen! No emulator engines configured in!
238 #endif 238 #endif
239 #endif 239 #endif
240 240
241 xs_cfg.clockSpeed = XS_CLOCK_PAL; 241 xs_cfg.clockSpeed = XS_CLOCK_PAL;
242 xs_cfg.forceSpeed = FALSE; 242 xs_cfg.forceSpeed = FALSE;
243 243
244 xs_cfg.sid2OptLevel = 0; 244 xs_cfg.sid2OptLevel = 0;
245 xs_cfg.sid2NFilterPresets = 0; 245 xs_cfg.sid2NFilterPresets = 0;
246 246
247 #ifdef HAVE_RESID_BUILDER 247 #ifdef HAVE_RESID_BUILDER
248 xs_cfg.sid2Builder = XS_BLD_RESID; 248 xs_cfg.sid2Builder = XS_BLD_RESID;
249 #else 249 #else
250 #ifdef HAVE_HARDSID_BUILDER 250 #ifdef HAVE_HARDSID_BUILDER
251 xs_cfg.sid2Builder = XS_BLD_HARDSID; 251 xs_cfg.sid2Builder = XS_BLD_HARDSID;
252 #else 252 #else
253 #ifdef HAVE_SIDPLAY2 253 #ifdef HAVE_SIDPLAY2
254 #error This should not happen! No supported SIDPlay2 builders configured in! 254 #error This should not happen! No supported SIDPlay2 builders configured in!
255 #endif 255 #endif
256 #endif 256 #endif
257 #endif 257 #endif
258 258
259 xs_cfg.oversampleEnable = FALSE; 259 xs_cfg.oversampleEnable = FALSE;
260 xs_cfg.oversampleFactor = XS_MIN_OVERSAMPLE; 260 xs_cfg.oversampleFactor = XS_MIN_OVERSAMPLE;
261 261
262 xs_cfg.playMaxTimeEnable = FALSE; 262 xs_cfg.playMaxTimeEnable = FALSE;
263 xs_cfg.playMaxTimeUnknown = FALSE; 263 xs_cfg.playMaxTimeUnknown = FALSE;
264 xs_cfg.playMaxTime = 150; 264 xs_cfg.playMaxTime = 150;
265 265
266 xs_cfg.playMinTimeEnable = FALSE; 266 xs_cfg.playMinTimeEnable = FALSE;
267 xs_cfg.playMinTime = 15; 267 xs_cfg.playMinTime = 15;
268 268
269 xs_cfg.songlenDBEnable = FALSE; 269 xs_cfg.songlenDBEnable = FALSE;
270 xs_pstrcpy(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt"); 270 xs_pstrcpy(&xs_cfg.songlenDBPath, "~/C64Music/Songlengths.txt");
271 271
272 xs_cfg.stilDBEnable = FALSE; 272 xs_cfg.stilDBEnable = FALSE;
273 xs_pstrcpy(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt"); 273 xs_pstrcpy(&xs_cfg.stilDBPath, "~/C64Music/DOCUMENTS/STIL.txt");
274 xs_pstrcpy(&xs_cfg.hvscPath, "~/C64Music"); 274 xs_pstrcpy(&xs_cfg.hvscPath, "~/C64Music");
275 275
276 #if defined(HAVE_SONG_POSITION) && !defined(AUDACIOUS_PLUGIN) 276 #if defined(HAVE_SONG_POSITION) && !defined(AUDACIOUS_PLUGIN)
277 xs_cfg.subsongControl = XS_SSC_PATCH; 277 xs_cfg.subsongControl = XS_SSC_PATCH;
278 #else 278 #else
279 xs_cfg.subsongControl = XS_SSC_POPUP; 279 xs_cfg.subsongControl = XS_SSC_POPUP;
280 #endif 280 #endif
281 xs_cfg.detectMagic = FALSE; 281 xs_cfg.detectMagic = FALSE;
282 282
283 #ifndef HAVE_XMMSEXTRA 283 #ifndef HAVE_XMMSEXTRA
284 xs_cfg.titleOverride = TRUE; 284 xs_cfg.titleOverride = TRUE;
285 #endif 285 #endif
286 286
287 #ifdef AUDACIOUS_PLUGIN 287 #ifdef AUDACIOUS_PLUGIN
288 xs_pstrcpy(&xs_cfg.titleFormat, "${artist} - ${title} (${copyright}) <${subsong-id}/${subsong-num}> [${sid-model}/${sid-speed}]"); 288 xs_pstrcpy(&xs_cfg.titleFormat, "${artist} - ${title} (${copyright}) <${subsong-id}/${subsong-num}> [${sid-model}/${sid-speed}]");
289 #else 289 #else
290 xs_pstrcpy(&xs_cfg.titleFormat, "%p - %t (%c) <%n/%N> [%m/%C]"); 290 xs_pstrcpy(&xs_cfg.titleFormat, "%p - %t (%c) <%n/%N> [%m/%C]");
291 #endif 291 #endif
292 292
293 xs_cfg.subAutoEnable = FALSE; 293 xs_cfg.subAutoEnable = FALSE;
294 xs_cfg.subAutoMinOnly = TRUE; 294 xs_cfg.subAutoMinOnly = TRUE;
295 xs_cfg.subAutoMinTime = 15; 295 xs_cfg.subAutoMinTime = 15;
296 296
297 297
298 /* Unlock the configuration */ 298 /* Unlock the configuration */
299 XS_MUTEX_UNLOCK(xs_cfg); 299 XS_MUTEX_UNLOCK(xs_cfg);
300 } 300 }
301 301
302 302
303 /* Filter configuration handling 303 /* Filter configuration handling
304 */ 304 */
305 #define XS_FITEM (4 * 2) 305 #define XS_FITEM (4 * 2)
306 306
307 static gboolean xs_filter_load_into(XS_CONFIG_FILE *cfg, gint nFilter, t_xs_sid2_filter *pResult) 307 static gboolean xs_filter_load_into(XS_CONFIG_FILE *cfg, gint nFilter, t_xs_sid2_filter *pResult)
308 { 308 {
309 gchar tmpKey[64], *tmpStr; 309 gchar tmpKey[64], *tmpStr;
310 gint i, j; 310 gint i, j;
311 311
312 /* Get fields from config */ 312 /* Get fields from config */
313 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dNPoints", nFilter); 313 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dNPoints", nFilter);
314 if (!XS_CFG_GET_INT(cfg, XS_CONFIG_IDENT, tmpKey, &(pResult->npoints))) 314 if (!XS_CFG_GET_INT(cfg, XS_CONFIG_IDENT, tmpKey, &(pResult->npoints)))
315 return FALSE; 315 return FALSE;
316 316
317 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dName", nFilter); 317 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dName", nFilter);
318 if (!XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, &tmpStr)) 318 if (!XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, &tmpStr))
319 return FALSE; 319 return FALSE;
320 320
321 pResult->name = g_strdup(tmpStr); 321 pResult->name = g_strdup(tmpStr);
322 if (pResult->name == NULL) { 322 if (pResult->name == NULL) {
323 g_free(pResult); 323 g_free(pResult);
324 return FALSE; 324 return FALSE;
325 } 325 }
326 326
327 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dPoints", nFilter); 327 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dPoints", nFilter);
328 if (!XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, &tmpStr)) 328 if (!XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, &tmpStr))
329 return FALSE; 329 return FALSE;
330 330
331 for (i = 0, j = 0; i < pResult->npoints; i++, j += XS_FITEM) { 331 for (i = 0, j = 0; i < pResult->npoints; i++, j += XS_FITEM) {
332 if (sscanf(&tmpStr[j], "%4x%4x", 332 if (sscanf(&tmpStr[j], "%4x%4x",
333 &(pResult->points[i].x), 333 &(pResult->points[i].x),
334 &(pResult->points[i].y)) != 2) 334 &(pResult->points[i].y)) != 2)
335 return FALSE; 335 return FALSE;
336 } 336 }
337 337
338 return TRUE; 338 return TRUE;
339 } 339 }
340 340
341 341
342 static t_xs_sid2_filter * xs_filter_load(XS_CONFIG_FILE *cfg, gint nFilter) 342 static t_xs_sid2_filter * xs_filter_load(XS_CONFIG_FILE *cfg, gint nFilter)
343 { 343 {
344 t_xs_sid2_filter *pResult; 344 t_xs_sid2_filter *pResult;
345 345
346 /* Allocate filter struct */ 346 /* Allocate filter struct */
347 if ((pResult = g_malloc0(sizeof(t_xs_sid2_filter))) == NULL) 347 if ((pResult = g_malloc0(sizeof(t_xs_sid2_filter))) == NULL)
348 return NULL; 348 return NULL;
349 349
350 if (!xs_filter_load_into(cfg, nFilter, pResult)) { 350 if (!xs_filter_load_into(cfg, nFilter, pResult)) {
351 g_free(pResult); 351 g_free(pResult);
352 return NULL; 352 return NULL;
353 } else 353 } else
354 return pResult; 354 return pResult;
355 } 355 }
356 356
357 #if 0 357 #if 0
358 static gboolean xs_filter_save(XS_CONFIG_FILE *cfg, t_xs_sid2_filter *pFilter, gint nFilter) 358 static gboolean xs_filter_save(XS_CONFIG_FILE *cfg, t_xs_sid2_filter *pFilter, gint nFilter)
359 { 359 {
360 gchar *tmpValue, tmpKey[64]; 360 gchar *tmpValue, tmpKey[64];
361 gint i, j; 361 gint i, j;
362 362
363 /* Allocate memory for value string */ 363 /* Allocate memory for value string */
364 tmpValue = g_malloc(sizeof(gchar) * XS_FITEM * (pFilter->npoints + 1)); 364 tmpValue = g_malloc(sizeof(gchar) * XS_FITEM * (pFilter->npoints + 1));
365 if (tmpValue == NULL) 365 if (tmpValue == NULL)
366 return FALSE; 366 return FALSE;
367 367
368 /* Make value string */ 368 /* Make value string */
369 for (i = 0, j = 0; i < pFilter->npoints; i++, j += XS_FITEM) { 369 for (i = 0, j = 0; i < pFilter->npoints; i++, j += XS_FITEM) {
370 g_snprintf(&tmpValue[j], XS_FITEM+1, "%04x%04x", 370 g_snprintf(&tmpValue[j], XS_FITEM+1, "%04x%04x",
371 pFilter->points[i].x, 371 pFilter->points[i].x,
372 pFilter->points[i].y); 372 pFilter->points[i].y);
373 } 373 }
374 374
375 /* Write into the configuration */ 375 /* Write into the configuration */
376 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dName", nFilter); 376 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dName", nFilter);
377 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, pFilter->name); 377 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, pFilter->name);
378 378
379 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dNPoints", nFilter); 379 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dNPoints", nFilter);
380 XS_CFG_SET_INT(cfg, XS_CONFIG_IDENT, tmpKey, pFilter->npoints); 380 XS_CFG_SET_INT(cfg, XS_CONFIG_IDENT, tmpKey, pFilter->npoints);
381 381
382 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dPoints", nFilter); 382 g_snprintf(tmpKey, sizeof(tmpKey), "filter%dPoints", nFilter);
383 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, tmpValue); 383 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT, tmpKey, tmpValue);
384 384
385 g_free(tmpValue); 385 g_free(tmpValue);
386 return TRUE; 386 return TRUE;
387 } 387 }
388 #endif 388 #endif
389 389
390 /* Filter exporting and importing. These functions export/import 390 /* Filter exporting and importing. These functions export/import
391 * filter settings to/from SIDPlay2 INI-type files. 391 * filter settings to/from SIDPlay2 INI-type files.
392 */ 392 */
393 static gboolean xs_fgetitem(gchar *inLine, size_t *linePos, gchar sep, gchar *tmpStr, size_t tmpMax) 393 static gboolean xs_fgetitem(gchar *inLine, size_t *linePos, gchar sep, gchar *tmpStr, size_t tmpMax)
394 { 394 {
395 size_t i; 395 size_t i;
396 for (i = 0; i < tmpMax && inLine[*linePos] && 396 for (i = 0; i < tmpMax && inLine[*linePos] &&
397 !isspace(inLine[*linePos]) && 397 !isspace(inLine[*linePos]) &&
398 inLine[*linePos] != sep; i++, (*linePos)++) 398 inLine[*linePos] != sep; i++, (*linePos)++)
399 tmpStr[i] = inLine[*linePos]; 399 tmpStr[i] = inLine[*linePos];
400 tmpStr[i] = 0; 400 tmpStr[i] = 0;
401 xs_findnext(inLine, linePos); 401 xs_findnext(inLine, linePos);
402 return (inLine[*linePos] == sep); 402 return (inLine[*linePos] == sep);
403 } 403 }
404 404
405 static gboolean xs_filters_import(const gchar *pcFilename, t_xs_sid2_filter **pFilters, gint *nFilters) 405 static gboolean xs_filters_import(const gchar *pcFilename, t_xs_sid2_filter **pFilters, gint *nFilters)
406 { 406 {
407 FILE *inFile; 407 FILE *inFile;
408 gchar inLine[XS_BUF_SIZE], tmpStr[XS_BUF_SIZE]; 408 gchar inLine[XS_BUF_SIZE], tmpStr[XS_BUF_SIZE];
409 gchar *sectName = NULL; 409 gchar *sectName = NULL;
410 gboolean sectBegin; 410 gboolean sectBegin;
411 size_t lineNum, i; 411 size_t lineNum, i;
412 t_xs_sid2_filter *tmpFilter; 412 t_xs_sid2_filter *tmpFilter;
413 413
414 fprintf(stderr, "xs_filters_import(%s)\n", pcFilename); 414 fprintf(stderr, "xs_filters_import(%s)\n", pcFilename);
415 415
416 if ((inFile = fopen(pcFilename, "ra")) == NULL) 416 if ((inFile = fopen(pcFilename, "ra")) == NULL)
417 return FALSE; 417 return FALSE;
418 418
419 fprintf(stderr, "importing...\n"); 419 fprintf(stderr, "importing...\n");
420 420
421 sectBegin = FALSE; 421 sectBegin = FALSE;
422 lineNum = 0; 422 lineNum = 0;
423 while (fgets(inLine, XS_BUF_SIZE, inFile) != NULL) { 423 while (fgets(inLine, XS_BUF_SIZE, inFile) != NULL) {
424 size_t linePos = 0; 424 size_t linePos = 0;
425 lineNum++; 425 lineNum++;
426 426
427 xs_findnext(inLine, &linePos); 427 xs_findnext(inLine, &linePos);
428 if (isalpha(inLine[linePos]) && sectBegin) { 428 if (isalpha(inLine[linePos]) && sectBegin) {
429 /* A new key/value pair */ 429 /* A new key/value pair */
430 if (!xs_fgetitem(inLine, &linePos, '=', tmpStr, XS_BUF_SIZE)) { 430 if (!xs_fgetitem(inLine, &linePos, '=', tmpStr, XS_BUF_SIZE)) {
431 fprintf(stderr, "invalid line: %s [expect =']'", inLine); 431 fprintf(stderr, "invalid line: %s [expect =']'", inLine);
432 } else { 432 } else {
433 linePos++; 433 linePos++;
434 xs_findnext(inLine, &linePos); 434 xs_findnext(inLine, &linePos);
435 if (!strncmp(tmpStr, "points", 6)) { 435 if (!strncmp(tmpStr, "points", 6)) {
436 fprintf(stderr, "points=%s\n", &inLine[linePos]); 436 fprintf(stderr, "points=%s\n", &inLine[linePos]);
437 } else if (!strncmp(tmpStr, "point", 5)) { 437 } else if (!strncmp(tmpStr, "point", 5)) {
438 } else if (!strncmp(tmpStr, "type", 4)) { 438 } else if (!strncmp(tmpStr, "type", 4)) {
439 } else { 439 } else {
440 fprintf(stderr, "warning: ukn def: %s @ %s\n", 440 fprintf(stderr, "warning: ukn def: %s @ %s\n",
441 tmpStr, sectName); 441 tmpStr, sectName);
442 } 442 }
443 } 443 }
444 } else if (inLine[linePos] == '[') { 444 } else if (inLine[linePos] == '[') {
445 /* Check for existing section */ 445 /* Check for existing section */
446 if (sectBegin) { 446 if (sectBegin) {
447 /* Submit definition */ 447 /* Submit definition */
448 fprintf(stderr, "filter ends: %s\n", sectName); 448 fprintf(stderr, "filter ends: %s\n", sectName);
449 if ((tmpFilter = g_malloc0(sizeof(t_xs_sid2_filter))) == NULL) { 449 if ((tmpFilter = g_malloc0(sizeof(t_xs_sid2_filter))) == NULL) {
450 fprintf(stderr, "could not allocate ..\n"); 450 fprintf(stderr, "could not allocate ..\n");
451 } else { 451 } else {
452 452
453 } 453 }
454 g_free(sectName); 454 g_free(sectName);
455 } 455 }
456 456
457 /* New filter(?) section starts */ 457 /* New filter(?) section starts */
458 linePos++; 458 linePos++;
459 for (i = 0; i < XS_BUF_SIZE && inLine[linePos] && inLine[linePos] != ']'; i++, linePos++) 459 for (i = 0; i < XS_BUF_SIZE && inLine[linePos] && inLine[linePos] != ']'; i++, linePos++)
460 tmpStr[i] = inLine[linePos]; 460 tmpStr[i] = inLine[linePos];
461 tmpStr[i] = 0; 461 tmpStr[i] = 0;
462 462
463 if (inLine[linePos] != ']') { 463 if (inLine[linePos] != ']') {
464 fprintf(stderr, "invalid! expected ']': %s\n", inLine); 464 fprintf(stderr, "invalid! expected ']': %s\n", inLine);
465 } else { 465 } else {
466 sectName = strdup(tmpStr); 466 sectName = strdup(tmpStr);
467 fprintf(stderr, "filter: %s\n", sectName); 467 fprintf(stderr, "filter: %s\n", sectName);
468 sectBegin = TRUE; 468 sectBegin = TRUE;
469 } 469 }
470 } else if ((inLine[linePos] != ';') && (inLine[linePos] != 0)) { 470 } else if ((inLine[linePos] != ';') && (inLine[linePos] != 0)) {
471 /* Syntax error */ 471 /* Syntax error */
472 fprintf(stderr, "syntax error: %s\n", inLine); 472 fprintf(stderr, "syntax error: %s\n", inLine);
473 } 473 }
474 } 474 }
475 475
476 fclose(inFile); 476 fclose(inFile);
477 return TRUE; 477 return TRUE;
478 } 478 }
479 479
480 480
481 static gboolean xs_filters_export(const gchar *pcFilename, t_xs_sid2_filter **pFilters, gint nFilters) 481 static gboolean xs_filters_export(const gchar *pcFilename, t_xs_sid2_filter **pFilters, gint nFilters)
482 { 482 {
483 FILE *outFile; 483 FILE *outFile;
484 t_xs_sid2_filter *f; 484 t_xs_sid2_filter *f;
485 gint n; 485 gint n;
486 486
487 /* Open/create the file */ 487 /* Open/create the file */
488 if ((outFile = fopen(pcFilename, "wa")) == NULL) 488 if ((outFile = fopen(pcFilename, "wa")) == NULL)
489 return FALSE; 489 return FALSE;
490 490
491 /* Header */ 491 /* Header */
492 fprintf(outFile, 492 fprintf(outFile,
493 "; SIDPlay2 compatible filter definition file\n" 493 "; SIDPlay2 compatible filter definition file\n"
494 "; Exported by " PACKAGE_STRING "\n\n"); 494 "; Exported by " PACKAGE_STRING "\n\n");
495 495
496 /* Write each filter spec in "INI"-style format */ 496 /* Write each filter spec in "INI"-style format */
497 for (n = 0; n < nFilters; n++) { 497 for (n = 0; n < nFilters; n++) {
498 gint i; 498 gint i;
499 f = pFilters[n]; 499 f = pFilters[n];
500 500
501 fprintf(outFile, 501 fprintf(outFile,
502 "[%s]\n" 502 "[%s]\n"
503 "type=1\n" 503 "type=1\n"
504 "points=%d\n", 504 "points=%d\n",
505 f->name, f->npoints); 505 f->name, f->npoints);
506 506
507 for (i = 0; i < f->npoints; i++) { 507 for (i = 0; i < f->npoints; i++) {
508 fprintf(outFile, 508 fprintf(outFile,
509 "point%d=%d,%d\n", 509 "point%d=%d,%d\n",
510 i + 1, 510 i + 1,
511 f->points[i].x, 511 f->points[i].x,
512 f->points[i].y); 512 f->points[i].y);
513 } 513 }
514 514
515 fprintf(outFile, "\n"); 515 fprintf(outFile, "\n");
516 f++; 516 f++;
517 } 517 }
518 518
519 fclose(outFile); 519 fclose(outFile);
520 return TRUE; 520 return TRUE;
521 } 521 }
522 522
523 /* Get the configuration (from file or default) 523 /* Get the configuration (from file or default)
524 */ 524 */
525 void xs_read_configuration(void) 525 void xs_read_configuration(void)
526 { 526 {
527 XS_CONFIG_FILE *cfg; 527 XS_CONFIG_FILE *cfg;
528 gint i; 528 gint i;
529 gchar *tmpStr; 529 gchar *tmpStr;
530 530
531 /* Try to open the XMMS configuration file */ 531 /* Try to open the XMMS configuration file */
532 XS_MUTEX_LOCK(xs_cfg); 532 XS_MUTEX_LOCK(xs_cfg);
533 XSDEBUG("loading from config-file ...\n"); 533 XSDEBUG("loading from config-file ...\n");
534 534
535 cfg = XS_CONFIG_OPEN(); 535 cfg = XS_CONFIG_OPEN();
536 536
537 if (cfg == NULL) { 537 if (cfg == NULL) {
538 XSDEBUG("Could not open configuration, trying to write defaults...\n"); 538 XSDEBUG("Could not open configuration, trying to write defaults...\n");
539 xs_write_configuration(); 539 xs_write_configuration();
540 return; 540 return;
541 } 541 }
542 542
543 /* Read the new settings from XMMS configuration file */ 543 /* Read the new settings from XMMS configuration file */
544 for (i = 0; i < xs_cfgtable_max; i++) { 544 for (i = 0; i < xs_cfgtable_max; i++) {
545 switch (xs_cfgtable[i].itemType) { 545 switch (xs_cfgtable[i].itemType) {
546 case CTYPE_INT: 546 case CTYPE_INT:
547 XS_CFG_GET_INT(cfg, XS_CONFIG_IDENT, 547 XS_CFG_GET_INT(cfg, XS_CONFIG_IDENT,
548 xs_cfgtable[i].itemName, 548 xs_cfgtable[i].itemName,
549 (gint *) xs_cfgtable[i].itemData); 549 (gint *) xs_cfgtable[i].itemData);
550 break; 550 break;
551 551
552 case CTYPE_BOOL: 552 case CTYPE_BOOL:
553 XS_CFG_GET_BOOL(cfg, XS_CONFIG_IDENT, 553 XS_CFG_GET_BOOL(cfg, XS_CONFIG_IDENT,
554 xs_cfgtable[i].itemName, 554 xs_cfgtable[i].itemName,
555 (gboolean *) xs_cfgtable[i].itemData); 555 (gboolean *) xs_cfgtable[i].itemData);
556 break; 556 break;
557 557
558 case CTYPE_FLOAT: 558 case CTYPE_FLOAT:
559 XS_CFG_GET_FLOAT(cfg, XS_CONFIG_IDENT, 559 XS_CFG_GET_FLOAT(cfg, XS_CONFIG_IDENT,
560 xs_cfgtable[i].itemName, 560 xs_cfgtable[i].itemName,
561 (gfloat *) xs_cfgtable[i].itemData); 561 (gfloat *) xs_cfgtable[i].itemData);
562 break; 562 break;
563 563
564 case CTYPE_STR: 564 case CTYPE_STR:
565 if (XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT, 565 if (XS_CFG_GET_STRING(cfg, XS_CONFIG_IDENT,
566 xs_cfgtable[i].itemName, (gchar **) &tmpStr)) { 566 xs_cfgtable[i].itemName, (gchar **) &tmpStr)) {
567 xs_pstrcpy((gchar **) xs_cfgtable[i].itemData, tmpStr); 567 xs_pstrcpy((gchar **) xs_cfgtable[i].itemData, tmpStr);
568 g_free(tmpStr); 568 g_free(tmpStr);
569 } 569 }
570 break; 570 break;
571 } 571 }
572 } 572 }
573 573
574 /* Filters and presets are a special case */ 574 /* Filters and presets are a special case */
575 xs_filter_load_into(cfg, 0, &xs_cfg.sid2Filter); 575 xs_filter_load_into(cfg, 0, &xs_cfg.sid2Filter);
576 576
577 if (xs_cfg.sid2NFilterPresets > 0) { 577 if (xs_cfg.sid2NFilterPresets > 0) {
578 xs_cfg.sid2FilterPresets = g_malloc0(xs_cfg.sid2NFilterPresets * sizeof(t_xs_sid2_filter *)); 578 xs_cfg.sid2FilterPresets = g_malloc0(xs_cfg.sid2NFilterPresets * sizeof(t_xs_sid2_filter *));
579 if (!xs_cfg.sid2FilterPresets) { 579 if (!xs_cfg.sid2FilterPresets) {
580 xs_error(_("Allocation of sid2FilterPresets structure failed!\n")); 580 xs_error(_("Allocation of sid2FilterPresets structure failed!\n"));
581 } else { 581 } else {
582 for (i = 0; i < xs_cfg.sid2NFilterPresets; i++) { 582 for (i = 0; i < xs_cfg.sid2NFilterPresets; i++) {
583 xs_cfg.sid2FilterPresets[i] = xs_filter_load(cfg, i); 583 xs_cfg.sid2FilterPresets[i] = xs_filter_load(cfg, i);
584 } 584 }
585 } 585 }
586 } 586 }
587 587
588 XS_CONFIG_FREE(cfg); 588 XS_CONFIG_FREE(cfg);
589 589
590 XS_MUTEX_UNLOCK(xs_cfg); 590 XS_MUTEX_UNLOCK(xs_cfg);
591 XSDEBUG("OK\n"); 591 XSDEBUG("OK\n");
592 } 592 }
593 593
594 594
595 /* Write the current configuration 595 /* Write the current configuration
596 */ 596 */
597 gint xs_write_configuration(void) 597 gint xs_write_configuration(void)
598 { 598 {
599 XS_CONFIG_FILE *cfg; 599 XS_CONFIG_FILE *cfg;
600 gint i; 600 gint i;
601 601
602 XSDEBUG("writing configuration ...\n"); 602 XSDEBUG("writing configuration ...\n");
603 XS_MUTEX_LOCK(xs_cfg); 603 XS_MUTEX_LOCK(xs_cfg);
604 604
605 /* Try to open the XMMS configuration file */ 605 /* Try to open the XMMS configuration file */
606 cfg = XS_CONFIG_OPEN(); 606 cfg = XS_CONFIG_OPEN();
607 607
608 #ifndef AUDACIOUS_PLUGIN 608 #ifndef AUDACIOUS_PLUGIN
609 if (!cfg) cfg = xmms_cfg_new(); 609 if (!cfg) cfg = xmms_cfg_new();
610 if (!cfg) return -1; 610 if (!cfg) return -1;
611 #endif 611 #endif
612 612
613 /* Write the new settings to XMMS configuration file */ 613 /* Write the new settings to XMMS configuration file */
614 for (i = 0; i < xs_cfgtable_max; i++) { 614 for (i = 0; i < xs_cfgtable_max; i++) {
615 switch (xs_cfgtable[i].itemType) { 615 switch (xs_cfgtable[i].itemType) {
616 case CTYPE_INT: 616 case CTYPE_INT:
617 XS_CFG_SET_INT(cfg, XS_CONFIG_IDENT, 617 XS_CFG_SET_INT(cfg, XS_CONFIG_IDENT,
618 xs_cfgtable[i].itemName, 618 xs_cfgtable[i].itemName,
619 *(gint *) xs_cfgtable[i].itemData); 619 *(gint *) xs_cfgtable[i].itemData);
620 break; 620 break;
621 621
622 case CTYPE_BOOL: 622 case CTYPE_BOOL:
623 XS_CFG_SET_BOOL(cfg, XS_CONFIG_IDENT, 623 XS_CFG_SET_BOOL(cfg, XS_CONFIG_IDENT,
624 xs_cfgtable[i].itemName, 624 xs_cfgtable[i].itemName,
625 *(gboolean *) xs_cfgtable[i].itemData); 625 *(gboolean *) xs_cfgtable[i].itemData);
626 break; 626 break;
627 627
628 case CTYPE_FLOAT: 628 case CTYPE_FLOAT:
629 XS_CFG_SET_FLOAT(cfg, XS_CONFIG_IDENT, 629 XS_CFG_SET_FLOAT(cfg, XS_CONFIG_IDENT,
630 xs_cfgtable[i].itemName, 630 xs_cfgtable[i].itemName,
631 *(gfloat *) xs_cfgtable[i].itemData); 631 *(gfloat *) xs_cfgtable[i].itemData);
632 break; 632 break;
633 633
634 case CTYPE_STR: 634 case CTYPE_STR:
635 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT, 635 XS_CFG_SET_STRING(cfg, XS_CONFIG_IDENT,
636 xs_cfgtable[i].itemName, 636 xs_cfgtable[i].itemName,
637 *(gchar **) xs_cfgtable[i].itemData); 637 *(gchar **) xs_cfgtable[i].itemData);
638 break; 638 break;
639 } 639 }
640 } 640 }
641 641
642 642
643 #ifndef AUDACIOUS_PLUGIN 643 #ifndef AUDACIOUS_PLUGIN
644 xmms_cfg_write_default_file(cfg); 644 xmms_cfg_write_default_file(cfg);
645 #endif 645 #endif
646 XS_CONFIG_FREE(cfg); 646 XS_CONFIG_FREE(cfg);
647 647
648 XS_MUTEX_UNLOCK(xs_cfg); 648 XS_MUTEX_UNLOCK(xs_cfg);
649 649
650 return 0; 650 return 0;
651 } 651 }
652 652
653 653
654 /* Configuration panel was canceled 654 /* Configuration panel was canceled
655 */ 655 */
658 658
659 /* Configuration was accepted, save the settings 659 /* Configuration was accepted, save the settings
660 */ 660 */
661 void xs_cfg_ok(void) 661 void xs_cfg_ok(void)
662 { 662 {
663 gint i; 663 gint i;
664 gfloat tmpValue; 664 gfloat tmpValue;
665 gint tmpInt; 665 gint tmpInt;
666 const gchar *tmpStr; 666 const gchar *tmpStr;
667 667
668 /* Get lock on configuration */ 668 /* Get lock on configuration */
669 XS_MUTEX_LOCK(xs_cfg); 669 XS_MUTEX_LOCK(xs_cfg);
670 670
671 XSDEBUG("get data from widgets to config...\n"); 671 XSDEBUG("get data from widgets to config...\n");
672 672
673 for (i = 0; i < xs_widtable_max; i++) { 673 for (i = 0; i < xs_widtable_max; i++) {
674 switch (xs_widtable[i].widType) { 674 switch (xs_widtable[i].widType) {
675 case WTYPE_BGROUP: 675 case WTYPE_BGROUP:
676 /* Check if toggle-button is active */ 676 /* Check if toggle-button is active */
677 if (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active) { 677 if (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active) {
678 /* Yes, set the constant value */ 678 /* Yes, set the constant value */
679 *((gint *) xs_widtable[i].itemData) = xs_widtable[i].itemSet; 679 *((gint *) xs_widtable[i].itemData) = xs_widtable[i].itemSet;
680 } 680 }
681 break; 681 break;
682 682
683 case WTYPE_COMBO: 683 case WTYPE_COMBO:
684 /* Get text from text-widget */ 684 /* Get text from text-widget */
685 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName))); 685 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName)));
686 if (sscanf(tmpStr, "%d", &tmpInt) != 1) 686 if (sscanf(tmpStr, "%d", &tmpInt) != 1)
687 tmpInt = xs_widtable[i].itemSet; 687 tmpInt = xs_widtable[i].itemSet;
688 688
689 *((gint *) xs_widtable[i].itemData) = tmpInt; 689 *((gint *) xs_widtable[i].itemData) = tmpInt;
690 break; 690 break;
691 691
692 case WTYPE_SPIN: 692 case WTYPE_SPIN:
693 case WTYPE_SCALE: 693 case WTYPE_SCALE:
694 /* Get the value */ 694 /* Get the value */
695 switch (xs_widtable[i].widType) { 695 switch (xs_widtable[i].widType) {
696 case WTYPE_SPIN: 696 case WTYPE_SPIN:
697 tmpValue = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName)))->value; 697 tmpValue = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName)))->value;
698 break; 698 break;
699 699
700 case WTYPE_SCALE: 700 case WTYPE_SCALE:
701 tmpValue = gtk_range_get_adjustment(GTK_RANGE(LUW(xs_widtable[i].widName)))->value; 701 tmpValue = gtk_range_get_adjustment(GTK_RANGE(LUW(xs_widtable[i].widName)))->value;
702 break; 702 break;
703 703
704 default: 704 default:
705 tmpValue = -1; 705 tmpValue = -1;
706 break; 706 break;
707 } 707 }
708 708
709 /* Set the value */ 709 /* Set the value */
710 switch (xs_widtable[i].itemType) { 710 switch (xs_widtable[i].itemType) {
711 case CTYPE_INT: 711 case CTYPE_INT:
712 *((gint *) xs_widtable[i].itemData) = (gint) tmpValue; 712 *((gint *) xs_widtable[i].itemData) = (gint) tmpValue;
713 break; 713 break;
714 714
715 case CTYPE_FLOAT: 715 case CTYPE_FLOAT:
716 *((gfloat *) xs_widtable[i].itemData) = tmpValue; 716 *((gfloat *) xs_widtable[i].itemData) = tmpValue;
717 break; 717 break;
718 } 718 }
719 break; 719 break;
720 720
721 case WTYPE_BUTTON: 721 case WTYPE_BUTTON:
722 /* Check if toggle-button is active */ 722 /* Check if toggle-button is active */
723 *((gboolean *) xs_widtable[i].itemData) = 723 *((gboolean *) xs_widtable[i].itemData) =
724 (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active); 724 (GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName))->active);
725 break; 725 break;
726 726
727 case WTYPE_TEXT: 727 case WTYPE_TEXT:
728 /* Get text from text-widget */ 728 /* Get text from text-widget */
729 xs_pstrcpy((gchar **) xs_widtable[i].itemData, 729 xs_pstrcpy((gchar **) xs_widtable[i].itemData,
730 gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName)))); 730 gtk_entry_get_text(GTK_ENTRY(LUW(xs_widtable[i].widName))));
731 break; 731 break;
732 } 732 }
733 } 733 }
734 734
735 /* Get filter settings */ 735 /* Get filter settings */
736 /* 736 /*
737 if (!xs_curve_get_points(XS_CURVE(LUW("")), &xs_cfg.sid2Filter.points, &xs_cfg.sid2Filter.npoints)) { 737 if (!xs_curve_get_points(XS_CURVE(LUW("")), &xs_cfg.sid2Filter.points, &xs_cfg.sid2Filter.npoints)) {
738 xs_error(_("Warning: Could not get filter curve widget points!\n")); 738 xs_error(_("Warning: Could not get filter curve widget points!\n"));
739 } 739 }
740 */ 740 */
741 741
742 /* Release lock */ 742 /* Release lock */
743 XS_MUTEX_UNLOCK(xs_cfg); 743 XS_MUTEX_UNLOCK(xs_cfg);
744 744
745 /* Close window */ 745 /* Close window */
746 gtk_widget_destroy(xs_configwin); 746 gtk_widget_destroy(xs_configwin);
747 xs_configwin = NULL; 747 xs_configwin = NULL;
748 748
749 /* Write settings */ 749 /* Write settings */
750 xs_write_configuration(); 750 xs_write_configuration();
751 751
752 /* Re-initialize */ 752 /* Re-initialize */
753 xs_reinit(); 753 xs_reinit();
754 } 754 }
755 755
756 756
757 /* Confirmation window 757 /* Confirmation window
758 */ 758 */
759 gboolean xs_confirmwin_delete(GtkWidget *widget, GdkEvent *event, gpointer user_data) 759 gboolean xs_confirmwin_delete(GtkWidget *widget, GdkEvent *event, gpointer user_data)
760 { 760 {
761 (void) widget; 761 (void) widget;
762 (void) event; 762 (void) event;
763 (void) user_data; 763 (void) user_data;
764 764
765 return FALSE; 765 return FALSE;
766 } 766 }
767 767
768 768
769 769
770 /* HVSC songlength-database file selector response-functions 770 /* HVSC songlength-database file selector response-functions
771 */ 771 */
772 void xs_cfg_sldb_browse(GtkButton * button, gpointer user_data) 772 void xs_cfg_sldb_browse(GtkButton * button, gpointer user_data)
773 { 773 {
774 (void) button; 774 (void) button;
775 (void) user_data; 775 (void) user_data;
776 776
777 if (xs_sldb_fileselector != NULL) { 777 if (xs_sldb_fileselector != NULL) {
778 gdk_window_raise(xs_sldb_fileselector->window); 778 gdk_window_raise(xs_sldb_fileselector->window);
779 return; 779 return;
780 } 780 }
781 781
782 xs_sldb_fileselector = create_xs_sldb_fs(); 782 xs_sldb_fileselector = create_xs_sldb_fs();
783 XS_MUTEX_LOCK(xs_cfg); 783 XS_MUTEX_LOCK(xs_cfg);
784 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_sldb_fileselector), xs_cfg.songlenDBPath); 784 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_sldb_fileselector), xs_cfg.songlenDBPath);
785 XS_MUTEX_UNLOCK(xs_cfg); 785 XS_MUTEX_UNLOCK(xs_cfg);
786 gtk_widget_show(xs_sldb_fileselector); 786 gtk_widget_show(xs_sldb_fileselector);
787 } 787 }
788 788
789 789
790 void xs_sldb_fs_ok(GtkButton *button, gpointer user_data) 790 void xs_sldb_fs_ok(GtkButton *button, gpointer user_data)
791 { 791 {
792 (void) button; 792 (void) button;
793 (void) user_data; 793 (void) user_data;
794 794
795 /* Selection was accepted! */ 795 /* Selection was accepted! */
796 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")), 796 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_sld_dbpath")),
797 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector))); 797 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_sldb_fileselector)));
798 798
799 /* Close file selector window */ 799 /* Close file selector window */
800 gtk_widget_destroy(xs_sldb_fileselector); 800 gtk_widget_destroy(xs_sldb_fileselector);
801 xs_sldb_fileselector = NULL; 801 xs_sldb_fileselector = NULL;
802 } 802 }
803 803
804 XS_DEF_WINDOW_CLOSE(sldb_fs_cancel, sldb_fileselector) 804 XS_DEF_WINDOW_CLOSE(sldb_fs_cancel, sldb_fileselector)
805 XS_DEF_WINDOW_DELETE(sldb_fs, sldb_fileselector) 805 XS_DEF_WINDOW_DELETE(sldb_fs, sldb_fileselector)
806 806
807 807
808 /* STIL-database file selector response-functions 808 /* STIL-database file selector response-functions
809 */ 809 */
810 void xs_cfg_stil_browse(GtkButton * button, gpointer user_data) 810 void xs_cfg_stil_browse(GtkButton * button, gpointer user_data)
811 { 811 {
812 (void) button; 812 (void) button;
813 (void) user_data; 813 (void) user_data;
814 814
815 if (xs_stil_fileselector != NULL) { 815 if (xs_stil_fileselector != NULL) {
816 gdk_window_raise(xs_stil_fileselector->window); 816 gdk_window_raise(xs_stil_fileselector->window);
817 return; 817 return;
818 } 818 }
819 819
820 xs_stil_fileselector = create_xs_stil_fs(); 820 xs_stil_fileselector = create_xs_stil_fs();
821 XS_MUTEX_LOCK(xs_cfg); 821 XS_MUTEX_LOCK(xs_cfg);
822 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_stil_fileselector), xs_cfg.stilDBPath); 822 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_stil_fileselector), xs_cfg.stilDBPath);
823 XS_MUTEX_UNLOCK(xs_cfg); 823 XS_MUTEX_UNLOCK(xs_cfg);
824 gtk_widget_show(xs_stil_fileselector); 824 gtk_widget_show(xs_stil_fileselector);
825 } 825 }
826 826
827 827
828 void xs_stil_fs_ok(GtkButton *button, gpointer user_data) 828 void xs_stil_fs_ok(GtkButton *button, gpointer user_data)
829 { 829 {
830 (void) button; 830 (void) button;
831 (void) user_data; 831 (void) user_data;
832 832
833 /* Selection was accepted! */ 833 /* Selection was accepted! */
834 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_dbpath")), 834 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_stil_dbpath")),
835 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector))); 835 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_stil_fileselector)));
836 836
837 /* Close file selector window */ 837 /* Close file selector window */
838 gtk_widget_destroy(xs_stil_fileselector); 838 gtk_widget_destroy(xs_stil_fileselector);
839 xs_stil_fileselector = NULL; 839 xs_stil_fileselector = NULL;
840 } 840 }
841 841
842 842
843 XS_DEF_WINDOW_CLOSE(stil_fs_cancel, stil_fileselector) 843 XS_DEF_WINDOW_CLOSE(stil_fs_cancel, stil_fileselector)
844 XS_DEF_WINDOW_DELETE(stil_fs, stil_fileselector) 844 XS_DEF_WINDOW_DELETE(stil_fs, stil_fileselector)
846 846
847 /* HVSC location selector response-functions 847 /* HVSC location selector response-functions
848 */ 848 */
849 void xs_cfg_hvsc_browse(GtkButton * button, gpointer user_data) 849 void xs_cfg_hvsc_browse(GtkButton * button, gpointer user_data)
850 { 850 {
851 (void) button; 851 (void) button;
852 (void) user_data; 852 (void) user_data;
853 853
854 if (xs_hvsc_selector != NULL) { 854 if (xs_hvsc_selector != NULL) {
855 gdk_window_raise(xs_hvsc_selector->window); 855 gdk_window_raise(xs_hvsc_selector->window);
856 return; 856 return;
857 } 857 }
858 858
859 xs_hvsc_selector = create_xs_hvsc_fs(); 859 xs_hvsc_selector = create_xs_hvsc_fs();
860 XS_MUTEX_LOCK(xs_cfg); 860 XS_MUTEX_LOCK(xs_cfg);
861 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_hvsc_selector), xs_cfg.hvscPath); 861 gtk_file_selection_set_filename(GTK_FILE_SELECTION(xs_hvsc_selector), xs_cfg.hvscPath);
862 XS_MUTEX_UNLOCK(xs_cfg); 862 XS_MUTEX_UNLOCK(xs_cfg);
863 gtk_widget_show(xs_hvsc_selector); 863 gtk_widget_show(xs_hvsc_selector);
864 } 864 }
865 865
866 866
867 void xs_hvsc_fs_ok(GtkButton *button, gpointer user_data) 867 void xs_hvsc_fs_ok(GtkButton *button, gpointer user_data)
868 { 868 {
869 (void) button; 869 (void) button;
870 (void) user_data; 870 (void) user_data;
871 871
872 /* Selection was accepted! */ 872 /* Selection was accepted! */
873 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_hvsc_path")), 873 gtk_entry_set_text(GTK_ENTRY(LUW("cfg_hvsc_path")),
874 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_hvsc_selector))); 874 gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_hvsc_selector)));
875 875
876 /* Close file selector window */ 876 /* Close file selector window */
877 gtk_widget_destroy(xs_hvsc_selector); 877 gtk_widget_destroy(xs_hvsc_selector);
878 xs_hvsc_selector = NULL; 878 xs_hvsc_selector = NULL;
879 } 879 }
880 880
881 881
882 XS_DEF_WINDOW_CLOSE(hvsc_fs_cancel, hvsc_selector) 882 XS_DEF_WINDOW_CLOSE(hvsc_fs_cancel, hvsc_selector)
883 XS_DEF_WINDOW_DELETE(hvsc_fs, hvsc_selector) 883 XS_DEF_WINDOW_DELETE(hvsc_fs, hvsc_selector)
885 885
886 /* Filter handling 886 /* Filter handling
887 */ 887 */
888 void xs_cfg_sp1_filter_reset(GtkButton * button, gpointer user_data) 888 void xs_cfg_sp1_filter_reset(GtkButton * button, gpointer user_data)
889 { 889 {
890 (void) button; 890 (void) button;
891 (void) user_data; 891 (void) user_data;
892 892
893 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_fs"))), XS_SIDPLAY1_FS); 893 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_fs"))), XS_SIDPLAY1_FS);
894 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_fm"))), XS_SIDPLAY1_FM); 894 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_fm"))), XS_SIDPLAY1_FM);
895 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_ft"))), XS_SIDPLAY1_FT); 895 gtk_adjustment_set_value(gtk_range_get_adjustment(GTK_RANGE(LUW("cfg_sp1_filter_ft"))), XS_SIDPLAY1_FT);
896 } 896 }
897 897
898 898
899 void xs_cfg_sp2_filter_update(XSCurve *curve, t_xs_sid2_filter *f) 899 void xs_cfg_sp2_filter_update(XSCurve *curve, t_xs_sid2_filter *f)
900 { 900 {
901 assert(curve); 901 assert(curve);
902 assert(f); 902 assert(f);
903 903
904 xs_curve_reset(curve); 904 xs_curve_reset(curve);
905 xs_curve_set_range(curve, 0,0, XS_SIDPLAY2_NFPOINTS, XS_SIDPLAY2_FMAX); 905 xs_curve_set_range(curve, 0,0, XS_SIDPLAY2_NFPOINTS, XS_SIDPLAY2_FMAX);
906 if (!xs_curve_set_points(curve, f->points, f->npoints)) { 906 if (!xs_curve_set_points(curve, f->points, f->npoints)) {
907 // FIXME 907 // FIXME
908 xs_error(_("Warning: Could not set filter curve widget points!\n")); 908 xs_error(_("Warning: Could not set filter curve widget points!\n"));
909 } 909 }
910 } 910 }
911 911
912 912
913 void xs_cfg_sp2_presets_update(void) 913 void xs_cfg_sp2_presets_update(void)
914 { 914 {
915 GList *tmpList = NULL; 915 GList *tmpList = NULL;
916 gint i; 916 gint i;
917 917
918 for (i = 0; i < xs_cfg.sid2NFilterPresets; i++) { 918 for (i = 0; i < xs_cfg.sid2NFilterPresets; i++) {
919 tmpList = g_list_append(tmpList, 919 tmpList = g_list_append(tmpList,
920 (gpointer) xs_cfg.sid2FilterPresets[i]->name); 920 (gpointer) xs_cfg.sid2FilterPresets[i]->name);
921 } 921 }
922 922
923 gtk_combo_set_popdown_strings(GTK_COMBO(LUW("cfg_sp2_filter_combo")), tmpList); 923 gtk_combo_set_popdown_strings(GTK_COMBO(LUW("cfg_sp2_filter_combo")), tmpList);
924 g_list_free(tmpList); 924 g_list_free(tmpList);
925 } 925 }
926 926
927 927
928 void xs_cfg_sp2_filter_load(GtkButton *button, gpointer user_data) 928 void xs_cfg_sp2_filter_load(GtkButton *button, gpointer user_data)
929 { 929 {
930 const gchar *tmpStr; 930 const gchar *tmpStr;
931 gint i, j; 931 gint i, j;
932 932
933 (void) button; 933 (void) button;
934 (void) user_data; 934 (void) user_data;
935 935
936 XS_MUTEX_LOCK(xs_cfg); 936 XS_MUTEX_LOCK(xs_cfg);
937 937
938 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sp2_filter_combo_entry"))); 938 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sp2_filter_combo_entry")));
939 for (i = 0, j = -1; i < xs_cfg.sid2NFilterPresets; i++) { 939 for (i = 0, j = -1; i < xs_cfg.sid2NFilterPresets; i++) {
940 if (!strcmp(tmpStr, xs_cfg.sid2FilterPresets[i]->name)) { 940 if (!strcmp(tmpStr, xs_cfg.sid2FilterPresets[i]->name)) {
941 j = i; 941 j = i;
942 break; 942 break;
943 } 943 }
944 } 944 }
945 945
946 if (j != -1) { 946 if (j != -1) {
947 fprintf(stderr, "Updating from '%s'\n", tmpStr); 947 fprintf(stderr, "Updating from '%s'\n", tmpStr);
948 xs_cfg_sp2_filter_update( 948 xs_cfg_sp2_filter_update(
949 XS_CURVE(LUW("cfg_sp2_filter_curve")), 949 XS_CURVE(LUW("cfg_sp2_filter_curve")),
950 xs_cfg.sid2FilterPresets[i]); 950 xs_cfg.sid2FilterPresets[i]);
951 } else { 951 } else {
952 /* error/warning: no such filter preset */ 952 /* error/warning: no such filter preset */
953 fprintf(stderr, "No such filter preset '%s'!\n", tmpStr); 953 fprintf(stderr, "No such filter preset '%s'!\n", tmpStr);
954 } 954 }
955 955
956 XS_MUTEX_UNLOCK(xs_cfg); 956 XS_MUTEX_UNLOCK(xs_cfg);
957 } 957 }
958 958
959 959
960 void xs_cfg_sp2_filter_save(GtkButton *button, gpointer user_data) 960 void xs_cfg_sp2_filter_save(GtkButton *button, gpointer user_data)
961 { 961 {
962 /* 962 /*
963 1) check if textentry matches any current filter name 963 1) check if textentry matches any current filter name
964 yes) ask if saving over ok? 964 yes) ask if saving over ok?
965 no) ... 965 no) ...
966 966
967 2) save current filter to the name 967 2) save current filter to the name
968 */ 968 */
969 const gchar *tmpStr; 969 const gchar *tmpStr;
970 gint i, j; 970 gint i, j;
971 971
972 (void) button; 972 (void) button;
973 (void) user_data; 973 (void) user_data;
974 974
975 XS_MUTEX_LOCK(xs_cfg); 975 XS_MUTEX_LOCK(xs_cfg);
976 976
977 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sp2_filter_combo_entry"))); 977 tmpStr = gtk_entry_get_text(GTK_ENTRY(LUW("cfg_sp2_filter_combo_entry")));
978 for (i = 0, j = -1; i < xs_cfg.sid2NFilterPresets; i++) { 978 for (i = 0, j = -1; i < xs_cfg.sid2NFilterPresets; i++) {
979 if (!strcmp(tmpStr, xs_cfg.sid2FilterPresets[i]->name)) { 979 if (!strcmp(tmpStr, xs_cfg.sid2FilterPresets[i]->name)) {
980 j = i; 980 j = i;
981 break; 981 break;
982 } 982 }
983 } 983 }
984 984
985 if (j != -1) { 985 if (j != -1) {
986 fprintf(stderr, "Found, confirm overwrite?\n"); 986 fprintf(stderr, "Found, confirm overwrite?\n");
987 } 987 }
988 988
989 fprintf(stderr, "saving!\n"); 989 fprintf(stderr, "saving!\n");
990 990
991 xs_cfg_sp2_presets_update(); 991 xs_cfg_sp2_presets_update();
992 992
993 XS_MUTEX_UNLOCK(xs_cfg); 993 XS_MUTEX_UNLOCK(xs_cfg);
994 } 994 }
995 995
996 996
997 void xs_cfg_sp2_filter_delete(GtkButton *button, gpointer user_data) 997 void xs_cfg_sp2_filter_delete(GtkButton *button, gpointer user_data)
998 { 998 {
999 (void) button; 999 (void) button;
1000 (void) user_data; 1000 (void) user_data;
1001 /* 1001 /*
1002 1) confirm 1002 1) confirm
1003 2) delete 1003 2) delete
1004 */ 1004 */
1005 } 1005 }
1006 1006
1007 1007
1008 void xs_cfg_sp2_filter_import(GtkButton *button, gpointer user_data) 1008 void xs_cfg_sp2_filter_import(GtkButton *button, gpointer user_data)
1009 { 1009 {
1010 (void) button; 1010 (void) button;
1011 (void) user_data; 1011 (void) user_data;
1012 1012
1013 if (xs_filt_importselector != NULL) { 1013 if (xs_filt_importselector != NULL) {
1014 gdk_window_raise(xs_filt_importselector->window); 1014 gdk_window_raise(xs_filt_importselector->window);
1015 return; 1015 return;
1016 } 1016 }
1017 1017
1018 xs_filt_importselector = create_xs_filter_import_fs(); 1018 xs_filt_importselector = create_xs_filter_import_fs();
1019 gtk_widget_show(xs_filt_importselector); 1019 gtk_widget_show(xs_filt_importselector);
1020 } 1020 }
1021 1021
1022 1022
1023 void xs_filter_import_fs_ok(GtkButton *button, gpointer user_data) 1023 void xs_filter_import_fs_ok(GtkButton *button, gpointer user_data)
1024 { 1024 {
1025 const gchar *tmpStr; 1025 const gchar *tmpStr;
1026 (void) button; 1026 (void) button;
1027 (void) user_data; 1027 (void) user_data;
1028 1028
1029 XS_MUTEX_LOCK(xs_cfg); 1029 XS_MUTEX_LOCK(xs_cfg);
1030 1030
1031 /* Selection was accepted! */ 1031 /* Selection was accepted! */
1032 tmpStr = gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_filt_importselector)); 1032 tmpStr = gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_filt_importselector));
1033 xs_filters_import(tmpStr, xs_cfg.sid2FilterPresets, &xs_cfg.sid2NFilterPresets); 1033 xs_filters_import(tmpStr, xs_cfg.sid2FilterPresets, &xs_cfg.sid2NFilterPresets);
1034 xs_cfg_sp2_presets_update(); 1034 xs_cfg_sp2_presets_update();
1035 1035
1036 /* Close file selector window */ 1036 /* Close file selector window */
1037 gtk_widget_destroy(xs_filt_importselector); 1037 gtk_widget_destroy(xs_filt_importselector);
1038 xs_filt_importselector = NULL; 1038 xs_filt_importselector = NULL;
1039 XS_MUTEX_UNLOCK(xs_cfg); 1039 XS_MUTEX_UNLOCK(xs_cfg);
1040 } 1040 }
1041 1041
1042 1042
1043 XS_DEF_WINDOW_CLOSE(filter_import_fs_cancel, filt_importselector) 1043 XS_DEF_WINDOW_CLOSE(filter_import_fs_cancel, filt_importselector)
1044 XS_DEF_WINDOW_DELETE(filter_import_fs, filt_importselector) 1044 XS_DEF_WINDOW_DELETE(filter_import_fs, filt_importselector)
1045 1045
1046 1046
1047 void xs_cfg_sp2_filter_export(GtkButton *button, gpointer user_data) 1047 void xs_cfg_sp2_filter_export(GtkButton *button, gpointer user_data)
1048 { 1048 {
1049 (void) button; 1049 (void) button;
1050 (void) user_data; 1050 (void) user_data;
1051 1051
1052 if (xs_filt_exportselector != NULL) { 1052 if (xs_filt_exportselector != NULL) {
1053 gdk_window_raise(xs_filt_exportselector->window); 1053 gdk_window_raise(xs_filt_exportselector->window);
1054 return; 1054 return;
1055 } 1055 }
1056 1056
1057 xs_filt_exportselector = create_xs_filter_export_fs(); 1057 xs_filt_exportselector = create_xs_filter_export_fs();
1058 gtk_widget_show(xs_filt_exportselector); 1058 gtk_widget_show(xs_filt_exportselector);
1059 } 1059 }
1060 1060
1061 1061
1062 void xs_filter_export_fs_ok(GtkButton *button, gpointer user_data) 1062 void xs_filter_export_fs_ok(GtkButton *button, gpointer user_data)
1063 { 1063 {
1064 const gchar *tmpStr; 1064 const gchar *tmpStr;
1065 (void) button; 1065 (void) button;
1066 (void) user_data; 1066 (void) user_data;
1067 1067
1068 XS_MUTEX_LOCK(xs_cfg); 1068 XS_MUTEX_LOCK(xs_cfg);
1069 1069
1070 /* Selection was accepted! */ 1070 /* Selection was accepted! */
1071 tmpStr = gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_filt_exportselector)); 1071 tmpStr = gtk_file_selection_get_filename(GTK_FILE_SELECTION(xs_filt_exportselector));
1072 xs_filters_export(tmpStr, xs_cfg.sid2FilterPresets, xs_cfg.sid2NFilterPresets); 1072 xs_filters_export(tmpStr, xs_cfg.sid2FilterPresets, xs_cfg.sid2NFilterPresets);
1073 1073
1074 /* Close file selector window */ 1074 /* Close file selector window */
1075 gtk_widget_destroy(xs_filt_exportselector); 1075 gtk_widget_destroy(xs_filt_exportselector);
1076 xs_filt_exportselector = NULL; 1076 xs_filt_exportselector = NULL;
1077 XS_MUTEX_UNLOCK(xs_cfg); 1077 XS_MUTEX_UNLOCK(xs_cfg);
1078 } 1078 }
1079 1079
1080 1080
1081 XS_DEF_WINDOW_CLOSE(filter_export_fs_cancel, filt_exportselector) 1081 XS_DEF_WINDOW_CLOSE(filter_export_fs_cancel, filt_exportselector)
1082 XS_DEF_WINDOW_DELETE(filter_export_fs, filt_exportselector) 1082 XS_DEF_WINDOW_DELETE(filter_export_fs, filt_exportselector)
1084 1084
1085 /* Selection toggle handlers 1085 /* Selection toggle handlers
1086 */ 1086 */
1087 void xs_cfg_emu_filters_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1087 void xs_cfg_emu_filters_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1088 { 1088 {
1089 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1089 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1090 1090
1091 (void) user_data; 1091 (void) user_data;
1092 1092
1093 gtk_widget_set_sensitive(LUW("cfg_filters_notebook"), isActive); 1093 gtk_widget_set_sensitive(LUW("cfg_filters_notebook"), isActive);
1094 } 1094 }
1095 1095
1096 1096
1097 void xs_cfg_ftitle_override_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1097 void xs_cfg_ftitle_override_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1098 { 1098 {
1099 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1099 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1100 1100
1101 (void) user_data; 1101 (void) user_data;
1102 1102
1103 gtk_widget_set_sensitive(LUW("cfg_ftitle_box"), isActive); 1103 gtk_widget_set_sensitive(LUW("cfg_ftitle_box"), isActive);
1104 } 1104 }
1105 1105
1106 1106
1107 void xs_cfg_emu_sidplay1_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1107 void xs_cfg_emu_sidplay1_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1108 { 1108 {
1109 (void) togglebutton; 1109 (void) togglebutton;
1110 (void) user_data; 1110 (void) user_data;
1111 } 1111 }
1112 1112
1113 1113
1114 void xs_cfg_emu_sidplay2_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1114 void xs_cfg_emu_sidplay2_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1115 { 1115 {
1116 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1116 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1117 1117
1118 (void) user_data; 1118 (void) user_data;
1119 1119
1120 gtk_widget_set_sensitive(LUW("cfg_emu_mem_real"), isActive); 1120 gtk_widget_set_sensitive(LUW("cfg_emu_mem_real"), isActive);
1121 1121
1122 gtk_widget_set_sensitive(LUW("cfg_sidplay2_frame"), isActive); 1122 gtk_widget_set_sensitive(LUW("cfg_sidplay2_frame"), isActive);
1123 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_opt"), isActive); 1123 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_opt"), isActive);
1124 1124
1125 gtk_widget_set_sensitive(LUW("cfg_chn_autopan"), !isActive); 1125 gtk_widget_set_sensitive(LUW("cfg_chn_autopan"), !isActive);
1126 1126
1127 #ifdef HAVE_RESID_BUILDER 1127 #ifdef HAVE_RESID_BUILDER
1128 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_resid"), isActive); 1128 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_resid"), isActive);
1129 #else 1129 #else
1130 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_resid"), FALSE); 1130 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_resid"), FALSE);
1131 #endif 1131 #endif
1132 1132
1133 #ifdef HAVE_HARDSID_BUILDER 1133 #ifdef HAVE_HARDSID_BUILDER
1134 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_hardsid"), isActive); 1134 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_hardsid"), isActive);
1135 #else 1135 #else
1136 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_hardsid"), FALSE); 1136 gtk_widget_set_sensitive(LUW("cfg_emu_sp2_hardsid"), FALSE);
1137 #endif 1137 #endif
1138 } 1138 }
1139 1139
1140 1140
1141 void xs_cfg_oversample_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1141 void xs_cfg_oversample_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1142 { 1142 {
1143 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1143 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1144 1144
1145 (void) user_data; 1145 (void) user_data;
1146 1146
1147 gtk_widget_set_sensitive(LUW("cfg_oversample_box"), isActive); 1147 gtk_widget_set_sensitive(LUW("cfg_oversample_box"), isActive);
1148 } 1148 }
1149 1149
1150 1150
1151 void xs_cfg_mintime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1151 void xs_cfg_mintime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1152 { 1152 {
1153 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1153 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1154 1154
1155 (void) user_data; 1155 (void) user_data;
1156 1156
1157 gtk_widget_set_sensitive(LUW("cfg_mintime_box"), isActive); 1157 gtk_widget_set_sensitive(LUW("cfg_mintime_box"), isActive);
1158 } 1158 }
1159 1159
1160 1160
1161 void xs_cfg_maxtime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1161 void xs_cfg_maxtime_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1162 { 1162 {
1163 gboolean isActive = GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable"))->active; 1163 gboolean isActive = GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable"))->active;
1164 1164
1165 (void) togglebutton; 1165 (void) togglebutton;
1166 (void) user_data; 1166 (void) user_data;
1167 1167
1168 gtk_widget_set_sensitive(LUW("cfg_maxtime_unknown"), isActive); 1168 gtk_widget_set_sensitive(LUW("cfg_maxtime_unknown"), isActive);
1169 gtk_widget_set_sensitive(LUW("cfg_maxtime_box"), isActive); 1169 gtk_widget_set_sensitive(LUW("cfg_maxtime_box"), isActive);
1170 } 1170 }
1171 1171
1172 1172
1173 void xs_cfg_sldb_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1173 void xs_cfg_sldb_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1174 { 1174 {
1175 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1175 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1176 1176
1177 (void) user_data; 1177 (void) user_data;
1178 1178
1179 gtk_widget_set_sensitive(LUW("cfg_sld_box"), isActive); 1179 gtk_widget_set_sensitive(LUW("cfg_sld_box"), isActive);
1180 } 1180 }
1181 1181
1182 1182
1183 void xs_cfg_stil_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1183 void xs_cfg_stil_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1184 { 1184 {
1185 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1185 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1186 1186
1187 (void) user_data; 1187 (void) user_data;
1188 1188
1189 gtk_widget_set_sensitive(LUW("cfg_stil_box1"), isActive); 1189 gtk_widget_set_sensitive(LUW("cfg_stil_box1"), isActive);
1190 gtk_widget_set_sensitive(LUW("cfg_stil_box2"), isActive); 1190 gtk_widget_set_sensitive(LUW("cfg_stil_box2"), isActive);
1191 } 1191 }
1192 1192
1193 1193
1194 void xs_cfg_subauto_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1194 void xs_cfg_subauto_enable_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1195 { 1195 {
1196 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active; 1196 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active;
1197 1197
1198 (void) user_data; 1198 (void) user_data;
1199 1199
1200 gtk_widget_set_sensitive(LUW("cfg_subauto_min_only"), isActive); 1200 gtk_widget_set_sensitive(LUW("cfg_subauto_min_only"), isActive);
1201 gtk_widget_set_sensitive(LUW("cfg_subauto_box"), isActive); 1201 gtk_widget_set_sensitive(LUW("cfg_subauto_box"), isActive);
1202 } 1202 }
1203 1203
1204 1204
1205 void xs_cfg_subauto_min_only_toggled(GtkToggleButton * togglebutton, gpointer user_data) 1205 void xs_cfg_subauto_min_only_toggled(GtkToggleButton * togglebutton, gpointer user_data)
1206 { 1206 {
1207 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active && 1207 gboolean isActive = GTK_TOGGLE_BUTTON(togglebutton)->active &&
1208 GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable"))->active; 1208 GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable"))->active;
1209 1209
1210 (void) user_data; 1210 (void) user_data;
1211 1211
1212 gtk_widget_set_sensitive(LUW("cfg_subauto_box"), isActive); 1212 gtk_widget_set_sensitive(LUW("cfg_subauto_box"), isActive);
1213 } 1213 }
1214 1214
1215 1215
1216 void xs_cfg_mintime_changed(GtkEditable * editable, gpointer user_data) 1216 void xs_cfg_mintime_changed(GtkEditable * editable, gpointer user_data)
1217 { 1217 {
1218 gint tmpValue; 1218 gint tmpValue;
1219 GtkAdjustment *tmpAdj; 1219 GtkAdjustment *tmpAdj;
1220 1220
1221 (void) user_data; 1221 (void) user_data;
1222 1222
1223 tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_maxtime"))); 1223 tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_maxtime")));
1224 1224
1225 tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value; 1225 tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value;
1226 1226
1227 if (tmpValue > tmpAdj->value) 1227 if (tmpValue > tmpAdj->value)
1228 gtk_adjustment_set_value(tmpAdj, tmpValue); 1228 gtk_adjustment_set_value(tmpAdj, tmpValue);
1229 } 1229 }
1230 1230
1231 1231
1232 void xs_cfg_maxtime_changed(GtkEditable * editable, gpointer user_data) 1232 void xs_cfg_maxtime_changed(GtkEditable * editable, gpointer user_data)
1233 { 1233 {
1234 gint tmpValue; 1234 gint tmpValue;
1235 GtkAdjustment *tmpAdj; 1235 GtkAdjustment *tmpAdj;
1236 1236
1237 (void) user_data; 1237 (void) user_data;
1238 1238
1239 tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_mintime"))); 1239 tmpAdj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(LUW("cfg_mintime")));
1240 1240
1241 tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value; 1241 tmpValue = (gint) gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(editable))->value;
1242 1242
1243 if (tmpValue < tmpAdj->value) 1243 if (tmpValue < tmpAdj->value)
1244 gtk_adjustment_set_value(tmpAdj, tmpValue); 1244 gtk_adjustment_set_value(tmpAdj, tmpValue);
1245 } 1245 }
1246 1246
1247 1247
1248 XS_DEF_WINDOW_DELETE(configwin, configwin) 1248 XS_DEF_WINDOW_DELETE(configwin, configwin)
1249 1249
1250 1250
1251 /* Execute the configuration panel 1251 /* Execute the configuration panel
1252 */ 1252 */
1253 void xs_configure(void) 1253 void xs_configure(void)
1254 { 1254 {
1255 gint i; 1255 gint i;
1256 gfloat tmpValue; 1256 gfloat tmpValue;
1257 gchar tmpStr[64]; 1257 gchar tmpStr[64];
1258 GList *tmpList = NULL; 1258 GList *tmpList = NULL;
1259 GtkWidget *tmpCurve; 1259 GtkWidget *tmpCurve;
1260 1260
1261 /* Check if the window already exists */ 1261 /* Check if the window already exists */
1262 if (xs_configwin) { 1262 if (xs_configwin) {
1263 gdk_window_raise(xs_configwin->window); 1263 gdk_window_raise(xs_configwin->window);
1264 return; 1264 return;
1265 } 1265 }
1266 1266
1267 /* Create the window */ 1267 /* Create the window */
1268 xs_configwin = create_xs_configwin(); 1268 xs_configwin = create_xs_configwin();
1269 1269
1270 /* Get lock on configuration */ 1270 /* Get lock on configuration */
1271 XS_MUTEX_LOCK(xs_cfg); 1271 XS_MUTEX_LOCK(xs_cfg);
1272 1272
1273 /* Add samplerates */ 1273 /* Add samplerates */
1274 for (i = 0; i < xs_nsamplerates_table; i++) { 1274 for (i = 0; i < xs_nsamplerates_table; i++) {
1275 tmpList = g_list_append (tmpList, 1275 tmpList = g_list_append (tmpList,
1276 (gpointer) xs_samplerates_table[i]); 1276 (gpointer) xs_samplerates_table[i]);
1277 } 1277 }
1278 gtk_combo_set_popdown_strings(GTK_COMBO(LUW("cfg_samplerate_combo")), tmpList); 1278 gtk_combo_set_popdown_strings(GTK_COMBO(LUW("cfg_samplerate_combo")), tmpList);
1279 g_list_free(tmpList); 1279 g_list_free(tmpList);
1280 1280
1281 /* Create the custom filter curve widget for libSIDPlay2 */ 1281 /* Create the custom filter curve widget for libSIDPlay2 */
1282 xs_cfg_sp2_presets_update(); 1282 xs_cfg_sp2_presets_update();
1283 tmpCurve = xs_curve_new(); 1283 tmpCurve = xs_curve_new();
1284 xs_cfg_sp2_filter_update(XS_CURVE(tmpCurve), &xs_cfg.sid2Filter); 1284 xs_cfg_sp2_filter_update(XS_CURVE(tmpCurve), &xs_cfg.sid2Filter);
1285 gtk_widget_set_name(tmpCurve, "cfg_sp2_filter_curve"); 1285 gtk_widget_set_name(tmpCurve, "cfg_sp2_filter_curve");
1286 gtk_widget_ref(tmpCurve); 1286 gtk_widget_ref(tmpCurve);
1287 gtk_object_set_data_full(GTK_OBJECT(xs_configwin), 1287 gtk_object_set_data_full(GTK_OBJECT(xs_configwin),
1288 "cfg_sp2_filter_curve", tmpCurve, (GtkDestroyNotify) gtk_widget_unref); 1288 "cfg_sp2_filter_curve", tmpCurve, (GtkDestroyNotify) gtk_widget_unref);
1289 gtk_widget_show(tmpCurve); 1289 gtk_widget_show(tmpCurve);
1290 gtk_container_add(GTK_CONTAINER(LUW("cfg_sp2_filter_frame")), tmpCurve); 1290 gtk_container_add(GTK_CONTAINER(LUW("cfg_sp2_filter_frame")), tmpCurve);
1291 1291
1292 1292
1293 /* Based on available optional parts, gray out options */ 1293 /* Based on available optional parts, gray out options */
1294 #ifndef HAVE_SIDPLAY1 1294 #ifndef HAVE_SIDPLAY1
1295 gtk_widget_set_sensitive(LUW("cfg_emu_sidplay1"), FALSE); 1295 gtk_widget_set_sensitive(LUW("cfg_emu_sidplay1"), FALSE);
1296 gtk_widget_set_sensitive(LUW("cfg_box_filter_sidplay1"), FALSE); 1296 gtk_widget_set_sensitive(LUW("cfg_box_filter_sidplay1"), FALSE);
1297 #endif 1297 #endif
1298 1298
1299 #ifndef HAVE_SIDPLAY2 1299 #ifndef HAVE_SIDPLAY2
1300 gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2"), FALSE); 1300 gtk_widget_set_sensitive(LUW("cfg_emu_sidplay2"), FALSE);
1301 gtk_widget_set_sensitive(LUW("cfg_box_filter_sidplay2"), FALSE); 1301 gtk_widget_set_sensitive(LUW("cfg_box_filter_sidplay2"), FALSE);
1302 #endif 1302 #endif
1303 1303
1304 gtk_widget_set_sensitive(LUW("cfg_resid_frame"), FALSE); 1304 gtk_widget_set_sensitive(LUW("cfg_resid_frame"), FALSE);
1305 1305
1306 #if !defined(HAVE_XMMSEXTRA) && !defined(AUDACIOUS_PLUGIN) 1306 #if !defined(HAVE_XMMSEXTRA) && !defined(AUDACIOUS_PLUGIN)
1307 gtk_widget_set_sensitive(LUW("cfg_ftitle_override"), FALSE); 1307 gtk_widget_set_sensitive(LUW("cfg_ftitle_override"), FALSE);
1308 xs_cfg.titleOverride = TRUE; 1308 xs_cfg.titleOverride = TRUE;
1309 #endif 1309 #endif
1310 1310
1311 #if !defined(HAVE_SONG_POSITION) && !defined(AUDACIOUS_PLUGIN) 1311 #if !defined(HAVE_SONG_POSITION) && !defined(AUDACIOUS_PLUGIN)
1312 gtk_widget_set_sensitive(LUW("cfg_subctrl_patch"), FALSE); 1312 gtk_widget_set_sensitive(LUW("cfg_subctrl_patch"), FALSE);
1313 #endif 1313 #endif
1314 1314
1315 xs_cfg_ftitle_override_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_ftitle_override")), NULL); 1315 xs_cfg_ftitle_override_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_ftitle_override")), NULL);
1316 xs_cfg_emu_filters_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_filters")), NULL); 1316 xs_cfg_emu_filters_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_filters")), NULL);
1317 xs_cfg_emu_sidplay1_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_sidplay1")), NULL); 1317 xs_cfg_emu_sidplay1_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_sidplay1")), NULL);
1318 xs_cfg_emu_sidplay2_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_sidplay2")), NULL); 1318 xs_cfg_emu_sidplay2_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_emu_sidplay2")), NULL);
1319 xs_cfg_oversample_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_oversample")), NULL); 1319 xs_cfg_oversample_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_oversample")), NULL);
1320 xs_cfg_mintime_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_mintime_enable")), NULL); 1320 xs_cfg_mintime_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_mintime_enable")), NULL);
1321 xs_cfg_maxtime_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable")), NULL); 1321 xs_cfg_maxtime_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_maxtime_enable")), NULL);
1322 xs_cfg_sldb_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_sld_enable")), NULL); 1322 xs_cfg_sldb_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_sld_enable")), NULL);
1323 xs_cfg_stil_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_stil_enable")), NULL); 1323 xs_cfg_stil_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_stil_enable")), NULL);
1324 xs_cfg_subauto_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable")), NULL); 1324 xs_cfg_subauto_enable_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_subauto_enable")), NULL);
1325 xs_cfg_subauto_min_only_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_subauto_min_only")), NULL); 1325 xs_cfg_subauto_min_only_toggled(GTK_TOGGLE_BUTTON(LUW("cfg_subauto_min_only")), NULL);
1326 1326
1327 1327
1328 /* Set current data to widgets */ 1328 /* Set current data to widgets */
1329 for (i = 0; i < xs_widtable_max; i++) { 1329 for (i = 0; i < xs_widtable_max; i++) {
1330 switch (xs_widtable[i].widType) { 1330 switch (xs_widtable[i].widType) {
1331 case WTYPE_BGROUP: 1331 case WTYPE_BGROUP:
1332 assert(xs_widtable[i].itemType == CTYPE_INT); 1332 assert(xs_widtable[i].itemType == CTYPE_INT);
1333 /* Check if current value matches the given one */ 1333 /* Check if current value matches the given one */
1334 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)), 1334 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
1335 (*((gint *) xs_widtable[i].itemData) == xs_widtable[i].itemSet)); 1335 (*((gint *) xs_widtable[i].itemData) == xs_widtable[i].itemSet));
1336 break; 1336 break;
1337 1337
1338 case WTYPE_COMBO: 1338 case WTYPE_COMBO:
1339 assert(xs_widtable[i].itemType == CTYPE_INT); 1339 assert(xs_widtable[i].itemType == CTYPE_INT);
1340 g_snprintf(tmpStr, sizeof(tmpStr), "%d", *(gint *) xs_widtable[i].itemData); 1340 g_snprintf(tmpStr, sizeof(tmpStr), "%d", *(gint *) xs_widtable[i].itemData);
1341 gtk_entry_set_text(GTK_ENTRY(LUW(xs_widtable[i].widName)), tmpStr); 1341 gtk_entry_set_text(GTK_ENTRY(LUW(xs_widtable[i].widName)), tmpStr);
1342 break; 1342 break;
1343 1343
1344 case WTYPE_SPIN: 1344 case WTYPE_SPIN:
1345 case WTYPE_SCALE: 1345 case WTYPE_SCALE:
1346 /* Get the value */ 1346 /* Get the value */
1347 switch (xs_widtable[i].itemType) { 1347 switch (xs_widtable[i].itemType) {
1348 case CTYPE_INT: 1348 case CTYPE_INT:
1349 tmpValue = (gfloat) * ((gint *) xs_widtable[i].itemData); 1349 tmpValue = (gfloat) * ((gint *) xs_widtable[i].itemData);
1350 break; 1350 break;
1351 1351
1352 case CTYPE_FLOAT: 1352 case CTYPE_FLOAT:
1353 tmpValue = *((gfloat *) xs_widtable[i].itemData); 1353 tmpValue = *((gfloat *) xs_widtable[i].itemData);
1354 break; 1354 break;
1355 1355
1356 default: 1356 default:
1357 tmpValue = -1; 1357 tmpValue = -1;
1358 assert(0); 1358 assert(0);
1359 break; 1359 break;
1360 } 1360 }
1361 1361
1362 /* Set the value */ 1362 /* Set the value */
1363 switch (xs_widtable[i].widType) { 1363 switch (xs_widtable[i].widType) {
1364 case WTYPE_SPIN: 1364 case WTYPE_SPIN:
1365 gtk_adjustment_set_value(gtk_spin_button_get_adjustment 1365 gtk_adjustment_set_value(gtk_spin_button_get_adjustment
1366 (GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName))), tmpValue); 1366 (GTK_SPIN_BUTTON(LUW(xs_widtable[i].widName))), tmpValue);
1367 break; 1367 break;
1368 1368
1369 case WTYPE_SCALE: 1369 case WTYPE_SCALE:
1370 gtk_adjustment_set_value(gtk_range_get_adjustment 1370 gtk_adjustment_set_value(gtk_range_get_adjustment
1371 (GTK_RANGE(LUW(xs_widtable[i].widName))), tmpValue); 1371 (GTK_RANGE(LUW(xs_widtable[i].widName))), tmpValue);
1372 break; 1372 break;
1373 } 1373 }
1374 break; 1374 break;
1375 1375
1376 case WTYPE_BUTTON: 1376 case WTYPE_BUTTON:
1377 assert(xs_widtable[i].itemType == CTYPE_BOOL); 1377 assert(xs_widtable[i].itemType == CTYPE_BOOL);
1378 /* Set toggle-button */ 1378 /* Set toggle-button */
1379 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)), 1379 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(LUW(xs_widtable[i].widName)),
1380 *((gboolean *) xs_widtable[i].itemData)); 1380 *((gboolean *) xs_widtable[i].itemData));
1381 break; 1381 break;
1382 1382
1383 case WTYPE_TEXT: 1383 case WTYPE_TEXT:
1384 assert(xs_widtable[i].itemType == CTYPE_STR); 1384 assert(xs_widtable[i].itemType == CTYPE_STR);
1385 /* Set text to text-widget */ 1385 /* Set text to text-widget */
1386 if (*(gchar **) xs_widtable[i].itemData != NULL) { 1386 if (*(gchar **) xs_widtable[i].itemData != NULL) {
1387 gtk_entry_set_text(GTK_ENTRY(LUW(xs_widtable[i].widName)), 1387 gtk_entry_set_text(GTK_ENTRY(LUW(xs_widtable[i].widName)),
1388 *(gchar **) xs_widtable[i].itemData); 1388 *(gchar **) xs_widtable[i].itemData);
1389 } 1389 }
1390 break; 1390 break;
1391 } 1391 }
1392 } 1392 }
1393 1393
1394 /* Release the configuration */ 1394 /* Release the configuration */
1395 XS_MUTEX_UNLOCK(xs_cfg); 1395 XS_MUTEX_UNLOCK(xs_cfg);
1396 1396
1397 /* Show the widget */ 1397 /* Show the widget */
1398 gtk_widget_show(xs_configwin); 1398 gtk_widget_show(xs_configwin);
1399 } 1399 }