1 /* this file included as text in snd-g|xprefs.c */
2
int_to_textfield(widget_t w,int val)3 static void int_to_textfield(widget_t w, int val)
4 {
5 char *str;
6 str = (char *)calloc(16, sizeof(char));
7 snprintf(str, 16, "%d", val);
8 SET_TEXT(w, str);
9 free(str);
10 }
11
12
mus_long_t_to_textfield(widget_t w,mus_long_t val)13 static void mus_long_t_to_textfield(widget_t w, mus_long_t val)
14 {
15 char *str;
16 str = (char *)calloc(32, sizeof(char));
17 snprintf(str, 32, "%" print_mus_long, val);
18 SET_TEXT(w, str);
19 free(str);
20 }
21
22
float_to_textfield(widget_t w,mus_float_t val)23 static void float_to_textfield(widget_t w, mus_float_t val)
24 {
25 char *str;
26 str = (char *)calloc(12, sizeof(char));
27 snprintf(str, 12, "%.3f", val);
28 SET_TEXT(w, str);
29 free(str);
30 }
31
32
float_1_to_textfield(widget_t w,mus_float_t val)33 static void float_1_to_textfield(widget_t w, mus_float_t val)
34 {
35 char *str;
36 str = (char *)calloc(12, sizeof(char));
37 snprintf(str, 12, "%.1f", val);
38 SET_TEXT(w, str);
39 free(str);
40 }
41
42
unpost_any_error(TIMEOUT_ARGS)43 static TIMEOUT_TYPE unpost_any_error(TIMEOUT_ARGS)
44 {
45 prefs_info *prf = (prefs_info *)context;
46 prf->got_error = false;
47 black_text(prf);
48 set_label(prf->label, prf->saved_label);
49 if (prf->reflect_func) (*(prf->reflect_func))(prf);
50 TIMEOUT_RESULT
51 }
52
53
any_error_to_text(const char * msg,void * data)54 static void any_error_to_text(const char *msg, void *data)
55 {
56 prefs_info *prf = (prefs_info *)data;
57 prf->got_error = true;
58 red_text(prf);
59 set_label(prf->label, msg);
60 TIMEOUT(unpost_any_error);
61 }
62
63
redirect_post_prefs_error(const char * msg,void * data)64 static void redirect_post_prefs_error(const char *msg, void *data)
65 {
66 post_prefs_error(msg, (prefs_info *)data);
67 }
68
69
70 static int prefs_size = 0, prefs_top = 0;
71 static prefs_info **prefs = NULL;
72
remember_pref(prefs_info * prf,void (* reflect_func)(struct prefs_info * prf),void (* save_func)(struct prefs_info * prf,FILE * fd),const char * (* help_func)(struct prefs_info * prf),void (* clear_func)(struct prefs_info * prf),void (* revert_func)(struct prefs_info * prf))73 static void remember_pref(prefs_info *prf,
74 void (*reflect_func)(struct prefs_info *prf),
75 void (*save_func)(struct prefs_info *prf, FILE *fd),
76 const char *(*help_func)(struct prefs_info *prf),
77 void (*clear_func)(struct prefs_info *prf),
78 void (*revert_func)(struct prefs_info *prf))
79 {
80 if (prefs_size == 0)
81 {
82 prefs_size = 100;
83 prefs = (prefs_info **)calloc(prefs_size, sizeof(prefs_info *));
84 }
85 else
86 {
87 if (prefs_top >= prefs_size)
88 {
89 int i;
90 prefs_size += 100;
91 prefs = (prefs_info **)realloc(prefs, prefs_size * sizeof(prefs_info *));
92 for (i = prefs_top; i < prefs_size; i++) prefs[i] = NULL;
93 }
94 }
95
96 prf->reflect_func = reflect_func;
97 prf->save_func = save_func;
98 prf->help_func = help_func;
99 prf->clear_func = clear_func;
100 prf->revert_func = revert_func;
101 prefs[prefs_top++] = prf;
102
103 if ((help_func) &&
104 (prf->label))
105 {
106 if (prf->var_name)
107 {
108 char *str;
109 str = mus_format("%s\n See %s for more info.", (*help_func)(prf), prf->var_name);
110 add_tooltip(prf->label, str); /* don't free it... */
111 }
112 else add_tooltip(prf->label, (*help_func)(prf));
113 }
114 }
115
116
reflect_prefs(void)117 static void reflect_prefs(void)
118 {
119 int i;
120 for (i = 0; i < prefs_top; i++)
121 {
122 prefs_info *prf;
123 prf = prefs[i];
124 if ((prf) &&
125 (prf->reflect_func))
126 (*(prf->reflect_func))(prf);
127 }
128 }
129
130
revert_prefs(void)131 static void revert_prefs(void)
132 {
133 int i;
134 for (i = 0; i < prefs_top; i++)
135 {
136 prefs_info *prf;
137 prf = prefs[i];
138 if ((prf) &&
139 (prf->revert_func))
140 (*(prf->revert_func))(prf);
141 }
142 }
143
144
clear_prefs(void)145 static void clear_prefs(void)
146 {
147 int i;
148 for (i = 0; i < prefs_top; i++)
149 {
150 prefs_info *prf;
151 prf = prefs[i];
152 if ((prf) &&
153 (prf->clear_func))
154 (*(prf->clear_func))(prf);
155 }
156 }
157
158
preferences_revert_or_clear(bool revert)159 static void preferences_revert_or_clear(bool revert)
160 {
161 clear_prefs_dialog_error();
162 if (revert)
163 revert_prefs();
164 else
165 {
166 snd_set_global_defaults(true);
167 clear_prefs();
168 }
169
170 reflect_prefs();
171 prefs_unsaved = false;
172
173 if (prefs_saved_filename)
174 {
175 char *fullname;
176 fullname = mus_expand_filename(prefs_saved_filename);
177 if (mus_file_probe(fullname))
178 snd_remove(fullname, IGNORE_CACHE);
179 free(prefs_saved_filename);
180 free(fullname);
181 prefs_saved_filename = NULL;
182 }
183 prefs_set_dialog_title(NULL);
184 }
185
186
local_access(char * dir)187 static bool local_access(char *dir)
188 {
189 int err;
190 char *temp;
191 temp = shorter_tempnam(dir, "snd_");
192 err = mus_file_create(temp);
193 if (err != -1)
194 {
195 snd_close(err, temp);
196 snd_remove(temp, IGNORE_CACHE);
197 }
198 free(temp);
199 return(err != -1);
200 }
201
202
is_string_member(const char * val,char ** lst,int len)203 static bool is_string_member(const char *val, char **lst, int len)
204 {
205 int i;
206 if ((len == 0) || (!lst) || (!val)) return(false);
207 for (i = 0; i < len; i++)
208 if (mus_strcmp(val, lst[i]))
209 return(true);
210 return(false);
211 }
212
213
load_path_to_string_array(int * len)214 static char **load_path_to_string_array(int *len)
215 {
216 char **cdirs = NULL;
217 int dir_len = 0, j = 0;
218 Xen dirs;
219
220 dirs = Xen_load_path;
221 dir_len = Xen_list_length(dirs);
222
223 if (dir_len > 0)
224 {
225 int i;
226 cdirs = (char **)calloc(dir_len, sizeof(char *));
227 for (i = 0; i < dir_len; i++)
228 {
229 const char *path;
230 path = Xen_string_to_C_string(Xen_list_ref(dirs, i));
231 if ((path) && (!(is_string_member(path, cdirs, j)))) /* try to remove duplicates */
232 cdirs[j++] = mus_strdup(path);
233 }
234 }
235
236 (*len) = j;
237 return(cdirs);
238 }
239
240
add_local_load_path(FILE * fd,char * path)241 static void add_local_load_path(FILE *fd, char *path)
242 {
243 #if HAVE_RUBY
244 fprintf(fd, "if (not $LOAD_PATH.include?(\"%s\")) then $LOAD_PATH.push(\"%s\") end\n", path, path);
245 #endif
246
247 #if HAVE_FORTH
248 /* this already checks */
249 fprintf(fd, "\"%s\" add-load-path\n", path); /* no drop here */
250 #endif
251
252 #if HAVE_SCHEME
253 fprintf(fd, "(if (not (member \"%s\" *load-path*)) (set! *load-path* (cons \"%s\" *load-path*)))\n", path, path);
254 #endif
255 }
256
257
258 #if HAVE_EXTENSION_LANGUAGE
save_prefs(void)259 static void save_prefs(void)
260 {
261 char *fullname;
262 const char *filename;
263 FILE *fd;
264
265 /* save_options_in_prefs passes us the filename after calling save_options which handles all
266 * the simple cases.
267 */
268
269 filename = save_options_in_prefs();
270 if (!filename) return;
271
272 fullname = mus_expand_filename(filename);
273 fd = FOPEN(fullname, "a");
274
275 if (fd)
276 {
277 char **current_dirs;
278 int i, current_dirs_len = 0;
279
280 fprintf(fd, "\n");
281
282 /* LOAD_PATH has the current load-path list,
283 * GET_TEXT(load_path_text_widget) has the current text (independent of activation)
284 * include_load_path has whatever the last <cr> set it to.
285 *
286 * load_path_to_string_array can turn the LOAD_PATH into a char** array.
287 *
288 * load-path needs to be set even if a later init file adds to it; we need a true
289 * load-path, but this can be called repeatedly, and across executions, so we
290 * don't want to fill up the list with repetitions
291 */
292
293 current_dirs = load_path_to_string_array(¤t_dirs_len);
294 if (current_dirs)
295 for (i = current_dirs_len - 1; i >= 0; i--) /* consing on front, so keep original order of paths */
296 add_local_load_path(fd, current_dirs[i]); /* don't try to be smart about startup paths -- just include everybody */
297
298 if ((include_load_path) &&
299 (!(is_string_member(include_load_path, current_dirs, current_dirs_len))))
300 add_local_load_path(fd, include_load_path);
301
302 if (load_path_text_widget)
303 {
304 char *unchecked_load_path;
305 unchecked_load_path = GET_TEXT(load_path_text_widget);
306 if ((unchecked_load_path) && /* text widget has an entry */
307 (local_access(unchecked_load_path)) && /* it's a legit path */
308 (!(is_string_member(unchecked_load_path, current_dirs, current_dirs_len))) && /* it's not in LOAD_PATH */
309 (!(mus_strcmp(unchecked_load_path, include_load_path)))) /* it's not already included above */
310 add_local_load_path(fd, unchecked_load_path);
311 if (unchecked_load_path) {free_TEXT(unchecked_load_path);}
312 }
313
314 if (current_dirs)
315 {
316 for (i = 0; i < current_dirs_len; i++)
317 if (current_dirs[i]) free(current_dirs[i]);
318 free(current_dirs);
319 current_dirs = NULL;
320 }
321
322 /* now finally the load path is set up, so we can call load if we need to */
323 for (i = 0; i < prefs_top; i++)
324 {
325 prefs_info *prf;
326 prf = prefs[i];
327 if ((prf) &&
328 (prf->save_func))
329 (*(prf->save_func))(prf, fd);
330 }
331 snd_fclose(fd, filename);
332 }
333 else snd_error("can't save preferences: %s %s", filename, snd_io_strerror());
334 free(fullname);
335 prefs_unsaved = false;
336 prefs_set_dialog_title(filename);
337 }
338 #endif
339
340
trim_string(const char * str)341 static char *trim_string(const char *str)
342 {
343 int i = 0, len, j = 0, k, m;
344 char *trimmed_str;
345 len = strlen(str);
346 trimmed_str = (char *)calloc(len + 1, sizeof(char));
347 while ((i < len) && (isspace((int)str[i]))) i++;
348 k = len - 1;
349 while ((k > i) && (isspace((int)str[k]))) k--;
350 for (m = i; m <= k; m++)
351 trimmed_str[j++] = str[m];
352 return(trimmed_str);
353 }
354
355
356 static char key_buf[16];
357
possibly_quote(char * key)358 static char *possibly_quote(char *key)
359 {
360 int i, j, len;
361 len = mus_strlen(key);
362 if (len > 12) len = 12;
363 for (i = 0, j = 0; i < len; i++)
364 if (!(isspace((int)key[i])))
365 {
366 if ((j == 0) && (isalpha((int)key[i])))
367 key_buf[j++] = '\"';
368 key_buf[j++] = key[i];
369 }
370 if ((key_buf[0] == '\"') && (key_buf[j - 1] != '\"'))
371 key_buf[j++] = '\"';
372 key_buf[j++] = '\0';
373 #if 0
374 fprintf(stderr,"return key %s\n", key_buf);
375 #endif
376 return(key_buf);
377 }
378
379
380 /* ---------------- auto-resize ---------------- */
381
382 static bool rts_auto_resize = DEFAULT_AUTO_RESIZE;
reflect_auto_resize(prefs_info * prf)383 static void reflect_auto_resize(prefs_info *prf) {SET_TOGGLE(prf->toggle, auto_resize(ss));}
resize_toggle(prefs_info * prf)384 static void resize_toggle(prefs_info *prf) {set_auto_resize(GET_TOGGLE(prf->toggle));}
revert_auto_resize(prefs_info * prf)385 static void revert_auto_resize(prefs_info *prf) {set_auto_resize(rts_auto_resize);}
save_auto_resize(prefs_info * prf,FILE * ignore)386 static void save_auto_resize(prefs_info *prf, FILE *ignore) {rts_auto_resize = auto_resize(ss);}
387
help_auto_resize(prefs_info * prf)388 static const char *help_auto_resize(prefs_info *prf)
389 {
390 return("\
391 If this option is set, Snd's main window \n\
392 changes size as sounds come and go. ");
393 }
394
395
396
397 /* ---------------- ask-before-overwrite ---------------- */
398
399 static bool rts_ask_before_overwrite = DEFAULT_ASK_BEFORE_OVERWRITE;
reflect_ask_before_overwrite(prefs_info * prf)400 static void reflect_ask_before_overwrite(prefs_info *prf) {SET_TOGGLE(prf->toggle, ask_before_overwrite(ss));}
overwrite_toggle(prefs_info * prf)401 static void overwrite_toggle(prefs_info *prf) {set_ask_before_overwrite(GET_TOGGLE(prf->toggle));}
revert_ask_before_overwrite(prefs_info * prf)402 static void revert_ask_before_overwrite(prefs_info *prf) {set_ask_before_overwrite(rts_ask_before_overwrite);}
save_ask_before_overwrite(prefs_info * prf,FILE * ignore)403 static void save_ask_before_overwrite(prefs_info *prf, FILE *ignore) {rts_ask_before_overwrite = ask_before_overwrite(ss);}
404
help_ask_before_overwrite(prefs_info * prf)405 static const char *help_ask_before_overwrite(prefs_info *prf)
406 {
407 return("\
408 If this option is set, Snd will ask you before \n\
409 it overwrites an existing sound. ");
410 }
411
412
413
414 /* ---------------- show-controls ---------------- */
415
416 static bool rts_show_controls = DEFAULT_SHOW_CONTROLS;
reflect_show_controls(prefs_info * prf)417 static void reflect_show_controls(prefs_info *prf) {SET_TOGGLE(prf->toggle, in_show_controls(ss));}
controls_toggle(prefs_info * prf)418 static void controls_toggle(prefs_info *prf) {set_show_controls(GET_TOGGLE(prf->toggle));}
revert_show_controls(prefs_info * prf)419 static void revert_show_controls(prefs_info *prf) {set_show_controls(rts_show_controls);}
save_show_controls(prefs_info * prf,FILE * ignore)420 static void save_show_controls(prefs_info *prf, FILE *ignore) {rts_show_controls = in_show_controls(ss);}
421
422
423 /* ---------------- just-sounds ---------------- */
424
425 static bool rts_just_sounds = DEFAULT_JUST_SOUNDS;
prefs_reflect_just_sounds(prefs_info * prf)426 static void prefs_reflect_just_sounds(prefs_info *prf) {SET_TOGGLE(prf->toggle, just_sounds(ss));}
just_sounds_toggle(prefs_info * prf)427 static void just_sounds_toggle(prefs_info *prf) {set_just_sounds(GET_TOGGLE(prf->toggle));}
revert_just_sounds(prefs_info * prf)428 static void revert_just_sounds(prefs_info *prf) {set_just_sounds(rts_just_sounds);}
save_just_sounds(prefs_info * prf,FILE * ignore)429 static void save_just_sounds(prefs_info *prf, FILE *ignore) {rts_just_sounds = just_sounds(ss);}
430
431
432 /* ---------------- verbose-cursor ---------------- */
433
434 static bool rts_with_verbose_cursor = DEFAULT_WITH_VERBOSE_CURSOR;
reflect_with_verbose_cursor(prefs_info * prf)435 static void reflect_with_verbose_cursor(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_verbose_cursor(ss));}
with_verbose_cursor_toggle(prefs_info * prf)436 static void with_verbose_cursor_toggle(prefs_info *prf) {set_with_verbose_cursor(GET_TOGGLE(prf->toggle));}
revert_with_verbose_cursor(prefs_info * prf)437 static void revert_with_verbose_cursor(prefs_info *prf) {set_with_verbose_cursor(rts_with_verbose_cursor);}
save_with_verbose_cursor(prefs_info * prf,FILE * ignore)438 static void save_with_verbose_cursor(prefs_info *prf, FILE *ignore) {rts_with_verbose_cursor = with_verbose_cursor(ss);}
439
440
441 /* ---------------- graphs-horizontal ---------------- */
442
443 static bool rts_graphs_horizontal = DEFAULT_GRAPHS_HORIZONTAL;
reflect_graphs_horizontal(prefs_info * prf)444 static void reflect_graphs_horizontal(prefs_info *prf) {SET_TOGGLE(prf->toggle, graphs_horizontal(ss));}
graphs_horizontal_toggle(prefs_info * prf)445 static void graphs_horizontal_toggle(prefs_info *prf) {in_set_graphs_horizontal(GET_TOGGLE(prf->toggle));}
revert_graphs_horizontal(prefs_info * prf)446 static void revert_graphs_horizontal(prefs_info *prf) {in_set_graphs_horizontal(rts_graphs_horizontal);}
save_graphs_horizontal(prefs_info * prf,FILE * ignore)447 static void save_graphs_horizontal(prefs_info *prf, FILE *ignore) {rts_graphs_horizontal = graphs_horizontal(ss);}
448
449
450 /* ---------------- show-y-zero ---------------- */
451
452 static bool rts_show_y_zero = DEFAULT_SHOW_Y_ZERO;
reflect_show_y_zero(prefs_info * prf)453 static void reflect_show_y_zero(prefs_info *prf) {SET_TOGGLE(prf->toggle, show_y_zero(ss));}
y_zero_toggle(prefs_info * prf)454 static void y_zero_toggle(prefs_info *prf) {set_show_y_zero(GET_TOGGLE(prf->toggle));}
revert_show_y_zero(prefs_info * prf)455 static void revert_show_y_zero(prefs_info *prf) {set_show_y_zero(rts_show_y_zero);}
save_show_y_zero(prefs_info * prf,FILE * ignore)456 static void save_show_y_zero(prefs_info *prf, FILE *ignore) {rts_show_y_zero = show_y_zero(ss);}
457
458
459 /* ---------------- show-grid ---------------- */
460
461 static with_grid_t rts_show_grid = DEFAULT_SHOW_GRID;
reflect_show_grid(prefs_info * prf)462 static void reflect_show_grid(prefs_info *prf) {SET_TOGGLE(prf->toggle, show_grid(ss) == WITH_GRID);}
grid_toggle(prefs_info * prf)463 static void grid_toggle(prefs_info *prf) {set_show_grid(((GET_TOGGLE(prf->toggle)) ? WITH_GRID : NO_GRID));}
revert_show_grid(prefs_info * prf)464 static void revert_show_grid(prefs_info *prf) {set_show_grid(rts_show_grid);}
save_show_grid(prefs_info * prf,FILE * ignore)465 static void save_show_grid(prefs_info *prf, FILE *ignore) {rts_show_grid = show_grid(ss);}
466
467
468 /* ---------------- fft-log-magnitude ---------------- */
469
470 static bool rts_fft_log_magnitude = DEFAULT_FFT_LOG_MAGNITUDE;
reflect_fft_log_magnitude(prefs_info * prf)471 static void reflect_fft_log_magnitude(prefs_info *prf) {SET_TOGGLE(prf->toggle, fft_log_magnitude(ss));}
log_magnitude_toggle(prefs_info * prf)472 static void log_magnitude_toggle(prefs_info *prf) {set_fft_log_magnitude(GET_TOGGLE(prf->toggle));}
revert_fft_log_magnitude(prefs_info * prf)473 static void revert_fft_log_magnitude(prefs_info *prf) {set_fft_log_magnitude(rts_fft_log_magnitude);}
save_fft_log_magnitude(prefs_info * prf,FILE * ignore)474 static void save_fft_log_magnitude(prefs_info *prf, FILE *ignore) {rts_fft_log_magnitude = fft_log_magnitude(ss);}
475
476
477 /* ---------------- fft-log-frequency ---------------- */
478
479 static bool rts_fft_log_frequency = DEFAULT_FFT_LOG_FREQUENCY;
reflect_fft_log_frequency(prefs_info * prf)480 static void reflect_fft_log_frequency(prefs_info *prf) {SET_TOGGLE(prf->toggle, fft_log_frequency(ss));}
log_frequency_toggle(prefs_info * prf)481 static void log_frequency_toggle(prefs_info *prf) {set_fft_log_frequency(GET_TOGGLE(prf->toggle));}
revert_fft_log_frequency(prefs_info * prf)482 static void revert_fft_log_frequency(prefs_info *prf) {set_fft_log_frequency(rts_fft_log_frequency);}
save_fft_log_frequency(prefs_info * prf,FILE * ignore)483 static void save_fft_log_frequency(prefs_info *prf, FILE *ignore) {rts_fft_log_frequency = fft_log_frequency(ss);}
484
485
486 /* ---------------- dac-combines-channels ---------------- */
487
488 static bool rts_dac_combines_channels = DEFAULT_DAC_COMBINES_CHANNELS;
reflect_dac_combines_channels(prefs_info * prf)489 static void reflect_dac_combines_channels(prefs_info *prf) {SET_TOGGLE(prf->toggle, dac_combines_channels(ss));}
dac_combines_channels_toggle(prefs_info * prf)490 static void dac_combines_channels_toggle(prefs_info *prf) {set_dac_combines_channels(GET_TOGGLE(prf->toggle));}
revert_dac_combines_channels(prefs_info * prf)491 static void revert_dac_combines_channels(prefs_info *prf) {set_dac_combines_channels(rts_dac_combines_channels);}
save_dac_combines_channels(prefs_info * prf,FILE * ignore)492 static void save_dac_combines_channels(prefs_info *prf, FILE *ignore) {rts_dac_combines_channels = dac_combines_channels(ss);}
493
494
495 /* ---------------- show-listener ---------------- */
496
497 static bool rts_show_listener = false, prefs_show_listener = false;
498
reflect_show_listener(prefs_info * prf)499 static void reflect_show_listener(prefs_info *prf)
500 {
501 prefs_show_listener = listener_is_visible();
502 SET_TOGGLE(prf->toggle, prefs_show_listener);
503 }
504
505
show_listener_toggle(prefs_info * prf)506 static void show_listener_toggle(prefs_info *prf)
507 {
508 prefs_show_listener = GET_TOGGLE(prf->toggle);
509 handle_listener(prefs_show_listener);
510 }
511
512
save_show_listener(prefs_info * prf,FILE * fd)513 static void save_show_listener(prefs_info *prf, FILE *fd)
514 {
515 rts_show_listener = prefs_show_listener;
516 }
517
518
revert_show_listener(prefs_info * prf)519 static void revert_show_listener(prefs_info *prf)
520 {
521 prefs_show_listener = rts_show_listener;
522 handle_listener(rts_show_listener);
523 }
524
525
clear_show_listener(prefs_info * prf)526 static void clear_show_listener(prefs_info *prf)
527 {
528 prefs_show_listener = false;
529 handle_listener(false);
530 }
531
532
533
534 /* ---------------- basic-color ---------------- */
535
536 /* we need the original color (Clear), the last saved color (Revert)
537 * the colors are updated continuously, so the current color variable (and the reflection func) is irrelevant
538 * so:
539 * set original in snd-gxmain or somewhere
540 * set rts in prefs dialog startup
541 * reflect_color: a no-op
542 * save_color: save current color_t value in rts value (actual fd output dealt with elsewhere)
543 * clear_color: set to original (leave rts value alone)
544 * revert_color: set to rts (leave original alone)
545 * help_color: built-in via color variable name
546 * color_func: set color based on rgb values
547 */
548
549 static color_t saved_basic_color;
save_basic_color(prefs_info * prf,FILE * ignore)550 static void save_basic_color(prefs_info *prf, FILE *ignore) {saved_basic_color = ss->basic_color;}
basic_color_func(prefs_info * prf,double r,double g,double b)551 static void basic_color_func(prefs_info *prf, double r, double g, double b) {set_basic_color(rgb_to_color(r, g, b));}
552
553
revert_basic_color(prefs_info * prf)554 static void revert_basic_color(prefs_info *prf)
555 {
556 scale_set_color(prf, saved_basic_color);
557 set_basic_color(saved_basic_color);
558 }
559
560
clear_basic_color(prefs_info * prf)561 static void clear_basic_color(prefs_info *prf)
562 {
563 scale_set_color(prf, ss->basic_color);
564 set_basic_color(ss->orig_basic_color);
565 }
566
567
568
569 /* ---------------- highlight-color ---------------- */
570
571 static color_t saved_highlight_color;
save_highlight_color(prefs_info * prf,FILE * ignore)572 static void save_highlight_color(prefs_info *prf, FILE *ignore) {saved_highlight_color = ss->highlight_color;}
highlight_color_func(prefs_info * prf,double r,double g,double b)573 static void highlight_color_func(prefs_info *prf, double r, double g, double b) {set_highlight_color(rgb_to_color(r, g, b));}
574
575
revert_highlight_color(prefs_info * prf)576 static void revert_highlight_color(prefs_info *prf)
577 {
578 scale_set_color(prf, saved_highlight_color);
579 set_highlight_color(saved_highlight_color);
580 }
581
582
clear_highlight_color(prefs_info * prf)583 static void clear_highlight_color(prefs_info *prf)
584 {
585 scale_set_color(prf, ss->orig_highlight_color);
586 set_highlight_color(ss->orig_highlight_color);
587 }
588
589
590
591 /* ---------------- position-color ---------------- */
592
593 static color_t saved_position_color;
save_position_color(prefs_info * prf,FILE * ignore)594 static void save_position_color(prefs_info *prf, FILE *ignore) {saved_position_color = ss->position_color;}
position_color_func(prefs_info * prf,double r,double g,double b)595 static void position_color_func(prefs_info *prf, double r, double g, double b) {set_position_color(rgb_to_color(r, g, b));}
596
597
revert_position_color(prefs_info * prf)598 static void revert_position_color(prefs_info *prf)
599 {
600 scale_set_color(prf, saved_position_color);
601 set_position_color(saved_position_color);
602 }
603
604
clear_position_color(prefs_info * prf)605 static void clear_position_color(prefs_info *prf)
606 {
607 scale_set_color(prf, ss->orig_position_color);
608 set_position_color(ss->orig_position_color);
609 }
610
611
612
613 /* ---------------- zoom-color ---------------- */
614
615 static color_t saved_zoom_color;
save_zoom_color(prefs_info * prf,FILE * ignore)616 static void save_zoom_color(prefs_info *prf, FILE *ignore) {saved_zoom_color = ss->zoom_color;}
zoom_color_func(prefs_info * prf,double r,double g,double b)617 static void zoom_color_func(prefs_info *prf, double r, double g, double b) {set_zoom_color(rgb_to_color(r, g, b));}
618
619
revert_zoom_color(prefs_info * prf)620 static void revert_zoom_color(prefs_info *prf)
621 {
622 scale_set_color(prf, saved_zoom_color);
623 set_zoom_color(saved_zoom_color);
624 }
625
626
clear_zoom_color(prefs_info * prf)627 static void clear_zoom_color(prefs_info *prf)
628 {
629 scale_set_color(prf, ss->orig_zoom_color);
630 set_zoom_color(ss->orig_zoom_color);
631 }
632
633
634
635 /* ---------------- cursor-color ---------------- */
636
637 static color_t saved_cursor_color;
save_cursor_color(prefs_info * prf,FILE * ignore)638 static void save_cursor_color(prefs_info *prf, FILE *ignore) {saved_cursor_color = ss->cursor_color;}
639
cursor_color_func(prefs_info * prf,double r,double g,double b)640 static void cursor_color_func(prefs_info *prf, double r, double g, double b)
641 {
642 color_cursor(rgb_to_color(r, g, b));
643 for_each_chan(update_graph);
644 }
645
646
revert_cursor_color(prefs_info * prf)647 static void revert_cursor_color(prefs_info *prf)
648 {
649 scale_set_color(prf, saved_cursor_color);
650 color_cursor(saved_cursor_color);
651 }
652
653
clear_cursor_color(prefs_info * prf)654 static void clear_cursor_color(prefs_info *prf)
655 {
656 scale_set_color(prf, ss->orig_cursor_color);
657 color_cursor(ss->orig_cursor_color);
658 }
659
660
661
662 /* ---------------- data-color ---------------- */
663
664 static color_t saved_data_color;
save_data_color(prefs_info * prf,FILE * ignore)665 static void save_data_color(prefs_info *prf, FILE *ignore) {saved_data_color = ss->data_color;}
data_color_func(prefs_info * prf,double r,double g,double b)666 static void data_color_func(prefs_info *prf, double r, double g, double b) {set_data_color(rgb_to_color(r, g, b));}
667
668
revert_data_color(prefs_info * prf)669 static void revert_data_color(prefs_info *prf)
670 {
671 scale_set_color(prf, saved_data_color);
672 set_data_color(saved_data_color);
673 }
674
675
clear_data_color(prefs_info * prf)676 static void clear_data_color(prefs_info *prf)
677 {
678 scale_set_color(prf, ss->orig_data_color);
679 set_data_color(ss->orig_data_color);
680 }
681
682
683
684 /* ---------------- graph-color ---------------- */
685
686 static color_t saved_graph_color;
save_graph_color(prefs_info * prf,FILE * ignore)687 static void save_graph_color(prefs_info *prf, FILE *ignore) {saved_graph_color = ss->graph_color;}
graph_color_func(prefs_info * prf,double r,double g,double b)688 static void graph_color_func(prefs_info *prf, double r, double g, double b) {set_graph_color(rgb_to_color(r, g, b));}
689
690
revert_graph_color(prefs_info * prf)691 static void revert_graph_color(prefs_info *prf)
692 {
693 scale_set_color(prf, saved_graph_color);
694 set_graph_color(saved_graph_color);
695 }
696
697
clear_graph_color(prefs_info * prf)698 static void clear_graph_color(prefs_info *prf)
699 {
700 scale_set_color(prf, ss->orig_graph_color);
701 set_graph_color(ss->orig_graph_color);
702 }
703
704
705
706 /* ---------------- selected-data-color ---------------- */
707
708 static color_t saved_selected_data_color;
save_selected_data_color(prefs_info * prf,FILE * ignore)709 static void save_selected_data_color(prefs_info *prf, FILE *ignore) {saved_selected_data_color = ss->selected_data_color;}
selected_data_color_func(prefs_info * prf,double r,double g,double b)710 static void selected_data_color_func(prefs_info *prf, double r, double g, double b) {set_selected_data_color(rgb_to_color(r, g, b));}
711
712
revert_selected_data_color(prefs_info * prf)713 static void revert_selected_data_color(prefs_info *prf)
714 {
715 scale_set_color(prf, saved_selected_data_color);
716 set_selected_data_color(saved_selected_data_color);
717 }
718
719
clear_selected_data_color(prefs_info * prf)720 static void clear_selected_data_color(prefs_info *prf)
721 {
722 scale_set_color(prf, ss->orig_selected_data_color);
723 set_selected_data_color(ss->orig_selected_data_color);
724 }
725
726
727
728 /* ---------------- selected-graph-color ---------------- */
729
730 static color_t saved_selected_graph_color;
save_selected_graph_color(prefs_info * prf,FILE * ignore)731 static void save_selected_graph_color(prefs_info *prf, FILE *ignore) {saved_selected_graph_color = ss->selected_graph_color;}
selected_graph_color_func(prefs_info * prf,double r,double g,double b)732 static void selected_graph_color_func(prefs_info *prf, double r, double g, double b) {set_selected_graph_color(rgb_to_color(r, g, b));}
733
734
revert_selected_graph_color(prefs_info * prf)735 static void revert_selected_graph_color(prefs_info *prf)
736 {
737 scale_set_color(prf, saved_selected_graph_color);
738 set_selected_graph_color(saved_selected_graph_color);
739 }
740
741
clear_selected_graph_color(prefs_info * prf)742 static void clear_selected_graph_color(prefs_info *prf)
743 {
744 scale_set_color(prf, ss->orig_selected_graph_color);
745 set_selected_graph_color(ss->orig_selected_graph_color);
746 }
747
748
749
750 /* ---------------- selection-color ---------------- */
751
set_selection_color(color_t color)752 static void set_selection_color(color_t color)
753 {
754 color_selection(color);
755 for_each_chan(update_graph);
756 }
757
758
759 static color_t saved_selection_color;
save_selection_color(prefs_info * prf,FILE * ignore)760 static void save_selection_color(prefs_info *prf, FILE *ignore) {saved_selection_color = ss->selection_color;}
selection_color_func(prefs_info * prf,double r,double g,double b)761 static void selection_color_func(prefs_info *prf, double r, double g, double b) {set_selection_color(rgb_to_color(r, g, b));}
762
763
revert_selection_color(prefs_info * prf)764 static void revert_selection_color(prefs_info *prf)
765 {
766 scale_set_color(prf, saved_selection_color);
767 set_selection_color(saved_selection_color);
768 }
769
770
clear_selection_color(prefs_info * prf)771 static void clear_selection_color(prefs_info *prf)
772 {
773 scale_set_color(prf, ss->orig_selection_color);
774 set_selection_color(ss->orig_selection_color);
775 }
776
777
778
779 /* ---------------- mark-color ---------------- */
780
781 static color_t saved_mark_color;
save_mark_color(prefs_info * prf,FILE * ignore)782 static void save_mark_color(prefs_info *prf, FILE *ignore) {saved_mark_color = ss->mark_color;}
mark_color_func(prefs_info * prf,double r,double g,double b)783 static void mark_color_func(prefs_info *prf, double r, double g, double b) {color_marks(rgb_to_color(r, g, b));}
784
785
revert_mark_color(prefs_info * prf)786 static void revert_mark_color(prefs_info *prf)
787 {
788 scale_set_color(prf, saved_mark_color);
789 color_marks(saved_mark_color);
790 }
791
792
clear_mark_color(prefs_info * prf)793 static void clear_mark_color(prefs_info *prf)
794 {
795 scale_set_color(prf, ss->orig_mark_color);
796 color_marks(ss->orig_mark_color);
797 }
798
799
800
801 /* ---------------- mix-color (waveform) ---------------- */
802
803 static color_t saved_mix_color;
save_mix_color(prefs_info * prf,FILE * ignore)804 static void save_mix_color(prefs_info *prf, FILE *ignore) {saved_mix_color = ss->mix_color;}
mix_color_func(prefs_info * prf,double r,double g,double b)805 static void mix_color_func(prefs_info *prf, double r, double g, double b) {color_mixes(rgb_to_color(r, g, b));}
806
807
revert_mix_color(prefs_info * prf)808 static void revert_mix_color(prefs_info *prf)
809 {
810 scale_set_color(prf, saved_mix_color);
811 color_mixes(saved_mix_color);
812 }
813
814
clear_mix_color(prefs_info * prf)815 static void clear_mix_color(prefs_info *prf)
816 {
817 scale_set_color(prf, ss->orig_mix_color);
818 color_mixes(ss->orig_mix_color);
819 }
820
821
822
823 /* ---------------- listener-color ---------------- */
824
825 static color_t saved_listener_color;
save_listener_color(prefs_info * prf,FILE * ignore)826 static void save_listener_color(prefs_info *prf, FILE *ignore) {saved_listener_color = ss->listener_color;}
listener_color_func(prefs_info * prf,double r,double g,double b)827 static void listener_color_func(prefs_info *prf, double r, double g, double b) {color_listener(rgb_to_color(r, g, b));}
828
829
revert_listener_color(prefs_info * prf)830 static void revert_listener_color(prefs_info *prf)
831 {
832 scale_set_color(prf, saved_listener_color);
833 color_listener(saved_listener_color);
834 }
835
836
clear_listener_color(prefs_info * prf)837 static void clear_listener_color(prefs_info *prf)
838 {
839 scale_set_color(prf, ss->orig_listener_color);
840 color_listener(ss->orig_listener_color);
841 }
842
843
844
845 /* ---------------- listener-text-color ---------------- */
846
847 static color_t saved_listener_text_color;
save_listener_text_color(prefs_info * prf,FILE * ignore)848 static void save_listener_text_color(prefs_info *prf, FILE *ignore) {saved_listener_text_color = ss->listener_text_color;}
listener_text_color_func(prefs_info * prf,double r,double g,double b)849 static void listener_text_color_func(prefs_info *prf, double r, double g, double b) {color_listener_text(rgb_to_color(r, g, b));}
850
851
revert_listener_text_color(prefs_info * prf)852 static void revert_listener_text_color(prefs_info *prf)
853 {
854 scale_set_color(prf, saved_listener_text_color);
855 color_listener_text(saved_listener_text_color);
856 }
857
858
clear_listener_text_color(prefs_info * prf)859 static void clear_listener_text_color(prefs_info *prf)
860 {
861 scale_set_color(prf, ss->orig_listener_text_color);
862 color_listener_text(ss->orig_listener_text_color);
863 }
864
865
866
867 /* ---------------- axis-label-font ---------------- */
868
869 static char *rts_axis_label_font = NULL;
870
axis_label_font_error_erase_func(TIMEOUT_ARGS)871 static TIMEOUT_TYPE axis_label_font_error_erase_func(TIMEOUT_ARGS)
872 {
873 prefs_info *prf = (prefs_info *)context;
874 SET_TEXT(prf->text, axis_label_font(ss));
875 TIMEOUT_RESULT
876 }
877
878
save_axis_label_font(prefs_info * prf,FILE * ignore)879 static void save_axis_label_font(prefs_info *prf, FILE *ignore)
880 {
881 if (rts_axis_label_font) free(rts_axis_label_font);
882 rts_axis_label_font = mus_strdup(axis_label_font(ss));
883 }
884
885
reflect_axis_label_font(prefs_info * prf)886 static void reflect_axis_label_font(prefs_info *prf) {SET_TEXT(prf->text, axis_label_font(ss));}
revert_axis_label_font(prefs_info * prf)887 static void revert_axis_label_font(prefs_info *prf) {set_axis_label_font(rts_axis_label_font);}
clear_axis_label_font(prefs_info * prf)888 static void clear_axis_label_font(prefs_info *prf) {set_axis_label_font(ss->orig_axis_label_font);}
889
890
axis_label_font_text(prefs_info * prf)891 static void axis_label_font_text(prefs_info *prf)
892 {
893 char *str;
894 str = GET_TEXT(prf->text);
895 if ((!str) || (!(*str)))
896 {
897 SET_TEXT(prf->text, axis_label_font(ss));
898 return;
899 }
900 if (!(set_axis_label_font(str)))
901 {
902 SET_TEXT(prf->text, "can't find that font");
903 TIMEOUT(axis_label_font_error_erase_func);
904 }
905 if (str) {free_TEXT(str);}
906 }
907
908
909
910 /* ---------------- axis-numbers-font ---------------- */
911
912 static char *rts_axis_numbers_font = NULL;
913
axis_numbers_font_error_erase_func(TIMEOUT_ARGS)914 static TIMEOUT_TYPE axis_numbers_font_error_erase_func(TIMEOUT_ARGS)
915 {
916 prefs_info *prf = (prefs_info *)context;
917 SET_TEXT(prf->text, axis_numbers_font(ss));
918 TIMEOUT_RESULT
919 }
920
921
save_axis_numbers_font(prefs_info * prf,FILE * ignore)922 static void save_axis_numbers_font(prefs_info *prf, FILE *ignore)
923 {
924 if (rts_axis_numbers_font) free(rts_axis_numbers_font);
925 rts_axis_numbers_font = mus_strdup(axis_numbers_font(ss));
926 }
927
928
reflect_axis_numbers_font(prefs_info * prf)929 static void reflect_axis_numbers_font(prefs_info *prf) {SET_TEXT(prf->text, axis_numbers_font(ss));}
revert_axis_numbers_font(prefs_info * prf)930 static void revert_axis_numbers_font(prefs_info *prf) {set_axis_numbers_font(rts_axis_numbers_font);}
clear_axis_numbers_font(prefs_info * prf)931 static void clear_axis_numbers_font(prefs_info *prf) {set_axis_numbers_font(ss->orig_axis_numbers_font);}
932
933
axis_numbers_font_text(prefs_info * prf)934 static void axis_numbers_font_text(prefs_info *prf)
935 {
936 char *str;
937 str = GET_TEXT(prf->text);
938 if ((!str) || (!(*str)))
939 {
940 SET_TEXT(prf->text, axis_numbers_font(ss));
941 return;
942 }
943 if (!(set_axis_numbers_font(str)))
944 {
945 SET_TEXT(prf->text, "can't find that font");
946 TIMEOUT(axis_numbers_font_error_erase_func);
947 }
948 if (str) {free_TEXT(str);}
949 }
950
951
952
953 /* ---------------- peaks-font ---------------- */
954
955 static char *rts_peaks_font = NULL;
956
peaks_font_error_erase_func(TIMEOUT_ARGS)957 static TIMEOUT_TYPE peaks_font_error_erase_func(TIMEOUT_ARGS)
958 {
959 prefs_info *prf = (prefs_info *)context;
960 SET_TEXT(prf->text, peaks_font(ss));
961 TIMEOUT_RESULT
962 }
963
964
save_peaks_font(prefs_info * prf,FILE * ignore)965 static void save_peaks_font(prefs_info *prf, FILE *ignore)
966 {
967 if (rts_peaks_font) free(rts_peaks_font);
968 rts_peaks_font = mus_strdup(peaks_font(ss));
969 }
970
971
reflect_peaks_font(prefs_info * prf)972 static void reflect_peaks_font(prefs_info *prf) {SET_TEXT(prf->text, peaks_font(ss));}
revert_peaks_font(prefs_info * prf)973 static void revert_peaks_font(prefs_info *prf) {set_peaks_font(rts_peaks_font);}
clear_peaks_font(prefs_info * prf)974 static void clear_peaks_font(prefs_info *prf) {set_peaks_font(ss->orig_peaks_font);}
975
976
peaks_font_text(prefs_info * prf)977 static void peaks_font_text(prefs_info *prf)
978 {
979 char *str;
980 str = GET_TEXT(prf->text);
981 if ((!str) || (!(*str)))
982 {
983 SET_TEXT(prf->text, peaks_font(ss));
984 return;
985 }
986 if (!(set_peaks_font(str)))
987 {
988 SET_TEXT(prf->text, "can't find that font");
989 TIMEOUT(peaks_font_error_erase_func);
990 }
991 if (str) {free_TEXT(str);}
992 }
993
994
995
996 /* ---------------- bold-peaks-font ---------------- */
997
998 static char *rts_bold_peaks_font = NULL;
999
bold_peaks_font_error_erase_func(TIMEOUT_ARGS)1000 static TIMEOUT_TYPE bold_peaks_font_error_erase_func(TIMEOUT_ARGS)
1001 {
1002 prefs_info *prf = (prefs_info *)context;
1003 SET_TEXT(prf->text, bold_peaks_font(ss));
1004 TIMEOUT_RESULT
1005 }
1006
1007
save_bold_peaks_font(prefs_info * prf,FILE * ignore)1008 static void save_bold_peaks_font(prefs_info *prf, FILE *ignore)
1009 {
1010 if (rts_bold_peaks_font) free(rts_bold_peaks_font);
1011 rts_bold_peaks_font = mus_strdup(bold_peaks_font(ss));
1012 }
1013
1014
reflect_bold_peaks_font(prefs_info * prf)1015 static void reflect_bold_peaks_font(prefs_info *prf) {SET_TEXT(prf->text, bold_peaks_font(ss));}
revert_bold_peaks_font(prefs_info * prf)1016 static void revert_bold_peaks_font(prefs_info *prf) {set_bold_peaks_font(rts_bold_peaks_font);}
clear_bold_peaks_font(prefs_info * prf)1017 static void clear_bold_peaks_font(prefs_info *prf) {set_bold_peaks_font(ss->orig_bold_peaks_font);}
1018
1019
bold_peaks_font_text(prefs_info * prf)1020 static void bold_peaks_font_text(prefs_info *prf)
1021 {
1022 char *str;
1023 str = GET_TEXT(prf->text);
1024 if ((!str) || (!(*str)))
1025 {
1026 SET_TEXT(prf->text, bold_peaks_font(ss));
1027 return;
1028 }
1029 if (!(set_bold_peaks_font(str)))
1030 {
1031 SET_TEXT(prf->text, "can't find that font");
1032 TIMEOUT(bold_peaks_font_error_erase_func);
1033 }
1034 if (str) {free_TEXT(str);}
1035 }
1036
1037
1038
1039 /* ---------------- tiny-font ---------------- */
1040
1041 static char *rts_tiny_font = NULL;
1042
tiny_font_error_erase_func(TIMEOUT_ARGS)1043 static TIMEOUT_TYPE tiny_font_error_erase_func(TIMEOUT_ARGS)
1044 {
1045 prefs_info *prf = (prefs_info *)context;
1046 SET_TEXT(prf->text, tiny_font(ss));
1047 TIMEOUT_RESULT
1048 }
1049
1050
save_tiny_font(prefs_info * prf,FILE * ignore)1051 static void save_tiny_font(prefs_info *prf, FILE *ignore)
1052 {
1053 if (rts_tiny_font) free(rts_tiny_font);
1054 rts_tiny_font = mus_strdup(tiny_font(ss));
1055 }
1056
1057
reflect_tiny_font(prefs_info * prf)1058 static void reflect_tiny_font(prefs_info *prf) {SET_TEXT(prf->text, tiny_font(ss));}
revert_tiny_font(prefs_info * prf)1059 static void revert_tiny_font(prefs_info *prf) {set_tiny_font(rts_tiny_font);}
clear_tiny_font(prefs_info * prf)1060 static void clear_tiny_font(prefs_info *prf) {set_tiny_font(ss->orig_tiny_font);}
1061
1062
tiny_font_text(prefs_info * prf)1063 static void tiny_font_text(prefs_info *prf)
1064 {
1065 char *str;
1066 str = GET_TEXT(prf->text);
1067 if ((!str) || (!(*str)))
1068 {
1069 SET_TEXT(prf->text, tiny_font(ss));
1070 return;
1071 }
1072 if (!(set_tiny_font(str)))
1073 {
1074 SET_TEXT(prf->text, "can't find that font");
1075 TIMEOUT(tiny_font_error_erase_func);
1076 }
1077 if (str) {free_TEXT(str);}
1078 }
1079
1080
1081
1082 /* ---------------- listener-font ---------------- */
1083
1084 static char *rts_listener_font = NULL;
1085
listener_font_error_erase_func(TIMEOUT_ARGS)1086 static TIMEOUT_TYPE listener_font_error_erase_func(TIMEOUT_ARGS)
1087 {
1088 prefs_info *prf = (prefs_info *)context;
1089 SET_TEXT(prf->text, listener_font(ss));
1090 TIMEOUT_RESULT
1091 }
1092
1093
save_listener_font(prefs_info * prf,FILE * ignore)1094 static void save_listener_font(prefs_info *prf, FILE *ignore)
1095 {
1096 if (rts_listener_font) free(rts_listener_font);
1097 rts_listener_font = mus_strdup(listener_font(ss));
1098 }
1099
1100
reflect_listener_font(prefs_info * prf)1101 static void reflect_listener_font(prefs_info *prf) {SET_TEXT(prf->text, listener_font(ss));}
revert_listener_font(prefs_info * prf)1102 static void revert_listener_font(prefs_info *prf) {set_listener_font(rts_listener_font);}
clear_listener_font(prefs_info * prf)1103 static void clear_listener_font(prefs_info *prf) {set_listener_font(ss->orig_listener_font);}
1104
1105
listener_font_text(prefs_info * prf)1106 static void listener_font_text(prefs_info *prf)
1107 {
1108 char *str;
1109 str = GET_TEXT(prf->text);
1110 if ((!str) || (!(*str)))
1111 {
1112 SET_TEXT(prf->text, listener_font(ss));
1113 return;
1114 }
1115 if (!(set_listener_font(str)))
1116 {
1117 SET_TEXT(prf->text, "can't find that font");
1118 TIMEOUT(listener_font_error_erase_func);
1119 }
1120 if (str) {free_TEXT(str);}
1121 }
1122
1123
1124
1125 /* ---------------- save-state-file ---------------- */
1126
1127 static char *rts_save_state_file = NULL;
1128
reflect_save_state_file(prefs_info * prf)1129 static void reflect_save_state_file(prefs_info *prf)
1130 {
1131 SET_TEXT(prf->text, save_state_file(ss));
1132 }
1133
1134
revert_save_state_file(prefs_info * prf)1135 static void revert_save_state_file(prefs_info *prf)
1136 {
1137 if (save_state_file(ss)) free(save_state_file(ss));
1138 in_set_save_state_file(mus_strdup(rts_save_state_file));
1139 }
1140
1141
save_save_state_file(prefs_info * prf,FILE * ignore)1142 static void save_save_state_file(prefs_info *prf, FILE *ignore)
1143 {
1144 if (rts_save_state_file) free(rts_save_state_file);
1145 rts_save_state_file = mus_strdup(save_state_file(ss));
1146 }
1147
1148
save_state_file_text(prefs_info * prf)1149 static void save_state_file_text(prefs_info *prf)
1150 {
1151 char *str, *file = NULL;
1152 str = GET_TEXT(prf->text);
1153 if ((!str) || (!(*str)))
1154 file = mus_strdup(DEFAULT_SAVE_STATE_FILE);
1155 else file = mus_strdup(str);
1156 if (save_state_file(ss)) free(save_state_file(ss));
1157 in_set_save_state_file(file);
1158 if (str) {free_TEXT(str);}
1159 }
1160
1161
1162
1163 /* ---------------- temp-dir ---------------- */
1164
1165 static char *rts_temp_dir = NULL;
1166
reflect_temp_dir(prefs_info * prf)1167 static void reflect_temp_dir(prefs_info *prf)
1168 {
1169 SET_TEXT(prf->text, temp_dir(ss));
1170 }
1171
1172
revert_temp_dir(prefs_info * prf)1173 static void revert_temp_dir(prefs_info *prf)
1174 {
1175 if (temp_dir(ss)) free(temp_dir(ss));
1176 set_temp_dir(mus_strdup(rts_temp_dir));
1177 }
1178
1179
save_temp_dir(prefs_info * prf,FILE * ignore)1180 static void save_temp_dir(prefs_info *prf, FILE *ignore)
1181 {
1182 if (rts_temp_dir) free(rts_temp_dir);
1183 rts_temp_dir = mus_strdup(temp_dir(ss));
1184 }
1185
1186
temp_dir_error_erase_func(TIMEOUT_ARGS)1187 static TIMEOUT_TYPE temp_dir_error_erase_func(TIMEOUT_ARGS)
1188 {
1189 prefs_info *prf = (prefs_info *)context;
1190 SET_TEXT(prf->text, rts_temp_dir);
1191 TIMEOUT_RESULT
1192 }
1193
1194
temp_dir_text(prefs_info * prf)1195 static void temp_dir_text(prefs_info *prf)
1196 {
1197 char *str, *dir;
1198
1199 str = GET_TEXT(prf->text);
1200 if ((!str) || (!(*str)))
1201 dir = MUS_DEFAULT_TEMP_DIR;
1202 else dir = str;
1203
1204 if (local_access(dir))
1205 {
1206 if (temp_dir(ss)) free(temp_dir(ss));
1207 set_temp_dir(mus_strdup(dir));
1208 }
1209 else
1210 {
1211 SET_TEXT(prf->text, "can't access that directory");
1212 TIMEOUT(temp_dir_error_erase_func);
1213 }
1214 #if USE_MOTIF
1215 if (str) XtFree(str);
1216 #endif
1217 }
1218
1219
1220
1221 /* ---------------- save-dir ---------------- */
1222
1223 static char *rts_save_dir = NULL;
1224
reflect_save_dir(prefs_info * prf)1225 static void reflect_save_dir(prefs_info *prf)
1226 {
1227 SET_TEXT(prf->text, save_dir(ss));
1228 }
1229
1230
revert_save_dir(prefs_info * prf)1231 static void revert_save_dir(prefs_info *prf)
1232 {
1233 if (save_dir(ss)) free(save_dir(ss));
1234 set_save_dir(mus_strdup(rts_save_dir));
1235 }
1236
1237
save_save_dir(prefs_info * prf,FILE * ignore)1238 static void save_save_dir(prefs_info *prf, FILE *ignore)
1239 {
1240 if (rts_save_dir) free(rts_save_dir);
1241 rts_save_dir = mus_strdup(save_dir(ss));
1242 }
1243
1244
save_dir_error_erase_func(TIMEOUT_ARGS)1245 static TIMEOUT_TYPE save_dir_error_erase_func(TIMEOUT_ARGS)
1246 {
1247 prefs_info *prf = (prefs_info *)context;
1248 SET_TEXT(prf->text, rts_save_dir);
1249 TIMEOUT_RESULT
1250 }
1251
1252
save_dir_text(prefs_info * prf)1253 static void save_dir_text(prefs_info *prf)
1254 {
1255 char *str, *dir;
1256
1257 str = GET_TEXT(prf->text);
1258 if ((!str) || (!(*str)))
1259 dir = MUS_DEFAULT_SAVE_DIR;
1260 else dir = str;
1261
1262 if (local_access(dir))
1263 {
1264 if (save_dir(ss)) free(save_dir(ss));
1265 set_save_dir(mus_strdup(dir));
1266 }
1267 else
1268 {
1269 SET_TEXT(prf->text, "can't access that directory");
1270 TIMEOUT(save_dir_error_erase_func);
1271 }
1272 #if USE_MOTIF
1273 if (str) XtFree(str);
1274 #endif
1275 }
1276
1277
1278
1279 #if HAVE_LADSPA
1280 /* ---------------- ladspa-dir ---------------- */
1281
1282 static char *rts_ladspa_dir = NULL;
1283
reflect_ladspa_dir(prefs_info * prf)1284 static void reflect_ladspa_dir(prefs_info *prf)
1285 {
1286 SET_TEXT(prf->text, ladspa_dir(ss));
1287 }
1288
1289
revert_ladspa_dir(prefs_info * prf)1290 static void revert_ladspa_dir(prefs_info *prf)
1291 {
1292 if (ladspa_dir(ss)) free(ladspa_dir(ss));
1293 set_ladspa_dir(mus_strdup(rts_ladspa_dir));
1294 }
1295
1296
save_ladspa_dir(prefs_info * prf,FILE * ignore)1297 static void save_ladspa_dir(prefs_info *prf, FILE *ignore)
1298 {
1299 if (rts_ladspa_dir) free(rts_ladspa_dir);
1300 rts_ladspa_dir = mus_strdup(ladspa_dir(ss));
1301 }
1302
1303
ladspa_dir_text(prefs_info * prf)1304 static void ladspa_dir_text(prefs_info *prf)
1305 {
1306 char *str;
1307 str = GET_TEXT(prf->text);
1308 if (ladspa_dir(ss)) free(ladspa_dir(ss));
1309 if (str)
1310 {
1311 set_ladspa_dir(mus_strdup(str));
1312 free_TEXT(str);
1313 }
1314 else set_ladspa_dir(mus_strdup(DEFAULT_LADSPA_DIR));
1315 }
1316
help_ladspa_dir(prefs_info * prf)1317 static const char *help_ladspa_dir(prefs_info *prf)
1318 {
1319 return("This sets the location of the ladspa libraries");
1320 }
1321 #endif
1322
1323
1324 #if USE_MOTIF
1325 /* ---------------- view-files directory ---------------- */
1326
1327 static char *rts_vf_directory = NULL;
1328
reflect_view_files_directory(prefs_info * prf)1329 static void reflect_view_files_directory(prefs_info *prf)
1330 {
1331 SET_TEXT(prf->text, view_files_find_any_directory());
1332 }
1333
1334
revert_view_files_directory(prefs_info * prf)1335 static void revert_view_files_directory(prefs_info *prf)
1336 {
1337 if (rts_vf_directory)
1338 view_files_add_directory(NULL_WIDGET, (const char *)rts_vf_directory);
1339 }
1340
1341
save_view_files_directory(prefs_info * prf,FILE * fd)1342 static void save_view_files_directory(prefs_info *prf, FILE *fd)
1343 {
1344 if (rts_vf_directory) free(rts_vf_directory);
1345 rts_vf_directory = mus_strdup(view_files_find_any_directory());
1346 if (rts_vf_directory)
1347 {
1348 #if HAVE_SCHEME
1349 fprintf(fd, "(%s \"%s\")\n", S_add_directory_to_view_files_list, rts_vf_directory);
1350 #endif
1351
1352 #if HAVE_RUBY
1353 fprintf(fd, "%s(\"%s\")\n", to_proc_name(S_add_directory_to_view_files_list), rts_vf_directory);
1354 #endif
1355
1356 #if HAVE_FORTH
1357 fprintf(fd, "\"%s\" %s drop\n", rts_vf_directory, S_add_directory_to_view_files_list);
1358 #endif
1359 }
1360 }
1361
1362
view_files_directory_text(prefs_info * prf)1363 static void view_files_directory_text(prefs_info *prf)
1364 {
1365 char *str;
1366 str = GET_TEXT(prf->text);
1367 if (str)
1368 {
1369 view_files_add_directory(NULL_WIDGET, (const char *)str);
1370 free_TEXT(str);
1371 }
1372 }
1373 #endif
1374
1375
1376
1377 /* ---------------- html-program ---------------- */
1378
1379 static char *rts_html_program = NULL;
1380
reflect_html_program(prefs_info * prf)1381 static void reflect_html_program(prefs_info *prf)
1382 {
1383 SET_TEXT(prf->text, html_program(ss));
1384 }
1385
1386
revert_html_program(prefs_info * prf)1387 static void revert_html_program(prefs_info *prf)
1388 {
1389 if (html_program(ss)) free(html_program(ss));
1390 set_html_program(mus_strdup(rts_html_program));
1391 }
1392
1393
save_html_program(prefs_info * prf,FILE * ignore)1394 static void save_html_program(prefs_info *prf, FILE *ignore)
1395 {
1396 if (rts_html_program) free(rts_html_program);
1397 rts_html_program = mus_strdup(html_program(ss));
1398 }
1399
1400
html_program_text(prefs_info * prf)1401 static void html_program_text(prefs_info *prf)
1402 {
1403 char *str;
1404 str = GET_TEXT(prf->text);
1405 if (html_program(ss)) free(html_program(ss));
1406 if (str)
1407 {
1408 set_html_program(mus_strdup(str));
1409 free_TEXT(str);
1410 }
1411 else set_html_program(mus_strdup(DEFAULT_HTML_PROGRAM));
1412 }
1413
1414
1415 /* ---------------- listener-prompt ---------------- */
1416
1417 static char *rts_listener_prompt = NULL;
1418
reflect_listener_prompt(prefs_info * prf)1419 static void reflect_listener_prompt(prefs_info *prf)
1420 {
1421 SET_TEXT(prf->text, listener_prompt(ss));
1422 }
1423
1424
revert_listener_prompt(prefs_info * prf)1425 static void revert_listener_prompt(prefs_info *prf)
1426 {
1427 if (rts_listener_prompt)
1428 {
1429 if (listener_prompt(ss)) free(listener_prompt(ss));
1430 set_listener_prompt(mus_strdup(rts_listener_prompt));
1431 }
1432 }
1433
1434
save_listener_prompt(prefs_info * prf,FILE * ignore)1435 static void save_listener_prompt(prefs_info *prf, FILE *ignore)
1436 {
1437 if (rts_listener_prompt) free(rts_listener_prompt);
1438 rts_listener_prompt = mus_strdup(listener_prompt(ss));
1439 }
1440
1441
listener_prompt_text(prefs_info * prf)1442 static void listener_prompt_text(prefs_info *prf)
1443 {
1444 char *str;
1445 str = GET_TEXT(prf->text);
1446 if (str)
1447 {
1448 if (listener_prompt(ss)) free(listener_prompt(ss));
1449 set_listener_prompt(mus_strdup(str));
1450 free_TEXT(str);
1451 }
1452 }
1453
1454
1455
1456 /* ---------------- show-transform-peaks ---------------- */
1457
1458 static bool rts_show_transform_peaks = DEFAULT_SHOW_TRANSFORM_PEAKS;
1459 static int rts_max_transform_peaks = DEFAULT_MAX_TRANSFORM_PEAKS;
1460
reflect_transform_peaks(prefs_info * prf)1461 static void reflect_transform_peaks(prefs_info *prf)
1462 {
1463 SET_TOGGLE(prf->toggle, show_transform_peaks(ss));
1464 int_to_textfield(prf->text, max_transform_peaks(ss));
1465 }
1466
1467
revert_transform_peaks(prefs_info * prf)1468 static void revert_transform_peaks(prefs_info *prf)
1469 {
1470 set_show_transform_peaks(rts_show_transform_peaks);
1471 set_max_transform_peaks(rts_max_transform_peaks);
1472 }
1473
1474
save_transform_peaks(prefs_info * prf,FILE * ignore)1475 static void save_transform_peaks(prefs_info *prf, FILE *ignore)
1476 {
1477 rts_show_transform_peaks = show_transform_peaks(ss);
1478 rts_max_transform_peaks = max_transform_peaks(ss);
1479 }
1480
1481
transform_peaks_toggle(prefs_info * prf)1482 static void transform_peaks_toggle(prefs_info *prf)
1483 {
1484 set_show_transform_peaks(GET_TOGGLE(prf->toggle));
1485 }
1486
1487
max_peaks_text(prefs_info * prf)1488 static void max_peaks_text(prefs_info *prf)
1489 {
1490 char *str;
1491 str = GET_TEXT(prf->text);
1492 if ((str) && (*str))
1493 {
1494 int value = 0;
1495
1496 redirect_errors_to(any_error_to_text, (void *)prf);
1497 value = string_to_int(str, 0, "max peaks");
1498 redirect_errors_to(NULL, NULL);
1499
1500 if (!(prf->got_error))
1501 set_max_transform_peaks(value);
1502 free_TEXT(str);
1503 }
1504 }
1505
1506
1507
1508 /* ---------------- show-mix-waveforms ---------------- */
1509
1510 static bool rts_show_mix_waveforms = DEFAULT_SHOW_MIX_WAVEFORMS;
1511 static int rts_mix_waveform_height = DEFAULT_MIX_WAVEFORM_HEIGHT;
1512
reflect_mix_waveforms(prefs_info * prf)1513 static void reflect_mix_waveforms(prefs_info *prf)
1514 {
1515 SET_TOGGLE(prf->toggle, show_mix_waveforms(ss));
1516 int_to_textfield(prf->text, mix_waveform_height(ss));
1517 }
1518
1519
revert_mix_waveforms(prefs_info * prf)1520 static void revert_mix_waveforms(prefs_info *prf)
1521 {
1522 set_show_mix_waveforms(rts_show_mix_waveforms);
1523 set_mix_waveform_height(rts_mix_waveform_height);
1524 }
1525
1526
save_mix_waveforms(prefs_info * prf,FILE * ignore)1527 static void save_mix_waveforms(prefs_info *prf, FILE *ignore)
1528 {
1529 rts_show_mix_waveforms = show_mix_waveforms(ss);
1530 rts_mix_waveform_height = mix_waveform_height(ss);
1531 }
1532
1533
show_mix_waveforms_toggle(prefs_info * prf)1534 static void show_mix_waveforms_toggle(prefs_info *prf)
1535 {
1536 set_show_mix_waveforms(GET_TOGGLE(prf->toggle));
1537 }
1538
1539
mix_waveform_height_text(prefs_info * prf)1540 static void mix_waveform_height_text(prefs_info *prf)
1541 {
1542 char *str;
1543 str = GET_TEXT(prf->text);
1544 if ((str) && (*str))
1545 {
1546 int value = 0;
1547
1548 redirect_errors_to(any_error_to_text, (void *)prf);
1549 value = string_to_int(str, 0, "mix waveform height");
1550 redirect_errors_to(NULL, NULL);
1551
1552 if (!(prf->got_error))
1553 set_mix_waveform_height(value);
1554 free_TEXT(str);
1555 }
1556 }
1557
1558
1559
1560 /* ---------------- selection-creates-region, max-regions ---------------- */
1561
1562 static bool rts_selection_creates_region = DEFAULT_SELECTION_CREATES_REGION;
1563 static int rts_max_regions = DEFAULT_MAX_REGIONS;
1564
1565
reflect_selection_creates_region(prefs_info * prf)1566 static void reflect_selection_creates_region(prefs_info *prf)
1567 {
1568 SET_TOGGLE(prf->toggle, selection_creates_region(ss));
1569 int_to_textfield(prf->text, max_regions(ss));
1570 }
1571
1572
revert_selection_creates_region(prefs_info * prf)1573 static void revert_selection_creates_region(prefs_info *prf)
1574 {
1575 set_selection_creates_region(rts_selection_creates_region);
1576 in_set_max_regions(rts_max_regions);
1577 }
1578
1579
save_selection_creates_region(prefs_info * prf,FILE * ignore)1580 static void save_selection_creates_region(prefs_info *prf, FILE *ignore)
1581 {
1582 rts_selection_creates_region = selection_creates_region(ss);
1583 rts_max_regions = max_regions(ss);
1584 }
1585
1586
selection_creates_region_toggle(prefs_info * prf)1587 static void selection_creates_region_toggle(prefs_info *prf)
1588 {
1589 set_selection_creates_region(GET_TOGGLE(prf->toggle));
1590 }
1591
1592
max_regions_text(prefs_info * prf)1593 static void max_regions_text(prefs_info *prf)
1594 {
1595 char *str;
1596 str = GET_TEXT(prf->text);
1597 if ((str) && (*str))
1598 {
1599 int value = 0;
1600
1601 redirect_errors_to(any_error_to_text, (void *)prf);
1602 value = string_to_int(str, 0, "max regions");
1603 redirect_errors_to(NULL, NULL);
1604
1605 if (!(prf->got_error))
1606 in_set_max_regions(value);
1607 free_TEXT(str);
1608 }
1609 }
1610
1611
1612
1613 /* ---------------- sinc width ---------------- */
1614
1615 static int rts_sinc_width = DEFAULT_SINC_WIDTH;
1616
reflect_sinc_width(prefs_info * prf)1617 static void reflect_sinc_width(prefs_info *prf) {int_to_textfield(prf->text, sinc_width(ss));}
revert_sinc_width(prefs_info * prf)1618 static void revert_sinc_width(prefs_info *prf) {set_sinc_width(rts_sinc_width);}
save_sinc_width(prefs_info * prf,FILE * ignore)1619 static void save_sinc_width(prefs_info *prf, FILE *ignore) {rts_sinc_width = sinc_width(ss);}
1620
sinc_width_text(prefs_info * prf)1621 static void sinc_width_text(prefs_info *prf)
1622 {
1623 char *str;
1624 str = GET_TEXT(prf->text);
1625 if ((str) && (*str))
1626 {
1627 int value = 0;
1628
1629 redirect_errors_to(any_error_to_text, (void *)prf);
1630 value = string_to_int(str, 0, "sinc width");
1631 redirect_errors_to(NULL, NULL);
1632
1633 if (!(prf->got_error))
1634 set_sinc_width(value);
1635 free_TEXT(str);
1636 }
1637 }
1638
1639
1640
1641 /* ---------------- print-length ---------------- */
1642
1643 static int rts_print_length = DEFAULT_PRINT_LENGTH;
1644
reflect_print_length(prefs_info * prf)1645 static void reflect_print_length(prefs_info *prf) {int_to_textfield(prf->text, print_length(ss));}
revert_print_length(prefs_info * prf)1646 static void revert_print_length(prefs_info *prf) {set_print_length(rts_print_length); mus_vct_set_print_length(rts_print_length);}
save_print_length(prefs_info * prf,FILE * ignore)1647 static void save_print_length(prefs_info *prf, FILE *ignore) {rts_print_length = print_length(ss);}
1648
1649
print_length_text(prefs_info * prf)1650 static void print_length_text(prefs_info *prf)
1651 {
1652 char *str;
1653 str = GET_TEXT(prf->text);
1654 if ((str) && (*str))
1655 {
1656 int value = 0;
1657
1658 redirect_errors_to(any_error_to_text, (void *)prf);
1659 value = string_to_int(str, 0, "print length");
1660 redirect_errors_to(NULL, NULL);
1661
1662 if (!(prf->got_error))
1663 {
1664 set_print_length(value);
1665 mus_vct_set_print_length(value);
1666 /* the clm array print length variable will be taken care of when ww.scm is loaded in the new context */
1667 }
1668 free_TEXT(str);
1669 }
1670 }
1671
1672
1673
1674 /* ---------------- dac-size ---------------- */
1675
1676 static int rts_dac_size = DEFAULT_DAC_SIZE;
1677
reflect_dac_size(prefs_info * prf)1678 static void reflect_dac_size(prefs_info *prf) {int_to_textfield(prf->text, dac_size(ss));}
revert_dac_size(prefs_info * prf)1679 static void revert_dac_size(prefs_info *prf) {set_dac_size(rts_dac_size);}
save_dac_size(prefs_info * prf,FILE * ignore)1680 static void save_dac_size(prefs_info *prf, FILE *ignore) {rts_dac_size = dac_size(ss);}
1681
1682
dac_size_text(prefs_info * prf)1683 static void dac_size_text(prefs_info *prf)
1684 {
1685 char *str;
1686 str = GET_TEXT(prf->text);
1687 if ((str) && (*str))
1688 {
1689 int value = 0;
1690
1691 redirect_errors_to(any_error_to_text, (void *)prf);
1692 value = string_to_int(str, 0, "dac size");
1693 redirect_errors_to(NULL, NULL);
1694
1695 if (!(prf->got_error))
1696 set_dac_size(value);
1697 free_TEXT(str);
1698 }
1699 }
1700
1701
1702
1703 /* ---------------- min-dB ---------------- */
1704
1705 static mus_float_t rts_min_dB = DEFAULT_MIN_DB;
1706
reflect_min_dB(prefs_info * prf)1707 static void reflect_min_dB(prefs_info *prf) {float_1_to_textfield(prf->text, min_dB(ss));}
revert_min_dB(prefs_info * prf)1708 static void revert_min_dB(prefs_info *prf) {set_min_dB(rts_min_dB);}
save_min_dB(prefs_info * prf,FILE * ignore)1709 static void save_min_dB(prefs_info *prf, FILE *ignore) {rts_min_dB = min_dB(ss);}
1710
1711
min_dB_text(prefs_info * prf)1712 static void min_dB_text(prefs_info *prf)
1713 {
1714 char *str;
1715 str = GET_TEXT(prf->text);
1716 if ((str) && (*str))
1717 {
1718 double value;
1719
1720 redirect_errors_to(any_error_to_text, (void *)prf);
1721 value = (double)string_to_mus_float_t(str, -100000.0, "min dB");
1722 redirect_errors_to(NULL, NULL);
1723
1724 if ((!(prf->got_error)) && (value < 0.0))
1725 set_min_db(value); /* snd-chn.c -- redisplays */
1726 free_TEXT(str);
1727 }
1728 }
1729
1730
1731
1732 /* ---------------- fft-window-beta ---------------- */
1733
1734 static mus_float_t rts_fft_window_beta = DEFAULT_FFT_WINDOW_BETA;
1735
reflect_fft_window_beta(prefs_info * prf)1736 static void reflect_fft_window_beta(prefs_info *prf)
1737 {
1738 SET_SCALE(fft_window_beta(ss) / prf->scale_max);
1739 float_to_textfield(prf->text, fft_window_beta(ss));
1740 }
1741
1742
revert_fft_window_beta(prefs_info * prf)1743 static void revert_fft_window_beta(prefs_info *prf) {set_fft_window_beta(rts_fft_window_beta);}
save_fft_window_beta(prefs_info * prf,FILE * ignore)1744 static void save_fft_window_beta(prefs_info *prf, FILE *ignore) {rts_fft_window_beta = fft_window_beta(ss);}
fft_window_beta_scale_callback(prefs_info * prf)1745 static void fft_window_beta_scale_callback(prefs_info *prf) {set_fft_window_beta(GET_SCALE() * prf->scale_max);}
1746
1747
fft_window_beta_text_callback(prefs_info * prf)1748 static void fft_window_beta_text_callback(prefs_info *prf)
1749 {
1750 char *str;
1751 str = GET_TEXT(prf->text);
1752 if ((str) && (*str))
1753 {
1754 double value;
1755
1756 redirect_errors_to(any_error_to_text, (void *)prf);
1757 value = (double)string_to_mus_float_t(str, 0.0, "fft beta");
1758 redirect_errors_to(NULL, NULL);
1759
1760 if ((!(prf->got_error)) && (value <= prf->scale_max))
1761 {
1762 set_fft_window_beta(value);
1763 SET_SCALE(value / prf->scale_max);
1764 }
1765 free_TEXT(str);
1766 }
1767 }
1768
1769
1770 /* ---------------- grid-density ---------------- */
1771
1772 static mus_float_t rts_grid_density = DEFAULT_GRID_DENSITY;
1773
reflect_grid_density(prefs_info * prf)1774 static void reflect_grid_density(prefs_info *prf)
1775 {
1776 SET_SCALE(grid_density(ss) / prf->scale_max);
1777 float_to_textfield(prf->text, grid_density(ss));
1778 }
1779
1780
revert_grid_density(prefs_info * prf)1781 static void revert_grid_density(prefs_info *prf) {set_grid_density(rts_grid_density);}
save_grid_density(prefs_info * prf,FILE * ignore)1782 static void save_grid_density(prefs_info *prf, FILE *ignore) {rts_grid_density = grid_density(ss);}
grid_density_scale_callback(prefs_info * prf)1783 static void grid_density_scale_callback(prefs_info *prf) {set_grid_density(GET_SCALE() * prf->scale_max);}
1784
1785
grid_density_text_callback(prefs_info * prf)1786 static void grid_density_text_callback(prefs_info *prf)
1787 {
1788 char *str;
1789 str = GET_TEXT(prf->text);
1790 if ((str) && (*str))
1791 {
1792 double value;
1793
1794 redirect_errors_to(any_error_to_text, (void *)prf);
1795 value = (double)string_to_mus_float_t(str, 0.0, "grid density");
1796 redirect_errors_to(NULL, NULL);
1797
1798 if ((!(prf->got_error)) && (value <= prf->scale_max))
1799 {
1800 set_grid_density(value);
1801 SET_SCALE(value / prf->scale_max);
1802 }
1803 free_TEXT(str);
1804 }
1805 }
1806
1807
1808
1809 /* ---------------- sync style ---------------- */
1810
1811 static sync_style_t rts_sync_style = DEFAULT_SYNC_STYLE;
revert_sync_style(prefs_info * prf)1812 static void revert_sync_style(prefs_info *prf) {set_sync_style(rts_sync_style);}
clear_sync_style(prefs_info * prf)1813 static void clear_sync_style(prefs_info *prf) {set_sync_style(DEFAULT_SYNC_STYLE);}
save_sync_style(prefs_info * prf,FILE * ignore)1814 static void save_sync_style(prefs_info *prf, FILE *ignore) {rts_sync_style = sync_style(ss);}
1815
help_sync_style(prefs_info * prf)1816 static const char *help_sync_style(prefs_info *prf)
1817 {
1818 return("\
1819 Many operations can operate either on all channels at once,\n\
1820 or only on the currently selected channel. If 'within each sound'\n\
1821 is set, the channels within a sound are tied together, but not\n\
1822 across sounds.");
1823 }
1824
1825
reflect_sync_style(prefs_info * prf)1826 static void reflect_sync_style(prefs_info *prf)
1827 {
1828 rts_sync_style = sync_style(ss);
1829 SET_TOGGLE(prf->toggle, rts_sync_style == SYNC_BY_SOUND);
1830 SET_TOGGLE(prf->toggle2, rts_sync_style == SYNC_ALL);
1831 }
1832
1833
sync1_choice(prefs_info * prf)1834 static void sync1_choice(prefs_info *prf)
1835 {
1836 if (GET_TOGGLE(prf->toggle))
1837 rts_sync_style = SYNC_BY_SOUND;
1838 else rts_sync_style = SYNC_NONE;
1839 SET_TOGGLE(prf->toggle2, false);
1840 set_sync_style(rts_sync_style);
1841 }
1842
1843
sync2_choice(prefs_info * prf)1844 static void sync2_choice(prefs_info *prf)
1845 {
1846 if (GET_TOGGLE(prf->toggle2))
1847 rts_sync_style = SYNC_ALL;
1848 else rts_sync_style = SYNC_NONE;
1849 SET_TOGGLE(prf->toggle, false);
1850 set_sync_style(rts_sync_style);
1851 }
1852
1853
1854
1855 /* ---------------- mark-tag size ---------------- */
1856
1857 static int rts_mark_tag_width = DEFAULT_MARK_TAG_WIDTH, rts_mark_tag_height = DEFAULT_MARK_TAG_HEIGHT;
1858
reflect_mark_tag_size(prefs_info * prf)1859 static void reflect_mark_tag_size(prefs_info *prf)
1860 {
1861 int_to_textfield(prf->text, mark_tag_width(ss));
1862 int_to_textfield(prf->rtxt, mark_tag_height(ss));
1863 }
1864
1865
revert_mark_tag_size(prefs_info * prf)1866 static void revert_mark_tag_size(prefs_info *prf)
1867 {
1868 set_mark_tag_width(rts_mark_tag_width);
1869 set_mark_tag_height(rts_mark_tag_height);
1870 }
1871
1872
save_mark_tag_size(prefs_info * prf,FILE * ignore)1873 static void save_mark_tag_size(prefs_info *prf, FILE *ignore)
1874 {
1875 rts_mark_tag_width = mark_tag_width(ss);
1876 rts_mark_tag_height = mark_tag_height(ss);
1877 }
1878
1879
mark_tag_width_erase_func(TIMEOUT_ARGS)1880 static TIMEOUT_TYPE mark_tag_width_erase_func(TIMEOUT_ARGS)
1881 {
1882 prefs_info *prf = (prefs_info *)context;
1883 int_to_textfield(prf->text, mark_tag_width(ss));
1884 TIMEOUT_RESULT
1885 }
1886
1887
mark_tag_height_erase_func(TIMEOUT_ARGS)1888 static TIMEOUT_TYPE mark_tag_height_erase_func(TIMEOUT_ARGS)
1889 {
1890 prefs_info *prf = (prefs_info *)context;
1891 int_to_textfield(prf->rtxt, mark_tag_height(ss));
1892 TIMEOUT_RESULT
1893 }
1894
1895
mark_tag_width_error(const char * msg,void * data)1896 static void mark_tag_width_error(const char *msg, void *data)
1897 {
1898 prefs_info *prf = (prefs_info *)data;
1899 SET_TEXT(prf->text, "must be > 0");
1900 TIMEOUT(mark_tag_width_erase_func);
1901 }
1902
1903
mark_tag_height_error(const char * msg,void * data)1904 static void mark_tag_height_error(const char *msg, void *data)
1905 {
1906 prefs_info *prf = (prefs_info *)data;
1907 SET_TEXT(prf->rtxt, "must be > 0");
1908 TIMEOUT(mark_tag_height_erase_func);
1909 }
1910
1911
mark_tag_size_text(prefs_info * prf)1912 static void mark_tag_size_text(prefs_info *prf)
1913 {
1914 char *str;
1915 str = GET_TEXT(prf->text);
1916 if ((str) && (*str))
1917 {
1918 int width = 0;
1919
1920 redirect_errors_to(mark_tag_width_error, (void *)prf);
1921 width = string_to_int(str, 1, "mark tag width");
1922 redirect_errors_to(NULL, NULL);
1923
1924 if (width > 0) set_mark_tag_width(width);
1925 free_TEXT(str);
1926 str = GET_TEXT(prf->rtxt);
1927 if ((str) && (*str))
1928 {
1929 int height;
1930
1931 redirect_errors_to(mark_tag_height_error, (void *)prf);
1932 height = string_to_int(str, 1, "mark tag height");
1933 redirect_errors_to(NULL, NULL);
1934
1935 if (height > 0) set_mark_tag_height(height);
1936 free_TEXT(str);
1937 }
1938 }
1939 }
1940
1941
1942 /* ---------------- mix-tag size ---------------- */
1943
1944 static int rts_mix_tag_width = DEFAULT_MIX_TAG_WIDTH, rts_mix_tag_height = DEFAULT_MIX_TAG_HEIGHT;
1945
reflect_mix_tag_size(prefs_info * prf)1946 static void reflect_mix_tag_size(prefs_info *prf)
1947 {
1948 int_to_textfield(prf->text, mix_tag_width(ss));
1949 int_to_textfield(prf->rtxt, mix_tag_height(ss));
1950 }
1951
1952
revert_mix_tag_size(prefs_info * prf)1953 static void revert_mix_tag_size(prefs_info *prf)
1954 {
1955 set_mix_tag_width(rts_mix_tag_width);
1956 set_mix_tag_height(rts_mix_tag_height);
1957 }
1958
1959
save_mix_tag_size(prefs_info * prf,FILE * ignore)1960 static void save_mix_tag_size(prefs_info *prf, FILE *ignore)
1961 {
1962 rts_mix_tag_width = mix_tag_width(ss);
1963 rts_mix_tag_height = mix_tag_height(ss);
1964 }
1965
1966
mix_tag_width_erase_func(TIMEOUT_ARGS)1967 static TIMEOUT_TYPE mix_tag_width_erase_func(TIMEOUT_ARGS)
1968 {
1969 prefs_info *prf = (prefs_info *)context;
1970 int_to_textfield(prf->text, mix_tag_width(ss));
1971 TIMEOUT_RESULT
1972 }
1973
1974
mix_tag_height_erase_func(TIMEOUT_ARGS)1975 static TIMEOUT_TYPE mix_tag_height_erase_func(TIMEOUT_ARGS)
1976 {
1977 prefs_info *prf = (prefs_info *)context;
1978 int_to_textfield(prf->rtxt, mix_tag_height(ss));
1979 TIMEOUT_RESULT
1980 }
1981
1982
mix_tag_width_error(const char * msg,void * data)1983 static void mix_tag_width_error(const char *msg, void *data)
1984 {
1985 prefs_info *prf = (prefs_info *)data;
1986 SET_TEXT(prf->text, "must be > 0");
1987 TIMEOUT(mix_tag_width_erase_func);
1988 }
1989
1990
mix_tag_height_error(const char * msg,void * data)1991 static void mix_tag_height_error(const char *msg, void *data)
1992 {
1993 prefs_info *prf = (prefs_info *)data;
1994 SET_TEXT(prf->rtxt, "must be > 0");
1995 TIMEOUT(mix_tag_height_erase_func);
1996 }
1997
1998
mix_tag_size_text(prefs_info * prf)1999 static void mix_tag_size_text(prefs_info *prf)
2000 {
2001 char *str;
2002 str = GET_TEXT(prf->text);
2003 if ((str) && (*str))
2004 {
2005 int width = 0;
2006
2007 redirect_errors_to(mix_tag_width_error, (void *)prf);
2008 width = string_to_int(str, 1, "mix tag width");
2009 redirect_errors_to(NULL, NULL);
2010
2011 if (width > 0) set_mix_tag_width(width);
2012 free_TEXT(str);
2013 str = GET_TEXT(prf->rtxt);
2014 if ((str) && (*str))
2015 {
2016 int height;
2017
2018 redirect_errors_to(mix_tag_height_error, (void *)prf);
2019 height = string_to_int(str, 1, "mix tag height");
2020 redirect_errors_to(NULL, NULL);
2021
2022 if (height > 0) set_mix_tag_height(height);
2023 free_TEXT(str);
2024 }
2025 }
2026 }
2027
2028
2029 /* ---------------- start up size ---------------- */
2030
2031 static int rts_init_window_width = DEFAULT_INIT_WINDOW_WIDTH, rts_init_window_height = DEFAULT_INIT_WINDOW_HEIGHT;
2032
revert_init_window_size(prefs_info * prf)2033 static void revert_init_window_size(prefs_info *prf)
2034 {
2035 ss->init_window_width = rts_init_window_width;
2036 ss->init_window_height = rts_init_window_height;
2037 }
2038
2039
reflect_init_window_size(prefs_info * prf)2040 static void reflect_init_window_size(prefs_info *prf)
2041 {
2042 char *str;
2043
2044 str = mus_format("%d", ss->init_window_width);
2045 SET_TEXT(prf->text, str);
2046 free(str);
2047
2048 str = mus_format("%d", ss->init_window_height);
2049 SET_TEXT(prf->rtxt, str);
2050 free(str);
2051 }
2052
2053
clear_init_window_size(prefs_info * prf)2054 static void clear_init_window_size(prefs_info *prf)
2055 {
2056 ss->init_window_width = DEFAULT_INIT_WINDOW_WIDTH;
2057 ss->init_window_height = DEFAULT_INIT_WINDOW_HEIGHT;
2058 }
2059
2060
save_init_window_size(prefs_info * prf,FILE * ignore)2061 static void save_init_window_size(prefs_info *prf, FILE *ignore)
2062 {
2063 rts_init_window_width = ss->init_window_width;
2064 rts_init_window_height = ss->init_window_height;
2065 }
2066
2067
startup_width_erase_func(TIMEOUT_ARGS)2068 static TIMEOUT_TYPE startup_width_erase_func(TIMEOUT_ARGS)
2069 {
2070 prefs_info *prf = (prefs_info *)context;
2071 int_to_textfield(prf->text, ss->init_window_width);
2072 TIMEOUT_RESULT
2073 }
2074
2075
startup_height_erase_func(TIMEOUT_ARGS)2076 static TIMEOUT_TYPE startup_height_erase_func(TIMEOUT_ARGS)
2077 {
2078 prefs_info *prf = (prefs_info *)context;
2079 int_to_textfield(prf->rtxt, ss->init_window_height);
2080 TIMEOUT_RESULT
2081 }
2082
2083
startup_width_error(const char * msg,void * data)2084 static void startup_width_error(const char *msg, void *data)
2085 {
2086 prefs_info *prf = (prefs_info *)data;
2087 SET_TEXT(prf->text, "must be > 0");
2088 TIMEOUT(startup_width_erase_func);
2089 }
2090
2091
startup_height_error(const char * msg,void * data)2092 static void startup_height_error(const char *msg, void *data)
2093 {
2094 prefs_info *prf = (prefs_info *)data;
2095 SET_TEXT(prf->rtxt, "must be > 0");
2096 TIMEOUT(startup_height_erase_func);
2097 }
2098
2099
startup_size_text(prefs_info * prf)2100 static void startup_size_text(prefs_info *prf)
2101 {
2102 char *str;
2103 str = GET_TEXT(prf->text);
2104 if ((str) && (*str))
2105 {
2106 int width = 0;
2107
2108 redirect_errors_to(startup_width_error, (void *)prf);
2109 width = string_to_int(str, 1, "startup width");
2110 redirect_errors_to(NULL, NULL);
2111
2112 if (width > 0) ss->init_window_width = width;
2113 free_TEXT(str);
2114 str = GET_TEXT(prf->rtxt);
2115 if ((str) && (*str))
2116 {
2117 int height;
2118
2119 redirect_errors_to(startup_height_error, (void *)prf);
2120 height = string_to_int(str, 1, "startup height");
2121 redirect_errors_to(NULL, NULL);
2122
2123 if (height > 0) ss->init_window_height = height;
2124 free_TEXT(str);
2125 }
2126 }
2127 }
2128
2129
2130 /* ---------------- ask-about-unsaved-edits ---------------- */
2131
2132 static bool rts_unsaved_edits = DEFAULT_ASK_ABOUT_UNSAVED_EDITS;
revert_unsaved_edits(prefs_info * prf)2133 static void revert_unsaved_edits(prefs_info *prf) {set_ask_about_unsaved_edits(rts_unsaved_edits);}
clear_unsaved_edits(prefs_info * prf)2134 static void clear_unsaved_edits(prefs_info *prf) {set_ask_about_unsaved_edits(DEFAULT_ASK_ABOUT_UNSAVED_EDITS);}
save_unsaved_edits(prefs_info * prf,FILE * fd)2135 static void save_unsaved_edits(prefs_info *prf, FILE *fd) {rts_unsaved_edits = ask_about_unsaved_edits(ss);}
reflect_unsaved_edits(prefs_info * prf)2136 static void reflect_unsaved_edits(prefs_info *prf) {SET_TOGGLE(prf->toggle, ask_about_unsaved_edits(ss));}
unsaved_edits_toggle(prefs_info * prf)2137 static void unsaved_edits_toggle(prefs_info *prf) {set_ask_about_unsaved_edits(GET_TOGGLE(prf->toggle));}
2138
help_unsaved_edits(prefs_info * prf)2139 static const char *help_unsaved_edits(prefs_info *prf)
2140 {
2141 return("\
2142 This option looks for unsaved edits when you \n\
2143 close a file, or exit Snd. If it finds any, it \n\
2144 asks you whether you want to save them.");
2145 }
2146
2147
2148
2149 /* ---------------- with-inset-graph ---------------- */
2150
2151 static bool rts_with_inset_graph = DEFAULT_WITH_INSET_GRAPH;
revert_with_inset_graph(prefs_info * prf)2152 static void revert_with_inset_graph(prefs_info *prf) {set_with_inset_graph(rts_with_inset_graph);}
clear_with_inset_graph(prefs_info * prf)2153 static void clear_with_inset_graph(prefs_info *prf) {set_with_inset_graph(DEFAULT_WITH_INSET_GRAPH);}
reflect_with_inset_graph(prefs_info * prf)2154 static void reflect_with_inset_graph(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_inset_graph(ss));}
2155
with_inset_graph_toggle(prefs_info * prf)2156 static void with_inset_graph_toggle(prefs_info *prf)
2157 {
2158 set_with_inset_graph(GET_TOGGLE(prf->toggle));
2159 for_each_chan(update_graph);
2160 }
2161
save_with_inset_graph(prefs_info * prf,FILE * fd)2162 static void save_with_inset_graph(prefs_info *prf, FILE *fd)
2163 {
2164 rts_with_inset_graph = GET_TOGGLE(prf->toggle);
2165 set_with_inset_graph(rts_with_inset_graph);
2166 }
2167
help_inset_graph(prefs_info * prf)2168 static const char *help_inset_graph(prefs_info *prf)
2169 {
2170 return("\
2171 This option displays a small graph of the entire sound \n\
2172 in the upper right corner of the screen with an indication \n\
2173 of where the current window is. If you click somewhere in the \n\
2174 little graph, the cursor and main window are moved to that spot.");
2175 }
2176
2177
2178
2179 /* ---------------- with-smpte-label ---------------- */
2180
2181 static bool rts_with_smpte_label = DEFAULT_WITH_SMPTE_LABEL;
revert_smpte(prefs_info * prf)2182 static void revert_smpte(prefs_info *prf) {set_with_smpte_label(rts_with_smpte_label);}
clear_smpte(prefs_info * prf)2183 static void clear_smpte(prefs_info *prf) {set_with_smpte_label(DEFAULT_WITH_SMPTE_LABEL);}
reflect_smpte(prefs_info * prf)2184 static void reflect_smpte(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_smpte_label(ss));}
2185
smpte_toggle(prefs_info * prf)2186 static void smpte_toggle(prefs_info *prf)
2187 {
2188 set_with_smpte_label(GET_TOGGLE(prf->toggle));
2189 for_each_chan(update_graph);
2190 }
2191
save_smpte(prefs_info * prf,FILE * fd)2192 static void save_smpte(prefs_info *prf, FILE *fd)
2193 {
2194 rts_with_smpte_label = GET_TOGGLE(prf->toggle);
2195 set_with_smpte_label(rts_with_smpte_label);
2196 }
2197
help_smpte(prefs_info * prf)2198 static const char *help_smpte(prefs_info *prf)
2199 {
2200 return(" This option displays the SMPTE data in the time domain graph. ");
2201 }
2202
2203
2204
2205 /* ---------------- with-pointer-focus ---------------- */
2206
2207 static bool rts_with_pointer_focus = DEFAULT_WITH_POINTER_FOCUS;
2208
revert_with_pointer_focus(prefs_info * prf)2209 static void revert_with_pointer_focus(prefs_info *prf) {set_with_pointer_focus(rts_with_pointer_focus);}
clear_with_pointer_focus(prefs_info * prf)2210 static void clear_with_pointer_focus(prefs_info *prf) {set_with_pointer_focus(DEFAULT_WITH_POINTER_FOCUS);}
with_pointer_focus_toggle(prefs_info * prf)2211 static void with_pointer_focus_toggle(prefs_info *prf) {set_with_pointer_focus(GET_TOGGLE(prf->toggle));}
reflect_with_pointer_focus(prefs_info * prf)2212 static void reflect_with_pointer_focus(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_pointer_focus(ss));}
2213
save_with_pointer_focus(prefs_info * prf,FILE * fd)2214 static void save_with_pointer_focus(prefs_info *prf, FILE *fd)
2215 {
2216 rts_with_pointer_focus = GET_TOGGLE(prf->toggle);
2217 set_with_pointer_focus(rts_with_pointer_focus);
2218 }
2219
2220
help_pointer_focus(prefs_info * prf)2221 static const char *help_pointer_focus(prefs_info *prf)
2222 {
2223 return("\
2224 If this option is set, when the mouse moves over a \n\
2225 text or graph widget, the widget is activated. ");
2226 }
2227
2228
2229
2230
2231 /* ---------------- cursor-size ---------------- */
2232
2233 static int rts_cursor_size = DEFAULT_CURSOR_SIZE;
2234
2235 #define MIN_CURSOR_SIZE 1
2236 #define MAX_CURSOR_SIZE 500
2237
revert_cursor_size(prefs_info * prf)2238 static void revert_cursor_size(prefs_info *prf) {set_cursor_size(rts_cursor_size);}
save_cursor_size(prefs_info * prf,FILE * ignore)2239 static void save_cursor_size(prefs_info *prf, FILE *ignore) {rts_cursor_size = cursor_size(ss);}
2240
2241
reflect_cursor_size(prefs_info * prf)2242 static void reflect_cursor_size(prefs_info *prf)
2243 {
2244 int_to_textfield(prf->text, cursor_size(ss));
2245 SET_SENSITIVE(prf->arrow_up, cursor_size(ss) < MAX_CURSOR_SIZE);
2246 SET_SENSITIVE(prf->arrow_down, cursor_size(ss) > MIN_CURSOR_SIZE);
2247 }
2248
2249
cursor_size_up(prefs_info * prf)2250 static void cursor_size_up(prefs_info *prf)
2251 {
2252 int size;
2253 size = cursor_size(ss) + 1;
2254 if (size >= MAX_CURSOR_SIZE) SET_SENSITIVE(prf->arrow_up, false);
2255 if (size > MIN_CURSOR_SIZE) SET_SENSITIVE(prf->arrow_down, true);
2256 set_cursor_size(size);
2257 int_to_textfield(prf->text, cursor_size(ss));
2258 }
2259
2260
cursor_size_down(prefs_info * prf)2261 static void cursor_size_down(prefs_info *prf)
2262 {
2263 int size;
2264 size = cursor_size(ss) - 1;
2265 if (size <= MIN_CURSOR_SIZE) SET_SENSITIVE(prf->arrow_down, false);
2266 if (size < MAX_CURSOR_SIZE) SET_SENSITIVE(prf->arrow_up, true);
2267 set_cursor_size(size);
2268 int_to_textfield(prf->text, cursor_size(ss));
2269 }
2270
2271
cursor_size_from_text(prefs_info * prf)2272 static void cursor_size_from_text(prefs_info *prf)
2273 {
2274 char *str;
2275 str = GET_TEXT(prf->text);
2276 if ((str) && (*str))
2277 {
2278 int size;
2279 prf->got_error = false;
2280
2281 redirect_errors_to(redirect_post_prefs_error, (void *)prf);
2282 size = string_to_int(str, 0, "cursor size");
2283 redirect_errors_to(NULL, NULL);
2284
2285 free_TEXT(str);
2286 if (!(prf->got_error))
2287 {
2288 if (size >= MIN_CURSOR_SIZE)
2289 {
2290 if (size <= MAX_CURSOR_SIZE)
2291 set_cursor_size(size);
2292 else va_post_prefs_error("%s > %d?", prf, str, MAX_CURSOR_SIZE);
2293 }
2294 else va_post_prefs_error("%s < %d?", prf, str, MIN_CURSOR_SIZE);
2295 }
2296 else prf->got_error = false;
2297 }
2298 else post_prefs_error("no size?", prf);
2299 }
2300
2301
2302
2303 /* ---------------- dot-size ---------------- */
2304
2305 static int rts_dot_size = DEFAULT_DOT_SIZE;
2306
2307 #define MIN_DOT_SIZE 0
2308 #define MAX_DOT_SIZE 100
2309
revert_dot_size(prefs_info * prf)2310 static void revert_dot_size(prefs_info *prf) {set_dot_size(rts_dot_size);}
save_dot_size(prefs_info * prf,FILE * ignore)2311 static void save_dot_size(prefs_info *prf, FILE *ignore) {rts_dot_size = dot_size(ss);}
2312
2313
reflect_dot_size(prefs_info * prf)2314 static void reflect_dot_size(prefs_info *prf)
2315 {
2316 int_to_textfield(prf->text, dot_size(ss));
2317 SET_SENSITIVE(prf->arrow_up, dot_size(ss) < MAX_DOT_SIZE);
2318 SET_SENSITIVE(prf->arrow_down, dot_size(ss) > MIN_DOT_SIZE);
2319 }
2320
2321
dot_size_up(prefs_info * prf)2322 static void dot_size_up(prefs_info *prf)
2323 {
2324 int size;
2325 size = dot_size(ss) + 1;
2326 if (size >= MAX_DOT_SIZE) SET_SENSITIVE(prf->arrow_up, false);
2327 if (size > MIN_DOT_SIZE) SET_SENSITIVE(prf->arrow_down, true);
2328 set_dot_size(size);
2329 int_to_textfield(prf->text, dot_size(ss));
2330 }
2331
2332
dot_size_down(prefs_info * prf)2333 static void dot_size_down(prefs_info *prf)
2334 {
2335 int size;
2336 size = dot_size(ss) - 1;
2337 if (size <= MIN_DOT_SIZE) SET_SENSITIVE(prf->arrow_down, false);
2338 if (size < MAX_DOT_SIZE) SET_SENSITIVE(prf->arrow_up, true);
2339 set_dot_size(size);
2340 int_to_textfield(prf->text, dot_size(ss));
2341 }
2342
2343
dot_size_from_text(prefs_info * prf)2344 static void dot_size_from_text(prefs_info *prf)
2345 {
2346 char *str;
2347 str = GET_TEXT(prf->text);
2348 if ((str) && (*str))
2349 {
2350 int size;
2351 prf->got_error = false;
2352
2353 redirect_errors_to(redirect_post_prefs_error, (void *)prf);
2354 size = string_to_int(str, 0, "dot size");
2355 redirect_errors_to(NULL, NULL);
2356
2357 free_TEXT(str);
2358 if (!(prf->got_error))
2359 {
2360 if (size >= MIN_DOT_SIZE)
2361 {
2362 if (size <= MAX_DOT_SIZE)
2363 set_dot_size(size);
2364 else va_post_prefs_error("%s > %d?", prf, str, MAX_DOT_SIZE);
2365 }
2366 else va_post_prefs_error("%s < %d?", prf, str, MIN_DOT_SIZE);
2367 }
2368 else prf->got_error = false;
2369 }
2370 else post_prefs_error("no size?", prf);
2371 }
2372
2373
2374 /* ---------------- fft-size ---------------- */
2375
2376 static mus_long_t rts_fft_size = DEFAULT_TRANSFORM_SIZE;
2377
2378 #define MAX_TRANSFORM_SIZE 1073741824
2379 #define MIN_TRANSFORM_SIZE 2
2380
revert_fft_size(prefs_info * prf)2381 static void revert_fft_size(prefs_info *prf) {set_transform_size(rts_fft_size);}
save_fft_size(prefs_info * prf,FILE * ignore)2382 static void save_fft_size(prefs_info *prf, FILE *ignore) {rts_fft_size = transform_size(ss);}
2383
2384
reflect_fft_size(prefs_info * prf)2385 static void reflect_fft_size(prefs_info *prf)
2386 {
2387 mus_long_t_to_textfield(prf->text, transform_size(ss));
2388 SET_SENSITIVE(prf->arrow_up, transform_size(ss) < MAX_TRANSFORM_SIZE);
2389 SET_SENSITIVE(prf->arrow_down, transform_size(ss) > MIN_TRANSFORM_SIZE);
2390 }
2391
2392
fft_size_up(prefs_info * prf)2393 static void fft_size_up(prefs_info *prf)
2394 {
2395 mus_long_t size;
2396 size = transform_size(ss) * 2;
2397 if (size >= MAX_TRANSFORM_SIZE) SET_SENSITIVE(prf->arrow_up, false);
2398 if (size > MIN_TRANSFORM_SIZE) SET_SENSITIVE(prf->arrow_down, true);
2399 set_transform_size(size);
2400 mus_long_t_to_textfield(prf->text, transform_size(ss));
2401 }
2402
2403
fft_size_down(prefs_info * prf)2404 static void fft_size_down(prefs_info *prf)
2405 {
2406 mus_long_t size;
2407 size = transform_size(ss) / 2;
2408 if (size <= MIN_TRANSFORM_SIZE) SET_SENSITIVE(prf->arrow_down, false);
2409 if (size < MAX_TRANSFORM_SIZE) SET_SENSITIVE(prf->arrow_up, true);
2410 set_transform_size(size);
2411 mus_long_t_to_textfield(prf->text, transform_size(ss));
2412 }
2413
2414
fft_size_from_text(prefs_info * prf)2415 static void fft_size_from_text(prefs_info *prf)
2416 {
2417 char *str;
2418 str = GET_TEXT(prf->text);
2419 if ((str) && (*str))
2420 {
2421 mus_long_t size;
2422 prf->got_error = false;
2423
2424 redirect_errors_to(redirect_post_prefs_error, (void *)prf);
2425 size = string_to_mus_long_t(str, MIN_TRANSFORM_SIZE, "size");
2426 redirect_errors_to(NULL, NULL);
2427
2428 free_TEXT(str);
2429 if (!(prf->got_error))
2430 {
2431 if (is_power_of_2(size))
2432 {
2433 if (size <= MAX_TRANSFORM_SIZE)
2434 set_transform_size(size);
2435 else va_post_prefs_error("%s > %d?", prf, str, MAX_TRANSFORM_SIZE);
2436 }
2437 else post_prefs_error("size must be a power of 2", prf);
2438 }
2439 else prf->got_error = false;
2440 }
2441 }
2442
2443
2444 /* ---------------- with-tracking-cursor ---------------- */
2445
2446 static tracking_cursor_t rts_with_tracking_cursor = DEFAULT_WITH_TRACKING_CURSOR;
2447 static mus_float_t rts_cursor_update_interval = DEFAULT_CURSOR_UPDATE_INTERVAL;
2448 static int rts_cursor_location_offset = DEFAULT_CURSOR_LOCATION_OFFSET;
2449
2450
revert_with_tracking_cursor(prefs_info * prf)2451 static void revert_with_tracking_cursor(prefs_info *prf)
2452 {
2453 set_with_tracking_cursor(ss, rts_with_tracking_cursor);
2454 set_cursor_update_interval(rts_cursor_update_interval);
2455 set_cursor_location_offset(rts_cursor_location_offset);
2456 }
2457
2458
save_with_tracking_cursor(prefs_info * prf,FILE * ignore)2459 static void save_with_tracking_cursor(prefs_info *prf, FILE *ignore)
2460 {
2461 rts_with_tracking_cursor = with_tracking_cursor(ss);
2462 rts_cursor_update_interval = cursor_update_interval(ss);
2463 rts_cursor_location_offset = cursor_location_offset(ss);
2464 }
2465
2466
reflect_with_tracking_cursor(prefs_info * prf)2467 static void reflect_with_tracking_cursor(prefs_info *prf)
2468 {
2469 SET_TOGGLE(prf->toggle, (with_tracking_cursor(ss) != DONT_TRACK));
2470 int_to_textfield(prf->rtxt, cursor_location_offset(ss));
2471 float_to_textfield(prf->text, cursor_update_interval(ss));
2472 }
2473
2474
with_tracking_cursor_toggle(prefs_info * prf)2475 static void with_tracking_cursor_toggle(prefs_info *prf)
2476 {
2477 set_with_tracking_cursor(ss, (GET_TOGGLE(prf->toggle)) ? TRACK_AND_RETURN : DONT_TRACK);
2478 }
2479
2480
cursor_location_text(prefs_info * prf)2481 static void cursor_location_text(prefs_info *prf)
2482 {
2483 char *str;
2484 str = GET_TEXT(prf->text);
2485 if ((str) && (*str))
2486 {
2487 double interval;
2488
2489 redirect_errors_to(any_error_to_text, (void *)prf);
2490 interval = (double)string_to_mus_float_t(str, 0.0, "cursor offset");
2491 redirect_errors_to(NULL, NULL);
2492
2493 if (!(prf->got_error))
2494 set_cursor_update_interval(interval);
2495 free_TEXT(str);
2496
2497 str = GET_TEXT(prf->rtxt);
2498 if ((str) && (*str))
2499 {
2500 int loc;
2501
2502 redirect_errors_to(any_error_to_text, (void *)prf);
2503 loc = string_to_int(str, 0, "cursor offset");
2504 redirect_errors_to(NULL, NULL);
2505
2506 if (!(prf->got_error))
2507 set_cursor_location_offset(loc);
2508 free_TEXT(str);
2509 }
2510 }
2511 }
2512
2513
2514 /* ---------------- channel-style ---------------- */
2515
2516 static channel_style_t rts_channel_style = DEFAULT_CHANNEL_STYLE;
2517
2518 static const char *channel_styles[NUM_CHANNEL_STYLES] = {"separate ", "combined ", "superimposed"};
2519
2520
reflect_channel_style(prefs_info * prf)2521 static void reflect_channel_style(prefs_info *prf) {set_radio_button(prf, (int)channel_style(ss));}
revert_channel_style(prefs_info * prf)2522 static void revert_channel_style(prefs_info *prf) {set_channel_style(rts_channel_style);}
save_channel_style(prefs_info * prf,FILE * ignore)2523 static void save_channel_style(prefs_info *prf, FILE *ignore) {rts_channel_style = channel_style(ss);}
2524
2525
channel_style_choice(prefs_info * prf)2526 static void channel_style_choice(prefs_info *prf)
2527 {
2528 if (GET_TOGGLE(prf->radio_button))
2529 set_channel_style((channel_style_t)which_radio_button(prf));
2530 }
2531
2532
2533 /* ---------------- cursor-style ---------------- */
2534
2535 static cursor_style_t rts_cursor_style = DEFAULT_CURSOR_STYLE;
2536
2537 #define NUM_CURSOR_STYLES 2
2538 static const char *cursor_styles[NUM_CURSOR_STYLES] = {"cross ", "line"};
2539
2540
reflect_cursor_style(prefs_info * prf)2541 static void reflect_cursor_style(prefs_info *prf) {set_radio_button(prf, (int)cursor_style(ss));}
revert_cursor_style(prefs_info * prf)2542 static void revert_cursor_style(prefs_info *prf) {set_cursor_style(rts_cursor_style);}
save_cursor_style(prefs_info * prf,FILE * ignore)2543 static void save_cursor_style(prefs_info *prf, FILE *ignore) {rts_cursor_style = cursor_style(ss);}
2544
2545
cursor_style_choice(prefs_info * prf)2546 static void cursor_style_choice(prefs_info *prf)
2547 {
2548 if (GET_TOGGLE(prf->radio_button))
2549 set_cursor_style((cursor_style_t)which_radio_button(prf));
2550 }
2551
2552
2553 /* ---------------- tracking-cursor-style ---------------- */
2554
2555 static cursor_style_t rts_tracking_cursor_style = DEFAULT_CURSOR_STYLE;
2556
2557
reflect_tracking_cursor_style(prefs_info * prf)2558 static void reflect_tracking_cursor_style(prefs_info *prf) {set_radio_button(prf, (int)tracking_cursor_style(ss));}
revert_tracking_cursor_style(prefs_info * prf)2559 static void revert_tracking_cursor_style(prefs_info *prf) {in_set_tracking_cursor_style(rts_tracking_cursor_style);}
save_tracking_cursor_style(prefs_info * prf,FILE * ignore)2560 static void save_tracking_cursor_style(prefs_info *prf, FILE *ignore) {rts_tracking_cursor_style = tracking_cursor_style(ss);}
2561
2562
tracking_cursor_style_choice(prefs_info * prf)2563 static void tracking_cursor_style_choice(prefs_info *prf)
2564 {
2565 if (GET_TOGGLE(prf->radio_button))
2566 in_set_tracking_cursor_style((cursor_style_t)which_radio_button(prf));
2567 }
2568
2569
2570 /* ---------------- transform-graph-type ---------------- */
2571
2572 static graph_type_t rts_transform_graph_type = DEFAULT_TRANSFORM_GRAPH_TYPE;
2573
2574 #define NUM_TRANSFORM_GRAPH_TYPES 3
2575 static const char *transform_graph_types[NUM_TRANSFORM_GRAPH_TYPES] = {"normal ", "sonogram ", "spectrogram"};
2576
2577
reflect_transform_graph_type(prefs_info * prf)2578 static void reflect_transform_graph_type(prefs_info *prf) {set_radio_button(prf, (int)transform_graph_type(ss));}
revert_transform_graph_type(prefs_info * prf)2579 static void revert_transform_graph_type(prefs_info *prf) {set_transform_graph_type(rts_transform_graph_type);}
save_transform_graph_type(prefs_info * prf,FILE * ignore)2580 static void save_transform_graph_type(prefs_info *prf, FILE *ignore) {rts_transform_graph_type = transform_graph_type(ss);}
2581
2582
transform_graph_type_choice(prefs_info * prf)2583 static void transform_graph_type_choice(prefs_info *prf)
2584 {
2585 if (GET_TOGGLE(prf->radio_button))
2586 set_transform_graph_type((graph_type_t)which_radio_button(prf));
2587 }
2588
2589
2590 /* ---------------- transform-normalization ---------------- */
2591
2592 static fft_normalize_t rts_transform_normalization = DEFAULT_TRANSFORM_NORMALIZATION;
2593
2594 static const char *transform_normalizations[NUM_TRANSFORM_NORMALIZATIONS] = {"none ", "by channel ", "by sound ", "global"};
2595
2596
reflect_transform_normalization(prefs_info * prf)2597 static void reflect_transform_normalization(prefs_info *prf) {set_radio_button(prf, (int)transform_normalization(ss));}
revert_transform_normalization(prefs_info * prf)2598 static void revert_transform_normalization(prefs_info *prf) {set_transform_normalization(rts_transform_normalization);}
save_transform_normalization(prefs_info * prf,FILE * ignore)2599 static void save_transform_normalization(prefs_info *prf, FILE *ignore) {rts_transform_normalization = transform_normalization(ss);}
2600
2601
transform_normalization_choice(prefs_info * prf)2602 static void transform_normalization_choice(prefs_info *prf)
2603 {
2604 if (GET_TOGGLE(prf->radio_button))
2605 set_transform_normalization((fft_normalize_t)which_radio_button(prf));
2606 }
2607
2608
2609 /* ---------------- graph-style ---------------- */
2610
2611 static graph_style_t rts_graph_style = DEFAULT_GRAPH_STYLE;
2612
2613 static const char *graph_styles[NUM_GRAPH_STYLES] = {"line ", "dot ", "filled ", "dot+line ", "lollipop"};
2614
2615
reflect_graph_style(prefs_info * prf)2616 static void reflect_graph_style(prefs_info *prf) {set_radio_button(prf, (int)graph_style(ss));}
revert_graph_style(prefs_info * prf)2617 static void revert_graph_style(prefs_info *prf) {set_graph_style(rts_graph_style);}
save_graph_style(prefs_info * prf,FILE * ignore)2618 static void save_graph_style(prefs_info *prf, FILE *ignore) {rts_graph_style = graph_style(ss);}
2619
2620
graph_style_choice(prefs_info * prf)2621 static void graph_style_choice(prefs_info *prf)
2622 {
2623 if (GET_TOGGLE(prf->radio_button))
2624 set_graph_style((graph_style_t)which_radio_button(prf));
2625 }
2626
2627
2628 /* ---------------- speed control ---------------- */
2629
2630 static speed_style_t rts_speed_control_style = DEFAULT_SPEED_CONTROL_STYLE;
2631 static int rts_speed_control_tones = DEFAULT_SPEED_CONTROL_TONES;
2632
2633 #define MIN_SPEED_CONTROL_SEMITONES 1
2634 static const char *speed_control_styles[NUM_SPEED_CONTROL_STYLES] = {"double ", "ratio ", "semitones:"};
2635
show_speed_control_semitones(prefs_info * prf)2636 static void show_speed_control_semitones(prefs_info *prf)
2637 {
2638 int_to_textfield(prf->text, speed_control_tones(ss));
2639 SET_SENSITIVE(prf->arrow_down, (speed_control_tones(ss) > MIN_SPEED_CONTROL_SEMITONES));
2640 }
2641
2642
speed_control_up(prefs_info * prf)2643 static void speed_control_up(prefs_info *prf)
2644 {
2645 in_set_speed_control_tones(ss, speed_control_tones(ss) + 1);
2646 show_speed_control_semitones(prf);
2647 }
2648
2649
speed_control_down(prefs_info * prf)2650 static void speed_control_down(prefs_info *prf)
2651 {
2652 in_set_speed_control_tones(ss, speed_control_tones(ss) - 1);
2653 show_speed_control_semitones(prf);
2654 }
2655
2656
speed_control_text(prefs_info * prf)2657 static void speed_control_text(prefs_info *prf)
2658 {
2659 char *str;
2660 str = GET_TEXT(prf->text);
2661 if ((str) && (*str))
2662 {
2663 int tones;
2664 prf->got_error = false;
2665 redirect_errors_to(redirect_post_prefs_error, (void *)prf);
2666 tones = string_to_int(str, MIN_SPEED_CONTROL_SEMITONES, "semitones");
2667 redirect_errors_to(NULL, NULL);
2668 free_TEXT(str);
2669 if (!(prf->got_error))
2670 {
2671 in_set_speed_control_tones(ss, tones);
2672 SET_SENSITIVE(prf->arrow_down, (speed_control_tones(ss) > MIN_SPEED_CONTROL_SEMITONES));
2673 }
2674 else prf->got_error = false;
2675 }
2676 }
2677
2678
reflect_speed_control(prefs_info * prf)2679 static void reflect_speed_control(prefs_info *prf)
2680 {
2681 set_radio_button(prf, (int)speed_control_style(ss));
2682 show_speed_control_semitones(prf);
2683 }
2684
2685
speed_control_choice(prefs_info * prf)2686 static void speed_control_choice(prefs_info *prf)
2687 {
2688 if (GET_TOGGLE(prf->radio_button))
2689 in_set_speed_control_style(ss, (speed_style_t)which_radio_button(prf));
2690 }
2691
2692
revert_speed_control(prefs_info * prf)2693 static void revert_speed_control(prefs_info *prf)
2694 {
2695 in_set_speed_control_style(ss, rts_speed_control_style);
2696 in_set_speed_control_tones(ss, rts_speed_control_tones);
2697 }
2698
2699
save_speed_control(prefs_info * prf,FILE * ignore)2700 static void save_speed_control(prefs_info *prf, FILE *ignore)
2701 {
2702 rts_speed_control_style = speed_control_style(ss);
2703 rts_speed_control_tones = speed_control_tones(ss);
2704 }
2705
2706
2707 /* ---------------- default-output-chans etc ---------------- */
2708
2709 static int rts_default_output_chans = DEFAULT_OUTPUT_CHANS;
2710 static int rts_default_output_srate = DEFAULT_OUTPUT_SRATE;
2711 static mus_sample_t rts_default_output_sample_type = DEFAULT_OUTPUT_SAMPLE_TYPE;
2712 static mus_header_t rts_default_output_header_type = DEFAULT_OUTPUT_HEADER_TYPE;
2713
2714 static prefs_info *output_sample_type_prf = NULL, *output_header_type_prf = NULL;
2715
2716 #define NUM_OUTPUT_CHAN_CHOICES 4
2717 static const char *output_chan_choices[NUM_OUTPUT_CHAN_CHOICES] = {"1 ", "2 ", "4 ", "8"};
2718 static int output_chans[NUM_OUTPUT_CHAN_CHOICES] = {1, 2, 4, 8};
2719
2720 #define NUM_OUTPUT_SRATE_CHOICES 4
2721 static const char *output_srate_choices[NUM_OUTPUT_SRATE_CHOICES] = {"8000 ", "22050 ", "44100 ", "48000"};
2722 static int output_srates[NUM_OUTPUT_SRATE_CHOICES] = {8000, 22050, 44100, 48000};
2723
2724 #define NUM_OUTPUT_HEADER_TYPE_CHOICES 7
2725 static const char *output_header_type_choices[NUM_OUTPUT_HEADER_TYPE_CHOICES] = {"aifc ", "wave ", "au ", "rf64 ", "nist ", "aiff ", "caff"};
2726 static mus_header_t output_header_types[NUM_OUTPUT_HEADER_TYPE_CHOICES] = {MUS_AIFC, MUS_RIFF, MUS_NEXT, MUS_RF64, MUS_NIST, MUS_AIFF, MUS_CAFF};
2727
2728 #define NUM_OUTPUT_SAMPLE_TYPE_CHOICES 4
2729 static const char *output_sample_type_choices[NUM_OUTPUT_SAMPLE_TYPE_CHOICES] = {"short ", "int ", "double ", "double"};
2730 static mus_sample_t output_sample_types[NUM_OUTPUT_SAMPLE_TYPE_CHOICES] = {MUS_LSHORT, MUS_LINT, MUS_LFLOAT, MUS_LDOUBLE};
2731
2732
header_to_sample_type(mus_header_t ht,mus_sample_t samp_type)2733 static mus_sample_t header_to_sample_type(mus_header_t ht, mus_sample_t samp_type)
2734 {
2735 /* nist -> short or int (lb)
2736 aiff -> short or int (b)
2737 aifc -> any (b)
2738 next -> any (b)
2739 wave -> any (l)
2740 caff -> any
2741 */
2742 switch (ht)
2743 {
2744 case MUS_NEXT: case MUS_AIFC:
2745 switch (samp_type)
2746 {
2747 case MUS_LSHORT: return(MUS_BSHORT); break;
2748 case MUS_LINT: return(MUS_BINT); break;
2749 case MUS_LFLOAT: return(MUS_BFLOAT); break;
2750 case MUS_LDOUBLE: return(MUS_BDOUBLE); break;
2751 default: break;
2752 }
2753 break;
2754
2755 case MUS_AIFF:
2756 switch (samp_type)
2757 {
2758 case MUS_LSHORT: return(MUS_BSHORT); break;
2759 case MUS_LINT: return(MUS_BINT); break;
2760 case MUS_LFLOAT: case MUS_LDOUBLE: case MUS_BFLOAT: case MUS_BDOUBLE: return(MUS_BINT); break;
2761 default: break;
2762 }
2763 break;
2764
2765 case MUS_NIST:
2766 switch (samp_type)
2767 {
2768 case MUS_LFLOAT: case MUS_LDOUBLE: return(MUS_LINT); break;
2769 case MUS_BFLOAT: case MUS_BDOUBLE: return(MUS_BINT); break;
2770 default: break;
2771 }
2772 break;
2773
2774 case MUS_RF64:
2775 case MUS_RIFF:
2776 switch (samp_type)
2777 {
2778 case MUS_BSHORT: return(MUS_LSHORT); break;
2779 case MUS_BINT: return(MUS_LINT); break;
2780 case MUS_BFLOAT: return(MUS_LFLOAT); break;
2781 case MUS_BDOUBLE: return(MUS_LDOUBLE); break;
2782 default: break;
2783 }
2784 break;
2785
2786 case MUS_CAFF:
2787 if (samp_type == MUS_LINT)
2788 return(MUS_LINTN);
2789 if (samp_type == MUS_BINT)
2790 return(MUS_BINTN);
2791 break;
2792
2793 default: break;
2794 }
2795 return(samp_type);
2796 }
2797
2798
chans_to_button(int chans)2799 static int chans_to_button(int chans)
2800 {
2801 int i;
2802 for (i = 0; i < NUM_OUTPUT_CHAN_CHOICES; i++)
2803 if (chans == output_chans[i])
2804 return(i);
2805 return(0);
2806 }
2807
2808
reflect_default_output_chans(prefs_info * prf)2809 static void reflect_default_output_chans(prefs_info *prf) {set_radio_button(prf, chans_to_button(default_output_chans(ss)));}
revert_default_output_chans(prefs_info * prf)2810 static void revert_default_output_chans(prefs_info *prf) {set_default_output_chans(rts_default_output_chans);}
save_default_output_chans(prefs_info * prf,FILE * ignore)2811 static void save_default_output_chans(prefs_info *prf, FILE *ignore) {rts_default_output_chans = default_output_chans(ss);}
2812
2813
default_output_chans_choice(prefs_info * prf)2814 static void default_output_chans_choice(prefs_info *prf)
2815 {
2816 if (GET_TOGGLE(prf->radio_button))
2817 set_default_output_chans(output_chans[which_radio_button(prf)]);
2818 }
2819
2820
srate_to_button(int srate)2821 static int srate_to_button(int srate)
2822 {
2823 int i;
2824 for (i = 0; i < NUM_OUTPUT_SRATE_CHOICES; i++)
2825 if (output_srates[i] == srate)
2826 return(i);
2827 return(0);
2828 }
2829
2830
reflect_default_output_srate(prefs_info * prf)2831 static void reflect_default_output_srate(prefs_info *prf) {set_radio_button(prf, srate_to_button(default_output_srate(ss)));}
revert_default_output_srate(prefs_info * prf)2832 static void revert_default_output_srate(prefs_info *prf) {set_default_output_srate(rts_default_output_srate);}
save_default_output_srate(prefs_info * prf,FILE * ignore)2833 static void save_default_output_srate(prefs_info *prf, FILE *ignore) {rts_default_output_srate = default_output_srate(ss);}
2834
2835
default_output_srate_choice(prefs_info * prf)2836 static void default_output_srate_choice(prefs_info *prf)
2837 {
2838 if (GET_TOGGLE(prf->radio_button))
2839 set_default_output_srate(output_srates[which_radio_button(prf)]);
2840 }
2841
2842
reflect_default_output_header_type(prefs_info * prf)2843 static void reflect_default_output_header_type(prefs_info *prf)
2844 {
2845 int which = -1;
2846 switch (default_output_header_type(ss))
2847 {
2848 case MUS_AIFC: which = 0; break;
2849 case MUS_AIFF: which = 5; break;
2850 case MUS_RIFF: which = 1; break;
2851 case MUS_RF64: which = 3; break;
2852 case MUS_NEXT: which = 2; break;
2853 case MUS_NIST: which = 4; break;
2854 case MUS_CAFF: which = 6; break;
2855 default: break;
2856 }
2857 set_radio_button(prf, which);
2858 }
2859
2860
revert_default_output_header_type(prefs_info * prf)2861 static void revert_default_output_header_type(prefs_info *prf)
2862 {
2863 set_default_output_header_type(rts_default_output_header_type);
2864 }
2865
2866
save_default_output_header_type(prefs_info * prf,FILE * ignore)2867 static void save_default_output_header_type(prefs_info *prf, FILE *ignore)
2868 {
2869 rts_default_output_header_type = default_output_header_type(ss);
2870 }
2871
2872
reflect_default_output_sample_type(prefs_info * prf)2873 static void reflect_default_output_sample_type(prefs_info *prf)
2874 {
2875 int which = -1;
2876 switch (default_output_sample_type(ss))
2877 {
2878 case MUS_LINT: case MUS_BINT: which = 1; break;
2879 case MUS_LSHORT: case MUS_BSHORT: which = 0; break;
2880 case MUS_LFLOAT: case MUS_BFLOAT: which = 2; break;
2881 case MUS_LDOUBLE: case MUS_BDOUBLE: which = 3; break;
2882 default: break;
2883 }
2884 set_radio_button(prf, which);
2885 }
2886
2887
default_output_header_type_choice(prefs_info * prf)2888 static void default_output_header_type_choice(prefs_info *prf)
2889 {
2890 if (GET_TOGGLE(prf->radio_button))
2891 {
2892 set_default_output_header_type(output_header_types[which_radio_button(prf)]);
2893 set_default_output_sample_type(header_to_sample_type(default_output_header_type(ss), default_output_sample_type(ss)));
2894 reflect_default_output_sample_type(output_sample_type_prf);
2895 }
2896 }
2897
revert_default_output_sample_type(prefs_info * prf)2898 static void revert_default_output_sample_type(prefs_info *prf)
2899 {
2900 set_default_output_sample_type(rts_default_output_sample_type);
2901 }
2902
2903
save_default_output_sample_type(prefs_info * prf,FILE * ignore)2904 static void save_default_output_sample_type(prefs_info *prf, FILE *ignore)
2905 {
2906 rts_default_output_sample_type = default_output_sample_type(ss);
2907 }
2908
2909
default_output_sample_type_choice(prefs_info * prf)2910 static void default_output_sample_type_choice(prefs_info *prf)
2911 {
2912 if (GET_TOGGLE(prf->radio_button))
2913 {
2914 int which;
2915 which = which_radio_button(prf);
2916 set_default_output_sample_type(output_sample_types[which]);
2917
2918 switch (default_output_sample_type(ss))
2919 {
2920 case MUS_LSHORT:
2921 switch (default_output_header_type(ss))
2922 {
2923 case MUS_AIFC: case MUS_AIFF: case MUS_NEXT:
2924 set_default_output_sample_type(MUS_BSHORT);
2925 break;
2926 default: break;
2927 }
2928 break;
2929
2930 case MUS_LINT:
2931 switch (default_output_header_type(ss))
2932 {
2933 case MUS_AIFC: case MUS_AIFF: case MUS_NEXT:
2934 set_default_output_sample_type(MUS_BINT);
2935 break;
2936 default: break;
2937 }
2938 break;
2939
2940 case MUS_LFLOAT:
2941 switch (default_output_header_type(ss))
2942 {
2943 case MUS_AIFC: case MUS_NEXT:
2944 set_default_output_sample_type(MUS_BFLOAT);
2945 break;
2946 case MUS_AIFF:
2947 set_default_output_header_type(MUS_AIFC);
2948 set_default_output_sample_type(MUS_BFLOAT);
2949 break;
2950 case MUS_NIST:
2951 set_default_output_header_type(MUS_RIFF);
2952 break;
2953 default: break;
2954 }
2955 break;
2956
2957 case MUS_LDOUBLE:
2958 switch (default_output_header_type(ss))
2959 {
2960 case MUS_AIFC: case MUS_NEXT:
2961 set_default_output_sample_type(MUS_BDOUBLE);
2962 break;
2963 case MUS_AIFF:
2964 set_default_output_header_type(MUS_AIFC);
2965 set_default_output_sample_type(MUS_BDOUBLE);
2966 break;
2967 case MUS_NIST:
2968 set_default_output_header_type(MUS_RIFF);
2969 break;
2970 default: break;
2971 }
2972 break;
2973
2974 default: break;
2975 }
2976 reflect_default_output_header_type(output_header_type_prf);
2977 }
2978 }
2979
2980
2981 /* ---------------- raw sound defaults ---------------- */
2982
2983 static int rts_raw_chans = DEFAULT_OUTPUT_CHANS;
2984 static int rts_raw_srate = DEFAULT_OUTPUT_SRATE;
2985 static mus_sample_t rts_raw_sample_type = DEFAULT_OUTPUT_SAMPLE_TYPE;
2986
revert_raw_chans(prefs_info * prf)2987 static void revert_raw_chans(prefs_info *prf)
2988 {
2989 int srate = 0, chans = 0;
2990 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
2991 mus_header_raw_defaults(&srate, &chans, &samp_type);
2992 chans = rts_raw_chans;
2993 mus_header_set_raw_defaults(srate, chans, samp_type);
2994 }
2995
2996
save_raw_chans(prefs_info * prf,FILE * ignore)2997 static void save_raw_chans(prefs_info *prf, FILE *ignore)
2998 {
2999 int srate = 0, chans = 0;
3000 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3001 mus_header_raw_defaults(&srate, &chans, &samp_type);
3002 rts_raw_chans = chans;
3003 }
3004
3005
reflect_raw_chans(prefs_info * prf)3006 static void reflect_raw_chans(prefs_info *prf)
3007 {
3008 int srate = 0, chans = 0;
3009 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3010 mus_header_raw_defaults(&srate, &chans, &samp_type);
3011 int_to_textfield(prf->text, chans);
3012 }
3013
3014
raw_chans_choice(prefs_info * prf)3015 static void raw_chans_choice(prefs_info *prf)
3016 {
3017 char *str;
3018 str = GET_TEXT(prf->text);
3019 if (str)
3020 {
3021 int srate = 0, chans = 0;
3022 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3023 mus_header_raw_defaults(&srate, &chans, &samp_type);
3024 redirect_errors_to(any_error_to_text, (void *)prf);
3025 chans = string_to_int(str, 1, "raw chans");
3026 redirect_errors_to(NULL, NULL);
3027 if (!(prf->got_error))
3028 mus_header_set_raw_defaults(srate, chans, samp_type);
3029 free_TEXT(str);
3030 }
3031 }
3032
3033
revert_raw_srate(prefs_info * prf)3034 static void revert_raw_srate(prefs_info *prf)
3035 {
3036 int srate = 0, chans = 0;
3037 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3038 mus_header_raw_defaults(&srate, &chans, &samp_type);
3039 srate = rts_raw_srate;
3040 mus_header_set_raw_defaults(srate, chans, samp_type);
3041 }
3042
3043
save_raw_srate(prefs_info * prf,FILE * ignore)3044 static void save_raw_srate(prefs_info *prf, FILE *ignore)
3045 {
3046 int srate = 0, chans = 0;
3047 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3048 mus_header_raw_defaults(&srate, &chans, &samp_type);
3049 rts_raw_srate = srate;
3050 }
3051
3052
reflect_raw_srate(prefs_info * prf)3053 static void reflect_raw_srate(prefs_info *prf)
3054 {
3055 int srate = 0, chans = 0;
3056 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3057 mus_header_raw_defaults(&srate, &chans, &samp_type);
3058 int_to_textfield(prf->text, srate);
3059 }
3060
3061
raw_srate_choice(prefs_info * prf)3062 static void raw_srate_choice(prefs_info *prf)
3063 {
3064 char *str;
3065 str = GET_TEXT(prf->text);
3066 if (str)
3067 {
3068 int srate = 0, chans = 0;
3069 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3070 mus_header_raw_defaults(&srate, &chans, &samp_type);
3071 redirect_errors_to(any_error_to_text, (void *)prf);
3072 srate = string_to_int(str, 1, "raw srate");
3073 redirect_errors_to(NULL, NULL);
3074 if (!(prf->got_error))
3075 mus_header_set_raw_defaults(srate, chans, samp_type);
3076 free_TEXT(str);
3077 }
3078 }
3079
3080
raw_sample_type_to_string(mus_sample_t samp_type)3081 static char *raw_sample_type_to_string(mus_sample_t samp_type)
3082 {
3083 /* the "mus-" prefix carries no information in this context, so strip it off */
3084 const char *name;
3085 name = mus_sample_type_to_string(samp_type);
3086 if (name)
3087 {
3088 char *rtn;
3089 int i, j, len;
3090 len = strlen(name);
3091 rtn = (char *)calloc(len, sizeof(char));
3092 for (i = 0, j = 4; j < len; i++, j++)
3093 {
3094 if (name[j] == '-')
3095 {
3096 rtn[i] = 'u';
3097 return(rtn);
3098 }
3099 else rtn[i] = name[j];
3100 }
3101 return(rtn);
3102 }
3103 return(mus_strdup("unknown"));
3104 }
3105
3106
revert_raw_sample_type(prefs_info * prf)3107 static void revert_raw_sample_type(prefs_info *prf)
3108 {
3109 int srate = 0, chans = 0;
3110 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3111 mus_header_raw_defaults(&srate, &chans, &samp_type);
3112 samp_type = rts_raw_sample_type;
3113 mus_header_set_raw_defaults(srate, chans, samp_type);
3114 }
3115
3116
save_raw_sample_type(prefs_info * prf,FILE * ignore)3117 static void save_raw_sample_type(prefs_info *prf, FILE *ignore)
3118 {
3119 int srate = 0, chans = 0;
3120 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3121 mus_header_raw_defaults(&srate, &chans, &samp_type);
3122 rts_raw_sample_type = samp_type;
3123 }
3124
3125
reflect_raw_sample_type(prefs_info * prf)3126 static void reflect_raw_sample_type(prefs_info *prf)
3127 {
3128 int srate = 0, chans = 0;
3129 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3130 char *str;
3131 mus_header_raw_defaults(&srate, &chans, &samp_type);
3132 str = raw_sample_type_to_string(samp_type);
3133 SET_TEXT(prf->text, str);
3134 free(str);
3135 }
3136
3137
3138 static char **raw_sample_type_choices = NULL;
3139
raw_sample_type_from_text(prefs_info * prf)3140 static void raw_sample_type_from_text(prefs_info *prf)
3141 {
3142 char *str;
3143 str = GET_TEXT(prf->text);
3144 if (str)
3145 {
3146 int i, srate = 0, chans = 0;
3147 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3148 mus_header_raw_defaults(&srate, &chans, &samp_type);
3149 for (i = 0; i < MUS_NUM_SAMPLES - 1; i++)
3150 if (STRCMP(raw_sample_type_choices[i], str) == 0)
3151 {
3152 mus_header_set_raw_defaults(srate, chans, (mus_sample_t)(i + 1)); /* skipping MUS_UNKNOWN_SAMPLE = 0 */
3153 reflect_raw_sample_type(prf);
3154 free_TEXT(str);
3155 return;
3156 }
3157 }
3158 }
3159
3160
3161 #if USE_MOTIF
raw_sample_type_from_menu(prefs_info * prf,char * value)3162 static void raw_sample_type_from_menu(prefs_info *prf, char *value)
3163 {
3164 int i, srate = 0, chans = 0;
3165 mus_sample_t samp_type = MUS_UNKNOWN_SAMPLE;
3166 mus_header_raw_defaults(&srate, &chans, &samp_type);
3167 for (i = 0; i < MUS_NUM_SAMPLES - 1; i++)
3168 if (STRCMP(raw_sample_type_choices[i], value) == 0)
3169 {
3170 mus_header_set_raw_defaults(srate, chans, (mus_sample_t)(i + 1));
3171 SET_TEXT(prf->text, raw_sample_type_choices[i]);
3172 return;
3173 }
3174 }
3175 #endif
3176
3177
3178 /* ---------------- with-toolbar ---------------- */
3179
3180 static bool rts_with_toolbar = DEFAULT_WITH_TOOLBAR;
3181
help_with_toolbar(prefs_info * prf)3182 static const char *help_with_toolbar(prefs_info *prf)
3183 {
3184 return(" If this is set, a toolbar is displayed. ");
3185 }
3186
revert_with_toolbar(prefs_info * prf)3187 static void revert_with_toolbar(prefs_info *prf) {set_with_toolbar_and_display(rts_with_toolbar);}
clear_with_toolbar(prefs_info * prf)3188 static void clear_with_toolbar(prefs_info *prf) {set_with_toolbar_and_display(DEFAULT_WITH_TOOLBAR);}
reflect_with_toolbar(prefs_info * prf)3189 static void reflect_with_toolbar(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_toolbar(ss));}
save_with_toolbar(prefs_info * prf,FILE * fd)3190 static void save_with_toolbar(prefs_info *prf, FILE *fd) {rts_with_toolbar = with_toolbar(ss);}
toggle_with_toolbar(prefs_info * prf)3191 static void toggle_with_toolbar(prefs_info *prf) {set_with_toolbar_and_display(GET_TOGGLE(prf->toggle));}
3192
3193
3194
3195 /* ---------------- with-tooltips ---------------- */
3196
3197 static bool rts_with_tooltips = DEFAULT_WITH_TOOLTIPS;
3198
help_with_tooltips(prefs_info * prf)3199 static const char *help_with_tooltips(prefs_info *prf)
3200 {
3201 return(" If this is set, tooltips may be displayed. ");
3202 }
3203
revert_with_tooltips(prefs_info * prf)3204 static void revert_with_tooltips(prefs_info *prf) {set_with_tooltips(rts_with_tooltips);}
clear_with_tooltips(prefs_info * prf)3205 static void clear_with_tooltips(prefs_info *prf) {set_with_tooltips(DEFAULT_WITH_TOOLTIPS);}
reflect_with_tooltips(prefs_info * prf)3206 static void reflect_with_tooltips(prefs_info *prf) {SET_TOGGLE(prf->toggle, with_tooltips(ss));}
save_with_tooltips(prefs_info * prf,FILE * fd)3207 static void save_with_tooltips(prefs_info *prf, FILE *fd) {rts_with_tooltips = with_tooltips(ss);}
toggle_with_tooltips(prefs_info * prf)3208 static void toggle_with_tooltips(prefs_info *prf) {set_with_tooltips(GET_TOGGLE(prf->toggle));}
3209
3210
3211
3212 /* ---------------- remember-sound-state ---------------- */
3213
3214 static bool rts_remember_sound_state = DEFAULT_REMEMBER_SOUND_STATE;
3215
help_remember_sound_state(prefs_info * prf)3216 static const char *help_remember_sound_state(prefs_info *prf)
3217 {
3218 return("\
3219 This option causes Snd to save most of a sound's display \n\
3220 state when it is closed, and if that same sound is later re-opened, \n\
3221 Snd restores the previous state. This only takes effect upon restarting Snd.");
3222 }
3223
revert_remember_sound_state(prefs_info * prf)3224 static void revert_remember_sound_state(prefs_info *prf) {set_remember_sound_state(rts_remember_sound_state);}
clear_remember_sound_state(prefs_info * prf)3225 static void clear_remember_sound_state(prefs_info *prf) {set_remember_sound_state(DEFAULT_REMEMBER_SOUND_STATE);}
reflect_remember_sound_state(prefs_info * prf)3226 static void reflect_remember_sound_state(prefs_info *prf) {SET_TOGGLE(prf->toggle, remember_sound_state(ss));}
save_remember_sound_state(prefs_info * prf,FILE * fd)3227 static void save_remember_sound_state(prefs_info *prf, FILE *fd) {rts_remember_sound_state = remember_sound_state(ss);}
toggle_remember_sound_state(prefs_info * prf)3228 static void toggle_remember_sound_state(prefs_info *prf) {set_remember_sound_state(GET_TOGGLE(prf->toggle));}
3229
3230
3231
3232 /* ---------------- show-axes ---------------- */
3233
3234 static show_axes_t rts_show_axes = DEFAULT_SHOW_AXES;
3235
3236 static const char *show_axes_choices[NUM_SHOW_AXES] = {"none", "X and Y", "just X", "X and Y unlabelled", "just X unlabelled", "bare X"};
3237
reflect_show_axes(prefs_info * prf)3238 static void reflect_show_axes(prefs_info *prf) {SET_TEXT(prf->text, (char *)show_axes_choices[(int)show_axes(ss)]);}
revert_show_axes(prefs_info * prf)3239 static void revert_show_axes(prefs_info *prf) {set_show_axes(rts_show_axes);}
clear_show_axes(prefs_info * prf)3240 static void clear_show_axes(prefs_info *prf) {set_show_axes(DEFAULT_SHOW_AXES);}
save_show_axes(prefs_info * prf,FILE * ignore)3241 static void save_show_axes(prefs_info *prf, FILE *ignore) {rts_show_axes = show_axes(ss);}
3242
3243
3244 #if USE_MOTIF
show_axes_from_menu(prefs_info * prf,char * value)3245 static void show_axes_from_menu(prefs_info *prf, char *value)
3246 {
3247 int i;
3248 for (i = 0; i < NUM_SHOW_AXES; i++)
3249 if (mus_strcmp(value, show_axes_choices[i]))
3250 {
3251 set_show_axes((show_axes_t)i);
3252 SET_TEXT(prf->text, value);
3253 return;
3254 }
3255 }
3256 #endif
3257
3258
show_axes_from_text(prefs_info * prf)3259 static void show_axes_from_text(prefs_info *prf)
3260 {
3261 char *str;
3262 str = GET_TEXT(prf->text);
3263 if ((str) && (*str))
3264 {
3265 char *trimmed_str;
3266 trimmed_str = trim_string(str);
3267 free_TEXT(str);
3268 if (mus_strlen(trimmed_str) > 0)
3269 {
3270 int i, curpos = -1;
3271 for (i = 0; i < NUM_SHOW_AXES; i++)
3272 if (STRCMP(trimmed_str, show_axes_choices[i]) == 0)
3273 {
3274 curpos = i;
3275 break;
3276 }
3277 if (curpos >= 0)
3278 set_show_axes((show_axes_t)curpos);
3279 else post_prefs_error("unknown axis choice", prf);
3280 }
3281 else post_prefs_error("need an axis choice", prf);
3282 free(trimmed_str);
3283 }
3284 else post_prefs_error("need an axis choice", prf);
3285 }
3286
3287
3288
3289 /* ---------------- x-axis-style ---------------- */
3290
3291 static x_axis_style_t rts_x_axis_style = DEFAULT_X_AXIS_STYLE;
3292
3293 static const char *x_axis_styles[NUM_X_AXIS_STYLES] = {"seconds", "samples", "% of total", "beats", "measures", "clock"};
3294
reflect_x_axis_style(prefs_info * prf)3295 static void reflect_x_axis_style(prefs_info *prf) {SET_TEXT(prf->text, (char *)x_axis_styles[(int)x_axis_style(ss)]);}
revert_x_axis_style(prefs_info * prf)3296 static void revert_x_axis_style(prefs_info *prf) {set_x_axis_style(rts_x_axis_style);}
clear_x_axis_style(prefs_info * prf)3297 static void clear_x_axis_style(prefs_info *prf) {set_x_axis_style(DEFAULT_X_AXIS_STYLE);}
save_x_axis_style(prefs_info * prf,FILE * ignore)3298 static void save_x_axis_style(prefs_info *prf, FILE *ignore) {rts_x_axis_style = x_axis_style(ss);}
3299
3300
3301 #if USE_MOTIF
x_axis_style_from_menu(prefs_info * prf,char * value)3302 static void x_axis_style_from_menu(prefs_info *prf, char *value)
3303 {
3304 int i;
3305 for (i = 0; i < NUM_X_AXIS_STYLES; i++)
3306 if (mus_strcmp(value, x_axis_styles[i]))
3307 {
3308 set_x_axis_style((x_axis_style_t)i);
3309 SET_TEXT(prf->text, value);
3310 return;
3311 }
3312 }
3313 #endif
3314
3315
x_axis_style_from_text(prefs_info * prf)3316 static void x_axis_style_from_text(prefs_info *prf)
3317 {
3318 char *str;
3319 str = GET_TEXT(prf->text);
3320 if ((str) && (*str))
3321 {
3322 char *trimmed_str;
3323 trimmed_str = trim_string(str);
3324 free_TEXT(str);
3325 if (mus_strlen(trimmed_str) > 0)
3326 {
3327 int i, curpos = -1;
3328 for (i = 0; i < NUM_X_AXIS_STYLES; i++)
3329 if (STRCMP(trimmed_str, x_axis_styles[i]) == 0)
3330 {
3331 curpos = i;
3332 break;
3333 }
3334 if (curpos >= 0)
3335 set_x_axis_style((x_axis_style_t)curpos);
3336 else post_prefs_error("unknown axis style", prf);
3337 }
3338 else post_prefs_error("need an axis style", prf);
3339 free(trimmed_str);
3340 }
3341 else post_prefs_error("need an axis style", prf);
3342 }
3343
3344
3345
3346 /* ---------------- transform-type ---------------- */
3347
3348 static int rts_transform_type = DEFAULT_TRANSFORM_TYPE;
3349
3350 static const char *transform_types[NUM_BUILTIN_TRANSFORM_TYPES] = {"Fourier", "Wavelet", "Walsh", "Autocorrelate", "Cepstrum", "Haar"};
3351
3352 static list_completer_info *transform_type_completer_info = NULL;
3353
3354
reflect_transform_type(prefs_info * prf)3355 static void reflect_transform_type(prefs_info *prf)
3356 {
3357 SET_TEXT(prf->text, (char *)transform_types[mus_iclamp(0, transform_type(ss), NUM_BUILTIN_TRANSFORM_TYPES - 1)]);
3358 }
3359
3360
revert_transform_type(prefs_info * prf)3361 static void revert_transform_type(prefs_info *prf) {set_transform_type(rts_transform_type);}
clear_transform_type(prefs_info * prf)3362 static void clear_transform_type(prefs_info *prf) {set_transform_type(DEFAULT_TRANSFORM_TYPE);}
save_transform_type(prefs_info * prf,FILE * ignore)3363 static void save_transform_type(prefs_info *prf, FILE *ignore) {rts_transform_type = transform_type(ss);}
3364
3365
transform_type_completer(widget_t w,const char * text,void * data)3366 static char *transform_type_completer(widget_t w, const char *text, void *data)
3367 {
3368 if (!transform_type_completer_info)
3369 {
3370 transform_type_completer_info = (list_completer_info *)calloc(1, sizeof(list_completer_info));
3371 transform_type_completer_info->exact_match = false;
3372 transform_type_completer_info->values = (char **)transform_types;
3373 transform_type_completer_info->num_values = NUM_BUILTIN_TRANSFORM_TYPES;
3374 transform_type_completer_info->values_size = NUM_BUILTIN_TRANSFORM_TYPES;
3375 }
3376 return(list_completer(w, text, (void *)transform_type_completer_info));
3377 }
3378
3379
3380 #if USE_MOTIF
transform_type_from_menu(prefs_info * prf,char * value)3381 static void transform_type_from_menu(prefs_info *prf, char *value)
3382 {
3383 int i;
3384 for (i = 0; i < NUM_BUILTIN_TRANSFORM_TYPES; i++)
3385 if (mus_strcmp(value, transform_types[i]))
3386 {
3387 set_transform_type(i);
3388 SET_TEXT(prf->text, value);
3389 return;
3390 }
3391 }
3392 #endif
3393
3394
transform_type_from_text(prefs_info * prf)3395 static void transform_type_from_text(prefs_info *prf)
3396 {
3397 char *str;
3398 str = GET_TEXT(prf->text);
3399 if ((str) && (*str))
3400 {
3401 char *trimmed_str;
3402 trimmed_str = trim_string(str);
3403 free_TEXT(str);
3404 if (mus_strlen(trimmed_str) > 0)
3405 {
3406 int i, curpos = -1;
3407 for (i = 0; i < NUM_BUILTIN_TRANSFORM_TYPES; i++)
3408 if (STRCMP(trimmed_str, transform_types[i]) == 0)
3409 {
3410 curpos = i;
3411 break;
3412 }
3413 if (curpos >= 0)
3414 set_transform_type(curpos);
3415 else post_prefs_error("unknown transform", prf);
3416 }
3417 else post_prefs_error("no transform?", prf);
3418 free(trimmed_str);
3419 }
3420 else post_prefs_error("no transform?", prf);
3421 }
3422
3423
3424
3425 /* -------- fft-window -------- */
3426
3427 static mus_fft_window_t rts_fft_window = DEFAULT_FFT_WINDOW;
3428
reflect_fft_window(prefs_info * prf)3429 static void reflect_fft_window(prefs_info *prf) {SET_TEXT(prf->text, (char *)mus_fft_window_name(fft_window(ss)));}
revert_fft_window(prefs_info * prf)3430 static void revert_fft_window(prefs_info *prf) {set_fft_window(rts_fft_window);}
clear_fft_window(prefs_info * prf)3431 static void clear_fft_window(prefs_info *prf) {set_fft_window(DEFAULT_FFT_WINDOW);}
save_fft_window(prefs_info * prf,FILE * ignore)3432 static void save_fft_window(prefs_info *prf, FILE *ignore) {rts_fft_window = fft_window(ss);}
3433
3434 static list_completer_info *fft_window_completer_info = NULL;
3435
3436
fft_window_completer(widget_t w,const char * text,void * data)3437 static char *fft_window_completer(widget_t w, const char *text, void *data)
3438 {
3439 if (!fft_window_completer_info)
3440 {
3441 fft_window_completer_info = (list_completer_info *)calloc(1, sizeof(list_completer_info));
3442 fft_window_completer_info->exact_match = false;
3443 fft_window_completer_info->values = (char **)mus_fft_window_names();
3444 fft_window_completer_info->num_values = MUS_NUM_FFT_WINDOWS;
3445 fft_window_completer_info->values_size = MUS_NUM_FFT_WINDOWS;
3446 }
3447 return(list_completer(w, text, (void *)fft_window_completer_info));
3448 }
3449
3450
3451 #if USE_MOTIF
fft_window_from_menu(prefs_info * prf,char * value)3452 static void fft_window_from_menu(prefs_info *prf, char *value)
3453 {
3454 int i;
3455 for (i = 0; i < MUS_NUM_FFT_WINDOWS; i++)
3456 if (mus_strcmp(value, mus_fft_window_name((mus_fft_window_t)i)))
3457 {
3458 set_fft_window((mus_fft_window_t)i);
3459 SET_TEXT(prf->text, value);
3460 return;
3461 }
3462 }
3463 #endif
3464
3465
fft_window_from_text(prefs_info * prf)3466 static void fft_window_from_text(prefs_info *prf)
3467 {
3468 char *str;
3469 str = GET_TEXT(prf->text);
3470 if ((str) && (*str))
3471 {
3472 char *trimmed_str;
3473 trimmed_str = trim_string(str);
3474 free_TEXT(str);
3475 if (mus_strlen(trimmed_str) > 0)
3476 {
3477 int i, curpos = -1;
3478 for (i = 0; i < MUS_NUM_FFT_WINDOWS; i++)
3479 if (STRCMP(trimmed_str, mus_fft_window_name((mus_fft_window_t)i)) == 0)
3480 {
3481 curpos = i;
3482 break;
3483 }
3484 if (curpos >= 0)
3485 set_fft_window((mus_fft_window_t)curpos);
3486 else post_prefs_error("unknown window", prf);
3487 }
3488 else post_prefs_error("no window?", prf);
3489 free(trimmed_str);
3490 }
3491 else post_prefs_error("no window?", prf);
3492 }
3493
3494
3495
3496 /* ---------------- colormap ---------------- */
3497
3498 static int rts_colormap = DEFAULT_COLOR_MAP;
3499
colormap_completer(widget_t w,const char * text,void * data)3500 static char *colormap_completer(widget_t w, const char *text, void *data)
3501 {
3502 list_completer_info *compinfo;
3503 char **cmaps;
3504 int i, len;
3505 char *result;
3506 len = num_colormaps();
3507 cmaps = (char **)calloc(len, sizeof(char *));
3508 for (i = 0; i < len; i++)
3509 cmaps[i] = colormap_name(i);
3510 compinfo = (list_completer_info *)calloc(1, sizeof(list_completer_info));
3511 compinfo->exact_match = false;
3512 compinfo->values = (char **)mus_fft_window_names();
3513 compinfo->num_values = len;
3514 compinfo->values_size = len;
3515 result = list_completer(w, text, (void *)compinfo);
3516 free(cmaps);
3517 return(result);
3518 }
3519
3520
reflect_colormap(prefs_info * prf)3521 static void reflect_colormap(prefs_info *prf) {SET_TEXT(prf->text, colormap_name(color_map(ss)));}
clear_colormap(prefs_info * prf)3522 static void clear_colormap(prefs_info *prf) {set_color_map(DEFAULT_COLOR_MAP);}
save_colormap(prefs_info * prf,FILE * ignore)3523 static void save_colormap(prefs_info *prf, FILE *ignore) {rts_colormap = color_map(ss);}
3524
3525
revert_colormap(prefs_info * prf)3526 static void revert_colormap(prefs_info *prf)
3527 {
3528 if (!(is_colormap(rts_colormap))) rts_colormap = DEFAULT_COLOR_MAP;
3529 set_color_map(rts_colormap);
3530 }
3531
3532
colormap_from_text(prefs_info * prf)3533 static void colormap_from_text(prefs_info *prf)
3534 {
3535 char *str;
3536 str = GET_TEXT(prf->text);
3537 if ((str) && (*str))
3538 {
3539 char *trimmed_str;
3540 trimmed_str = trim_string(str);
3541 free_TEXT(str);
3542 if (mus_strlen(trimmed_str) > 0)
3543 {
3544 int i, len, curpos = -1;
3545 len = num_colormaps();
3546 for (i = 0; i < len; i++)
3547 if ((colormap_name(i)) &&
3548 (STRCMP(trimmed_str, colormap_name(i)) == 0))
3549 {
3550 curpos = i;
3551 break;
3552 }
3553 if (is_colormap(curpos))
3554 set_color_map(curpos);
3555 else post_prefs_error("unknown colormap", prf);
3556 }
3557 else post_prefs_error("no colormap?", prf);
3558 free(trimmed_str);
3559 }
3560 else post_prefs_error("no colormap?", prf);
3561 }
3562
3563
3564 #if USE_MOTIF
colormap_from_menu(prefs_info * prf,char * value)3565 static void colormap_from_menu(prefs_info *prf, char *value)
3566 {
3567 int i, len;
3568 len = num_colormaps();
3569 for (i = 0; i < len; i++)
3570 if (mus_strcmp(value, colormap_name(i)))
3571 {
3572 set_color_map(i);
3573 SET_TEXT(prf->text, value);
3574 return;
3575 }
3576 }
3577 #endif
3578
3579
3580
3581 /* ---------------- peak-envs ---------------- */
3582
3583 static bool include_peak_envs = false, rts_peak_envs = false;
3584 static char *include_peak_env_directory = NULL, *rts_peak_env_directory = NULL;
3585
help_peak_envs(prefs_info * prf)3586 static const char *help_peak_envs(prefs_info *prf)
3587 {
3588 return("\
3589 When a very large file is first opened, Snd scans \n\
3590 all the data to build up an overall representation of \n\
3591 the sound. If you like to view the entire sound upon \n\
3592 opening it, you can speed up the process a lot by saving \n\
3593 this initial representation. The data is called a 'peak-env' file \n\
3594 and it resides in the 'peak-env-dir'.");
3595 }
3596
3597
find_peak_envs(void)3598 static bool find_peak_envs(void)
3599 {
3600 return(peak_env_dir(ss));
3601 }
3602
3603
clear_peak_envs(prefs_info * prf)3604 static void clear_peak_envs(prefs_info *prf)
3605 {
3606 if (include_peak_env_directory) free(include_peak_env_directory);
3607 include_peak_env_directory = NULL;
3608 include_peak_envs = false;
3609 }
3610
3611
revert_peak_envs(prefs_info * prf)3612 static void revert_peak_envs(prefs_info *prf)
3613 {
3614 if (include_peak_env_directory) free(include_peak_env_directory);
3615 include_peak_env_directory = mus_strdup(rts_peak_env_directory);
3616 include_peak_envs = rts_peak_envs;
3617 }
3618
3619
save_peak_envs(prefs_info * prf,FILE * fd)3620 static void save_peak_envs(prefs_info *prf, FILE *fd)
3621 {
3622 rts_peak_envs = GET_TOGGLE(prf->toggle);
3623 if (rts_peak_env_directory) free(rts_peak_env_directory);
3624 rts_peak_env_directory = mus_strdup(include_peak_env_directory);
3625 }
3626
3627
reflect_peak_envs(prefs_info * prf)3628 static void reflect_peak_envs(prefs_info *prf)
3629 {
3630 SET_TOGGLE(prf->toggle, include_peak_envs);
3631 SET_TEXT(prf->text, include_peak_env_directory);
3632 }
3633
3634
peak_envs_toggle(prefs_info * prf)3635 static void peak_envs_toggle(prefs_info *prf)
3636 {
3637 include_peak_envs = GET_TOGGLE(prf->toggle);
3638 }
3639
3640
peak_envs_text(prefs_info * prf)3641 static void peak_envs_text(prefs_info *prf)
3642 {
3643 char *str;
3644 str = GET_TEXT(prf->text);
3645 if ((str) && (*str))
3646 {
3647 if (include_peak_env_directory) {free(include_peak_env_directory); include_peak_env_directory = NULL;}
3648 include_peak_env_directory = mus_strdup(str);
3649 free_TEXT(str);
3650 }
3651 }
3652
3653
3654
3655 /* ---------------- load path ---------------- */
3656
3657 static char *rts_load_path = NULL;
3658
help_load_path(prefs_info * prf)3659 static const char *help_load_path(prefs_info *prf)
3660 {
3661 static char *hlp = NULL;
3662 char *temp = NULL;
3663 if (hlp) free(hlp);
3664
3665 hlp = mus_format("Much of Snd's functionality is loaded as needed \n\
3666 from the Scheme, Ruby, or Forth files found in the Snd tarball. \n\
3667 You can run Snd without these files, but there's no reason to! \n\
3668 Just add the directory containing them to the load path \n\
3669 variable %s. " Xen_language " searches these directories \n\
3670 for any *." Xen_file_extension " files that it can't find elsewhere. \n\
3671 The current load path list is: \n\n%s\n",
3672 #if HAVE_RUBY
3673 ", $LOAD_PATH",
3674 #else
3675 #if HAVE_FORTH || HAVE_SCHEME
3676 ", *load-path*",
3677 #else
3678 "",
3679 #endif
3680 #endif
3681 temp = (char *)Xen_object_to_C_string(Xen_load_path));
3682 #if HAVE_SCHEME
3683 if (temp) free(temp);
3684 #endif
3685 return(hlp);
3686 }
3687
3688
find_sources(void)3689 static char *find_sources(void) /* returns directory name where it finds extensions.* */
3690 {
3691 char *file = NULL;
3692 #define BASE_FILE "extensions." Xen_file_extension
3693
3694 #if HAVE_SCHEME
3695 /* mimic Forth code below -- get *load-path* value and run through it */
3696 {
3697 int i, len, base_len;
3698 Xen load_path;
3699 load_path = Xen_load_path;
3700 len = Xen_list_length(load_path);
3701 base_len = strlen(BASE_FILE);
3702 for (i = 0; i < len; i++)
3703 {
3704 char *fname;
3705 const char *path;
3706 int flen;
3707 path = Xen_string_to_C_string(Xen_list_ref(load_path, i));
3708 flen = base_len + 32 + strlen(path);
3709 fname = (char *)calloc(flen, sizeof(char));
3710 snprintf(fname, flen, "%s/%s", path, BASE_FILE);
3711 if (mus_file_probe(fname))
3712 {
3713 file = fname;
3714 break;
3715 }
3716 }
3717 }
3718 #endif
3719
3720 #if HAVE_RUBY
3721 {
3722 Xen xfile;
3723 xfile = rb_find_file(C_string_to_Xen_string(BASE_FILE));
3724 if (Xen_is_string(xfile))
3725 file = mus_expand_filename(Xen_string_to_C_string(xfile));
3726 }
3727 #endif
3728
3729 #if HAVE_FORTH
3730 {
3731 /* taken from fth/src/misc.c -- fth_find_file looks for an already-loaded file */
3732 int i, len, base_len;
3733 Xen load_path;
3734 load_path = Xen_load_path;
3735 len = fth_array_length(load_path);
3736 base_len = strlen(BASE_FILE);
3737 for (i = 0; i < len; i++)
3738 {
3739 char *fname, *path;
3740 int flen;
3741 path = fth_string_ref(fth_array_ref(load_path, i));
3742 flen = base_len + 32 + strlen(path);
3743 fname = (char *)calloc(flen, sizeof(char));
3744 snprintf(fname, flen, "%s/%s", path, BASE_FILE);
3745 if (mus_file_probe(fname))
3746 {
3747 file = fname;
3748 break;
3749 }
3750 }
3751 }
3752 #endif
3753
3754 if (file)
3755 {
3756 int len, exts_len;
3757 len = mus_strlen(file);
3758 exts_len = strlen(BASE_FILE);
3759 if (len > exts_len)
3760 file[len - exts_len - 1] = '\0';
3761 return(file);
3762 }
3763 return(NULL);
3764 }
3765
3766
clear_load_path(prefs_info * prf)3767 static void clear_load_path(prefs_info *prf)
3768 {
3769 char *str;
3770 str = find_sources();
3771 SET_TEXT(prf->text, str);
3772 if (str)
3773 {
3774 black_text(prf);
3775 free(str);
3776 }
3777 else
3778 {
3779 red_text(prf);
3780 }
3781 }
3782
3783
revert_load_path(prefs_info * prf)3784 static void revert_load_path(prefs_info *prf)
3785 {
3786 SET_TEXT(prf->text, rts_load_path);
3787 if (rts_load_path)
3788 black_text(prf);
3789 else
3790 {
3791 red_text(prf);
3792 }
3793 }
3794
3795
reflect_load_path(prefs_info * prf)3796 static void reflect_load_path(prefs_info *prf) {}
3797
load_path_text(prefs_info * prf)3798 static void load_path_text(prefs_info *prf)
3799 {
3800 char *str;
3801 str = GET_TEXT(prf->text);
3802 if ((!str) || (!(*str)))
3803 return;
3804 if (local_access(str))
3805 {
3806 black_text(prf);
3807 if (include_load_path) free(include_load_path);
3808 include_load_path = mus_strdup(str);
3809 Xen_add_to_load_path(include_load_path);
3810 }
3811 if (str) {free_TEXT(str);}
3812 }
3813
3814
3815
3816 /* ---------------- initial bounds ---------------- */
3817
3818 static mus_float_t rts_initial_beg = DEFAULT_INITIAL_BEG, rts_initial_dur = DEFAULT_INITIAL_DUR;
3819 static bool rts_full_duration = DEFAULT_SHOW_FULL_DURATION;
3820
help_initial_bounds(prefs_info * prf)3821 static const char *help_initial_bounds(prefs_info *prf)
3822 {
3823 return("\
3824 Normally Snd displays just the first 0.1 seconds of a \n\
3825 sound in its initial graph. This option sets either new \n\
3826 bounds for that display, or directs Snd to display the entire sound.");
3827 }
3828
3829
initial_bounds_to_string(void)3830 static char *initial_bounds_to_string(void)
3831 {
3832 return(mus_format("%.2f : %.2f", initial_beg(ss), initial_dur(ss)));
3833 }
3834
3835
save_initial_bounds(prefs_info * prf,FILE * fd)3836 static void save_initial_bounds(prefs_info *prf, FILE *fd)
3837 {
3838 rts_full_duration = GET_TOGGLE(prf->toggle);
3839 }
3840
3841
reflect_initial_bounds(prefs_info * prf)3842 static void reflect_initial_bounds(prefs_info *prf)
3843 {
3844 /* text has beg : dur, toggle true if full dur */
3845 char *str;
3846 str = initial_bounds_to_string();
3847 SET_TEXT(prf->text, str);
3848 free(str);
3849 SET_TOGGLE(prf->toggle, show_full_duration(ss));
3850 }
3851
3852
revert_initial_bounds(prefs_info * prf)3853 static void revert_initial_bounds(prefs_info *prf)
3854 {
3855 set_initial_beg(rts_initial_beg);
3856 set_initial_dur(rts_initial_dur);
3857 set_show_full_duration(rts_full_duration);
3858 }
3859
3860
clear_initial_bounds(prefs_info * prf)3861 static void clear_initial_bounds(prefs_info *prf)
3862 {
3863 set_initial_beg(DEFAULT_INITIAL_BEG);
3864 set_initial_dur(DEFAULT_INITIAL_DUR);
3865 set_show_full_duration(DEFAULT_SHOW_FULL_DURATION);
3866 }
3867
3868
initial_bounds_toggle(prefs_info * prf)3869 static void initial_bounds_toggle(prefs_info *prf)
3870 {
3871 set_show_full_duration(GET_TOGGLE(prf->toggle));
3872 }
3873
3874
initial_bounds_text(prefs_info * prf)3875 static void initial_bounds_text(prefs_info *prf)
3876 {
3877 double beg = 0.0, dur = 0.1;
3878 char *str;
3879
3880 str = GET_TEXT(prf->text);
3881 sscanf(str, "%lf : %lf", &beg, &dur);
3882 set_initial_beg(beg);
3883 set_initial_dur(dur);
3884 free_TEXT(str);
3885 }
3886
3887
3888
3889 /* ---------------- keys ---------------- */
3890
reflect_key(prefs_info * prf,const char * key_name)3891 static void reflect_key(prefs_info *prf, const char *key_name)
3892 {
3893 key_info *ki;
3894 ki = find_prefs_key(key_name);
3895 SET_TOGGLE(prf->toggle, ki->c);
3896 SET_TOGGLE(prf->toggle2, ki->m);
3897 SET_TOGGLE(prf->toggle3, ki->x);
3898 SET_TEXT(prf->text, ki->key);
3899 free(ki);
3900 }
3901
3902
save_key(prefs_info * prf,FILE * fd,char * (* binder)(char * key,bool c,bool m,bool x))3903 static void save_key(prefs_info *prf, FILE *fd, char *(*binder)(char *key, bool c, bool m, bool x))
3904 {
3905 char *key;
3906 key = GET_TEXT(prf->text);
3907 if ((key) && (*key))
3908 {
3909 char *expr;
3910 expr = (*binder)(key,
3911 GET_TOGGLE(prf->toggle),
3912 GET_TOGGLE(prf->toggle2),
3913 GET_TOGGLE(prf->toggle3));
3914 fprintf(fd, "%s", expr);
3915 free(expr);
3916 free_TEXT(key);
3917 }
3918 }
3919
3920
key_bind(prefs_info * prf,char * (* binder)(char * key,bool c,bool m,bool x))3921 static void key_bind(prefs_info *prf, char *(*binder)(char *key, bool c, bool m, bool x))
3922 {
3923 char *key;
3924 bool ctrl, meta, cx;
3925 key = GET_TEXT(prf->text);
3926 ctrl = GET_TOGGLE(prf->toggle);
3927 meta = GET_TOGGLE(prf->toggle2);
3928 cx = GET_TOGGLE(prf->toggle3);
3929 if ((key) && (*key))
3930 {
3931 char *expr;
3932 expr = (*binder)(key, ctrl, meta, cx);
3933 free_TEXT(key);
3934 Xen_eval_C_string(expr);
3935 free(expr);
3936 }
3937 }
3938
3939
clear_key(prefs_info * prf,const char * name)3940 static void clear_key(prefs_info *prf, const char *name)
3941 {
3942 key_info *ki;
3943 ki = find_prefs_key(name);
3944 if (ki)
3945 {
3946 if (ki->key)
3947 {
3948 int state = 0;
3949 if (ki->c) state |= 4;
3950 if (ki->m) state |= 8;
3951 #if USE_MOTIF
3952 set_keymap_entry((int)XStringToKeysym(ki->key), state, 0, Xen_undefined, ki->x, name, name);
3953 #else
3954 set_keymap_entry((int)gdk_keyval_from_name(ki->key), state, 0, Xen_undefined, ki->x, name, name);
3955 #endif
3956 }
3957 free(ki);
3958 }
3959 }
3960
3961
3962
3963 /* -------- key: play all chans from cursor -------- */
3964
help_play_from_cursor(prefs_info * prf)3965 static const char *help_play_from_cursor(prefs_info *prf)
3966 {
3967 return(" This option binds a key to play the entire sound. ");
3968 }
3969
3970
make_pfc(char * key,bool ctrl,bool meta,bool cx)3971 static char *make_pfc(char *key, bool ctrl, bool meta, bool cx)
3972 {
3973 #if HAVE_SCHEME
3974 return(mus_format("(bind-key %s %d (lambda () (set! (pausing) #f) (play (cursor))) %s \"play sound from cursor\" \"play-from-cursor\")\n",
3975 possibly_quote(key),
3976 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
3977 (cx) ? "#t" : "#f"));
3978 #endif
3979
3980 #if HAVE_RUBY
3981 return(mus_format("bind_key(%s, %d, lambda do\n set_pausing(false)\n play(cursor())\n end, %s, \"play sound from cursor\", \"play-from-cursor\")\n",
3982 possibly_quote(key),
3983 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
3984 (cx) ? "true" : "false"));
3985 #endif
3986
3987 #if HAVE_FORTH
3988 return(mus_format("%s %d lambda: <{ }> #f set-pausing drop #f #f #f cursor play drop ; %s \"play sound from cursor\" \"play-from-cursor\" bind-key drop\n",
3989 possibly_quote(key),
3990 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
3991 (cx) ? "#t" : "#f"));
3992 #endif
3993 return(NULL);
3994 }
3995
3996
reflect_play_from_cursor(prefs_info * prf)3997 static void reflect_play_from_cursor(prefs_info *prf)
3998 {
3999 reflect_key(prf, "play-from-cursor");
4000 }
4001
4002
save_pfc(prefs_info * prf,FILE * fd)4003 static void save_pfc(prefs_info *prf, FILE *fd)
4004 {
4005 save_key(prf, fd, make_pfc);
4006 }
4007
4008
bind_play_from_cursor(prefs_info * prf)4009 static void bind_play_from_cursor(prefs_info *prf)
4010 {
4011 key_bind(prf, make_pfc);
4012 }
4013
4014
clear_play_from_cursor(prefs_info * prf)4015 static void clear_play_from_cursor(prefs_info *prf)
4016 {
4017 clear_key(prf, "play-from-cursor");
4018 }
4019
4020
4021
4022 /* -------- key: show all of sound -------- */
4023
help_show_all(prefs_info * prf)4024 static const char *help_show_all(prefs_info *prf)
4025 {
4026 return("\
4027 This option binds a key to show all of the current sound \n\
4028 in the current time domain window, equivalent to moving the \n\
4029 'zoom' slider all the way to the right.");
4030 }
4031
4032
make_show_all(char * key,bool ctrl,bool meta,bool cx)4033 static char *make_show_all(char *key, bool ctrl, bool meta, bool cx)
4034 {
4035 #if HAVE_SCHEME
4036 return(mus_format("(bind-key %s %d (lambda () \
4037 (let ((old-sync (sync))) \
4038 (set! (sync) (+ (sync-max) 1)) \
4039 (set! (x-bounds) (list 0.0 (/ (framples) (srate)))) \
4040 (set! (sync) old-sync))) %s \"show entire sound\" \"show-all\")\n",
4041 possibly_quote(key),
4042 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4043 (cx) ? "#t" : "#f"));
4044 #endif
4045
4046 #if HAVE_RUBY
4047 return(mus_format("bind_key(%s, %d, lambda do\n\
4048 old_sync = sync()\n\
4049 sync(1 + sync_max())\n\
4050 set_x_bounds([0.0, framples() / srate()])\n\
4051 set_sync(old_sync)\n\
4052 end, %s, \"show entire sound\", \"show-all\")\n",
4053 possibly_quote(key),
4054 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4055 (cx) ? "true" : "false"));
4056 #endif
4057
4058 #if HAVE_FORTH
4059 return(mus_format("%s %d lambda: <{ }> #f sync sync-max 1+ #f set-sync drop '( 0.0 #f #f #f framples #f srate f/ ) #f #f set-x-bounds drop #f set-sync ; %s \"show entire sound\" \"show-all\" bind-key drop\n",
4060 possibly_quote(key),
4061 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4062 (cx) ? "#t" : "#f"));
4063 #endif
4064 return(NULL);
4065 }
4066
4067
reflect_show_all(prefs_info * prf)4068 static void reflect_show_all(prefs_info *prf)
4069 {
4070 reflect_key(prf, "show-all");
4071 }
4072
4073
save_show_all(prefs_info * prf,FILE * fd)4074 static void save_show_all(prefs_info *prf, FILE *fd)
4075 {
4076 save_key(prf, fd, make_show_all);
4077 }
4078
4079
bind_show_all(prefs_info * prf)4080 static void bind_show_all(prefs_info *prf)
4081 {
4082 key_bind(prf, make_show_all);
4083 }
4084
4085
clear_show_all(prefs_info * prf)4086 static void clear_show_all(prefs_info *prf)
4087 {
4088 clear_key(prf, "show-all");
4089 }
4090
4091
4092
4093 /* -------- key: select all of sound -------- */
4094
help_select_all(prefs_info * prf)4095 static const char *help_select_all(prefs_info *prf)
4096 {
4097 return("\
4098 This option binds a key to select all of the current sound. \n\
4099 The 'Select all' Edit menu item follows the 'sync' buttons when \n\
4100 deciding which channels to select.");
4101 }
4102
4103
make_select_all(char * key,bool ctrl,bool meta,bool cx)4104 static char *make_select_all(char *key, bool ctrl, bool meta, bool cx)
4105 {
4106 #if HAVE_SCHEME
4107 return(mus_format("(bind-key %s %d (lambda () \
4108 (let ((old-sync (sync))) \
4109 (set! (sync) (+ (sync-max) 1)) \
4110 (select-all) \
4111 (set! (sync) old-sync))) %s \"select entire sound\" \"select-all\")\n",
4112 possibly_quote(key),
4113 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4114 (cx) ? "#t" : "#f"));
4115 #endif
4116
4117 #if HAVE_RUBY
4118 return(mus_format("bind_key(%s, %d, lambda do\n\
4119 old_sync = sync()\n\
4120 sync(1 + sync_max())\n\
4121 select_all()\n\
4122 set_sync(old_sync)\n\
4123 end, %s, \"select entire sound\", \"select-all\")\n",
4124 possibly_quote(key),
4125 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4126 (cx) ? "true" : "false"));
4127 #endif
4128
4129 #if HAVE_FORTH
4130 return(mus_format("%s %d lambda: <{ }> #f sync sync-max 1+ #f set-sync drop #f #f select-all drop #f set-sync ; %s \"select entire sound\" \"select-all\" bind-key drop\n",
4131 possibly_quote(key),
4132 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4133 (cx) ? "#t" : "#f"));
4134 #endif
4135 return(NULL);
4136 }
4137
4138
reflect_select_all(prefs_info * prf)4139 static void reflect_select_all(prefs_info *prf)
4140 {
4141 reflect_key(prf, "select-all");
4142 }
4143
4144
save_select_all(prefs_info * prf,FILE * fd)4145 static void save_select_all(prefs_info *prf, FILE *fd)
4146 {
4147 save_key(prf, fd, make_select_all);
4148 }
4149
4150
bind_select_all(prefs_info * prf)4151 static void bind_select_all(prefs_info *prf)
4152 {
4153 key_bind(prf, make_select_all);
4154 }
4155
4156
clear_select_all(prefs_info * prf)4157 static void clear_select_all(prefs_info *prf)
4158 {
4159 clear_key(prf, "select-all");
4160 }
4161
4162
4163
4164 /* -------- key: undo all edits -------- */
4165
help_revert(prefs_info * prf)4166 static const char *help_revert(prefs_info *prf)
4167 {
4168 return("\
4169 This option binds a key to undo any edits in the current sound, \n\
4170 equivalent to the File:Revert menu item.");
4171 }
4172
4173
make_revert(char * key,bool ctrl,bool meta,bool cx)4174 static char *make_revert(char *key, bool ctrl, bool meta, bool cx)
4175 {
4176 #if HAVE_SCHEME
4177 return(mus_format("(bind-key %s %d revert-sound %s \"undo all edits\" \"revert-sound\")\n",
4178 possibly_quote(key),
4179 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4180 (cx) ? "#t" : "#f"));
4181 #endif
4182
4183 #if HAVE_RUBY
4184 return(mus_format("bind_key(%s, %d, lambda do\n revert_sound()\n end, %s, \"undo all edits\", \"revert-sound\")\n",
4185 possibly_quote(key),
4186 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4187 (cx) ? "true" : "false"));
4188 #endif
4189
4190 #if HAVE_FORTH
4191 return(mus_format("%s %d lambda: <{ }> #f revert-sound ; %s \"undo all edits\" \"revert-sound\" bind-key drop\n",
4192 possibly_quote(key),
4193 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4194 (cx) ? "#t" : "#f"));
4195 #endif
4196 return(NULL);
4197 }
4198
4199
reflect_revert(prefs_info * prf)4200 static void reflect_revert(prefs_info *prf)
4201 {
4202 reflect_key(prf, "revert-sound");
4203 }
4204
4205
save_revert(prefs_info * prf,FILE * fd)4206 static void save_revert(prefs_info *prf, FILE *fd)
4207 {
4208 save_key(prf, fd, make_revert);
4209 }
4210
4211
bind_revert(prefs_info * prf)4212 static void bind_revert(prefs_info *prf)
4213 {
4214 key_bind(prf, make_revert);
4215 }
4216
4217
clear_revert_sound(prefs_info * prf)4218 static void clear_revert_sound(prefs_info *prf)
4219 {
4220 clear_key(prf, "revert-sound");
4221 }
4222
4223
4224
4225 /* -------- key: exit -------- */
4226
help_exit(prefs_info * prf)4227 static const char *help_exit(prefs_info *prf)
4228 {
4229 return("\
4230 This option binds a key to exit from Snd, \n\
4231 equivalent to the File:Exit menu item.");
4232 }
4233
4234
make_exit(char * key,bool ctrl,bool meta,bool cx)4235 static char *make_exit(char *key, bool ctrl, bool meta, bool cx)
4236 {
4237 #if HAVE_SCHEME
4238 return(mus_format("(bind-key %s %d exit %s \"exit\" \"exit\")\n",
4239 possibly_quote(key),
4240 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4241 (cx) ? "#t" : "#f"));
4242 #endif
4243
4244 #if HAVE_RUBY
4245 return(mus_format("bind_key(%s, %d, lambda do\n exit()\n end, %s, \"exit\", \"exit\")\n",
4246 possibly_quote(key),
4247 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4248 (cx) ? "true" : "false"));
4249 #endif
4250
4251 #if HAVE_FORTH
4252 return(mus_format("%s %d lambda: <{ }> 0 snd-exit ; %s \"exit\" \"exit\" bind-key drop\n",
4253 possibly_quote(key),
4254 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4255 (cx) ? "#t" : "#f"));
4256 #endif
4257 return(NULL);
4258 }
4259
4260
reflect_exit(prefs_info * prf)4261 static void reflect_exit(prefs_info *prf)
4262 {
4263 reflect_key(prf, "exit");
4264 }
4265
4266
save_exit(prefs_info * prf,FILE * fd)4267 static void save_exit(prefs_info *prf, FILE *fd)
4268 {
4269 save_key(prf, fd, make_exit);
4270 }
4271
4272
bind_exit(prefs_info * prf)4273 static void bind_exit(prefs_info *prf)
4274 {
4275 key_bind(prf, make_exit);
4276 }
4277
4278
clear_exit(prefs_info * prf)4279 static void clear_exit(prefs_info *prf)
4280 {
4281 clear_key(prf, "exit");
4282 }
4283
4284
4285
4286 /* -------- key: goto maxamp -------- */
4287
help_goto_maxamp(prefs_info * prf)4288 static const char *help_goto_maxamp(prefs_info *prf)
4289 {
4290 return("\
4291 This option binds a key to move the view (and cursor) to the \n\
4292 position of the current channel's maximum sample.");
4293 }
4294
4295
make_goto_maxamp(char * key,bool ctrl,bool meta,bool cx)4296 static char *make_goto_maxamp(char *key, bool ctrl, bool meta, bool cx)
4297 {
4298 #if HAVE_SCHEME
4299 return(mus_format("(bind-key %s %d (lambda () (set! (cursor) (maxamp-position))) %s \"goto maxamp\" \"goto-maxamp\")\n",
4300 possibly_quote(key),
4301 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4302 (cx) ? "#t" : "#f"));
4303 #endif
4304
4305 #if HAVE_RUBY
4306 return(mus_format("bind_key(%s, %d, lambda do\n set_cursor(maxamp_position())\n end, %s, \"goto maxamp\", \"goto-maxamp\")\n",
4307 possibly_quote(key),
4308 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4309 (cx) ? "true" : "false"));
4310 #endif
4311
4312 #if HAVE_FORTH
4313 return(mus_format("%s %d lambda: <{ }> #f #f #f maxamp-position #f #f #f set-cursor ; %s \"goto maxamp\" \"goto-maxamp\" bind-key drop\n",
4314 possibly_quote(key),
4315 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4316 (cx) ? "#t" : "#f"));
4317 #endif
4318 return(NULL);
4319 }
4320
4321
reflect_goto_maxamp(prefs_info * prf)4322 static void reflect_goto_maxamp(prefs_info *prf)
4323 {
4324 reflect_key(prf, "goto-maxamp");
4325 }
4326
4327
save_goto_maxamp(prefs_info * prf,FILE * fd)4328 static void save_goto_maxamp(prefs_info *prf, FILE *fd)
4329 {
4330 save_key(prf, fd, make_goto_maxamp);
4331 }
4332
4333
bind_goto_maxamp(prefs_info * prf)4334 static void bind_goto_maxamp(prefs_info *prf)
4335 {
4336 key_bind(prf, make_goto_maxamp);
4337 }
4338
4339
clear_goto_maxamp(prefs_info * prf)4340 static void clear_goto_maxamp(prefs_info *prf)
4341 {
4342 clear_key(prf, "goto-maxamp");
4343 }
4344
4345
4346
4347 /* -------- key: show selection -------- */
4348
help_show_selection(prefs_info * prf)4349 static const char *help_show_selection(prefs_info *prf)
4350 {
4351 return("\
4352 This option binds a key to cause the current selection to \n\
4353 fill the time domain graph.");
4354 }
4355
4356
make_show_selection(char * key,bool ctrl,bool meta,bool cx)4357 static char *make_show_selection(char *key, bool ctrl, bool meta, bool cx)
4358 {
4359 #if HAVE_SCHEME
4360 return(mus_format("(bind-key %s %d show-selection %s \"show selection\" \"show-selection\")\n",
4361 possibly_quote(key),
4362 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4363 (cx) ? "#t" : "#f"));
4364 #endif
4365
4366 #if HAVE_RUBY
4367 return(mus_format("bind_key(%s, %d, lambda do\n show_selection()\n end, %s, \"show selection\", \"show-selection\")\n",
4368 possibly_quote(key),
4369 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4370 (cx) ? "true" : "false"));
4371 #endif
4372
4373 #if HAVE_FORTH
4374 return(mus_format("%s %d ' show-selection %s \"show selection\" \"show-selection\" bind-key drop\n",
4375 possibly_quote(key),
4376 ((ctrl) ? 4 : 0) + ((meta) ? 8 : 0),
4377 (cx) ? "#t" : "#f"));
4378 #endif
4379 return(NULL);
4380 }
4381
4382
reflect_show_selection(prefs_info * prf)4383 static void reflect_show_selection(prefs_info *prf)
4384 {
4385 reflect_key(prf, "show-selection");
4386 }
4387
4388
save_show_selection(prefs_info * prf,FILE * fd)4389 static void save_show_selection(prefs_info *prf, FILE *fd)
4390 {
4391 save_key(prf, fd, make_show_selection);
4392 }
4393
4394
bind_show_selection(prefs_info * prf)4395 static void bind_show_selection(prefs_info *prf)
4396 {
4397 key_bind(prf, make_show_selection);
4398 }
4399
4400
clear_show_selection(prefs_info * prf)4401 static void clear_show_selection(prefs_info *prf)
4402 {
4403 clear_key(prf, "show-selection");
4404 }
4405
help_show_controls(prefs_info * prf)4406 static const char *help_show_controls(prefs_info *prf)
4407 {
4408 return("\
4409 The control panel is the set of playback controls \n\
4410 under the sound graphs. It is normally hidden. ");
4411 }
4412
help_selection_creates_region(prefs_info * prf)4413 static const char *help_selection_creates_region(prefs_info *prf)
4414 {
4415 return("\
4416 This determines whether a region is created whenever \n\
4417 you make a selection. ");
4418 }
4419
help_just_sounds(prefs_info * prf)4420 static const char *help_just_sounds(prefs_info *prf)
4421 {
4422 return("\
4423 The various file dialogs can restrict the files \n\
4424 displayed to just sound files. This sets the default\n\
4425 value of the 'just sounds' button in those dialogs. ");
4426 }
4427
help_temp_dir(prefs_info * prf)4428 static const char *help_temp_dir(prefs_info *prf)
4429 {
4430 return("\
4431 Snd sometimes needs a place to write a temporary \n\
4432 file. This is the directory to use. ");
4433 }
4434
help_save_dir(prefs_info * prf)4435 static const char *help_save_dir(prefs_info *prf)
4436 {
4437 return("\
4438 When you choose the Options: Save state item, \n\
4439 the saved settings are placed in a file in this directory. ");
4440 }
4441
help_save_state_file(prefs_info * prf)4442 static const char *help_save_state_file(prefs_info *prf)
4443 {
4444 return("\
4445 When you choose Options: Save state, the state \n\
4446 is saved in this file, in the save directory. ");
4447 }
4448
help_html_program(prefs_info * prf)4449 static const char *help_html_program(prefs_info *prf)
4450 {
4451 return("\
4452 The help dialog has links to the Snd documentation, \n\
4453 and this option gives the name of the HTML viewer to use. ");
4454 }
4455
help_default_output_chans(prefs_info * prf)4456 static const char *help_default_output_chans(prefs_info *prf)
4457 {
4458 return("\
4459 This sets the default number of output channels \n\
4460 when a new sound is started. ");
4461 }
4462
help_default_output_srate(prefs_info * prf)4463 static const char *help_default_output_srate(prefs_info *prf)
4464 {
4465 return("\
4466 This sets the default sampling rate when a new \n\
4467 sound is opened. ");
4468 }
4469
help_default_output_header_type(prefs_info * prf)4470 static const char *help_default_output_header_type(prefs_info *prf)
4471 {
4472 return("\
4473 This sets the default output header type (AIFC, etc) \n\
4474 when a new sound is opened. ");
4475 }
4476
help_default_output_sample_type(prefs_info * prf)4477 static const char *help_default_output_sample_type(prefs_info *prf)
4478 {
4479 return("\
4480 This sets the default sample type (big-endian float, etc) \n\
4481 when a new sound is opened. ");
4482 }
4483
help_with_verbose_cursor(prefs_info * prf)4484 static const char *help_with_verbose_cursor(prefs_info *prf)
4485 {
4486 return("\
4487 If this is set, the cursor's position and the underlying \n\
4488 sample's value are displayed in the status area as the cursor moves. ");
4489 }
4490
help_with_tracking_cursor(prefs_info * prf)4491 static const char *help_with_tracking_cursor(prefs_info *prf)
4492 {
4493 return("\
4494 If this is set, the cursor always tries to show where the playback \n\
4495 is in the sound as it is played. It is only an approximation. ");
4496 }
4497
help_cursor_size(prefs_info * prf)4498 static const char *help_cursor_size(prefs_info *prf)
4499 {
4500 return(" This sets the cursor size in pixels. ");
4501 }
4502
help_cursor_style(prefs_info * prf)4503 static const char *help_cursor_style(prefs_info *prf)
4504 {
4505 return(" This sets the cursor shape. ");
4506 }
4507
help_tracking_cursor_style(prefs_info * prf)4508 static const char *help_tracking_cursor_style(prefs_info *prf)
4509 {
4510 return(" This sets the tracking cursor shape (the 'tracking cursor'\n\
4511 tries to show where you are in the sound while it is begin played). ");
4512 }
4513
help_cursor_color(prefs_info * prf)4514 static const char *help_cursor_color(prefs_info *prf)
4515 {
4516 return(" This is the cursor color. ");
4517 }
4518
help_basic_color(prefs_info * prf)4519 static const char *help_basic_color(prefs_info *prf)
4520 {
4521 return(" This is the main background color used throughout Snd. ");
4522 }
4523
help_highlight_color(prefs_info * prf)4524 static const char *help_highlight_color(prefs_info *prf)
4525 {
4526 return(" This color is used for highlighted items. ");
4527 }
4528
help_position_color(prefs_info * prf)4529 static const char *help_position_color(prefs_info *prf)
4530 {
4531 return(" This is the color of the position-related sliders. ");
4532 }
4533
help_zoom_color(prefs_info * prf)4534 static const char *help_zoom_color(prefs_info *prf)
4535 {
4536 return(" This is the color of the zoom-related sliders. ");
4537 }
4538
help_graph_style(prefs_info * prf)4539 static const char *help_graph_style(prefs_info *prf)
4540 {
4541 return("\
4542 This sets how sound data is displayed. Normally samples \n\
4543 are joined by lines, but you can also display them as isolated \n\
4544 dots, or as filled polygons, or as dots-on-stilts, as in the DSP \n\
4545 textbooks. ");
4546 }
4547
help_dot_size(prefs_info * prf)4548 static const char *help_dot_size(prefs_info *prf)
4549 {
4550 return("\
4551 If the graph style uses dots, this sets the dot size. ");
4552 }
4553
help_channel_style(prefs_info * prf)4554 static const char *help_channel_style(prefs_info *prf)
4555 {
4556 return("\
4557 When a sound has more than one channel, this chooses how \n\
4558 to lay them out: in separate windows, combined in one window \n\
4559 or superimposed on each other in a single graph. ");
4560 }
4561
help_graphs_horizontal(prefs_info * prf)4562 static const char *help_graphs_horizontal(prefs_info *prf)
4563 {
4564 return("\
4565 This chooses whether sounds are layed out horizontally or vertically. ");
4566 }
4567
help_show_y_zero(prefs_info * prf)4568 static const char *help_show_y_zero(prefs_info *prf)
4569 {
4570 return("\
4571 If this is set, each channel graph includes a line at y=0. ");
4572 }
4573
help_show_grid(prefs_info * prf)4574 static const char *help_show_grid(prefs_info *prf)
4575 {
4576 return("\
4577 If this option is set, each channel graph has a grid, sort \n\
4578 of like engineering graph paper. ");
4579 }
4580
help_grid_density(prefs_info * prf)4581 static const char *help_grid_density(prefs_info *prf)
4582 {
4583 return("\
4584 If grids are in use, this sets how close the lines are. ");
4585 }
4586
help_show_axes(prefs_info * prf)4587 static const char *help_show_axes(prefs_info *prf)
4588 {
4589 return(" This chooses which axes to display. ");
4590 }
4591
help_x_axis_style(prefs_info * prf)4592 static const char *help_x_axis_style(prefs_info *prf)
4593 {
4594 return(" This sets the x axis labelling. ");
4595 }
4596
help_data_color(prefs_info * prf)4597 static const char *help_data_color(prefs_info *prf)
4598 {
4599 return(" This is the waveform color in unselected graphs. ");
4600 }
4601
help_graph_color(prefs_info * prf)4602 static const char *help_graph_color(prefs_info *prf)
4603 {
4604 return(" This is the background color in unselected graphs. ");
4605 }
4606
help_selected_data_color(prefs_info * prf)4607 static const char *help_selected_data_color(prefs_info *prf)
4608 {
4609 return(" This is the waveform color in a selected graph. ");
4610 }
4611
help_selected_graph_color(prefs_info * prf)4612 static const char *help_selected_graph_color(prefs_info *prf)
4613 {
4614 return(" This is the background color in a selected graph. ");
4615 }
4616
help_selection_color(prefs_info * prf)4617 static const char *help_selection_color(prefs_info *prf)
4618 {
4619 return(" This is the color used to show the current selection. ");
4620 }
4621
help_axis_label_font(prefs_info * prf)4622 static const char *help_axis_label_font(prefs_info *prf)
4623 {
4624 return(" This is a font used to label axes. ");
4625 }
4626
help_axis_numbers_font(prefs_info * prf)4627 static const char *help_axis_numbers_font(prefs_info *prf)
4628 {
4629 return(" This is the font used for axis numbers. ");
4630 }
4631
help_peaks_font(prefs_info * prf)4632 static const char *help_peaks_font(prefs_info *prf)
4633 {
4634 return(" This is the font used in the FFT peaks listing. ");
4635 }
4636
help_bold_peaks_font(prefs_info * prf)4637 static const char *help_bold_peaks_font(prefs_info *prf)
4638 {
4639 return("\
4640 This is the font used in the FFT peaks list\n\
4641 to show a major peak. ");
4642 }
4643
help_transform_graph_type(prefs_info * prf)4644 static const char *help_transform_graph_type(prefs_info *prf)
4645 {
4646 return("\
4647 FFT results can be displayed as a waveform, a sonogram, \n\
4648 or a spectrogram. ");
4649 }
4650
help_transform_type(prefs_info * prf)4651 static const char *help_transform_type(prefs_info *prf)
4652 {
4653 return("\
4654 This chooses the kind of transform displayed \n\
4655 in the fft graph. ");
4656 }
4657
help_fft_window(prefs_info * prf)4658 static const char *help_fft_window(prefs_info *prf)
4659 {
4660 return(" This sets the fft data window. ");
4661 }
4662
help_fft_window_beta(prefs_info * prf)4663 static const char *help_fft_window_beta(prefs_info *prf)
4664 {
4665 return(" If the FFT window has an associated parameter, this sets it. ");
4666 }
4667
help_colormap(prefs_info * prf)4668 static const char *help_colormap(prefs_info *prf)
4669 {
4670 return(" If the FFT is being displayed as a sonogram or spectrogram,\n\
4671 this sets the colormap to use. ");
4672 }
4673
help_fft_log_magnitude(prefs_info * prf)4674 static const char *help_fft_log_magnitude(prefs_info *prf)
4675 {
4676 return(" If this option is set, the FFTs show the magnitude axis using a log scale. ");
4677 }
4678
help_min_dB(prefs_info * prf)4679 static const char *help_min_dB(prefs_info *prf)
4680 {
4681 return("\
4682 If the FFT graphs are using a dB scale, this sets the\n\
4683 minimum dB value displayed. ");
4684 }
4685
help_fft_log_frequency(prefs_info * prf)4686 static const char *help_fft_log_frequency(prefs_info *prf)
4687 {
4688 return(" If this is set, FFTs show the frequency axis using a log scale. ");
4689 }
4690
help_transform_normalization(prefs_info * prf)4691 static const char *help_transform_normalization(prefs_info *prf)
4692 {
4693 return(" This chooses whether FFT data is normalized before display. ");
4694 }
4695
help_mark_color(prefs_info * prf)4696 static const char *help_mark_color(prefs_info *prf)
4697 {
4698 return(" This is the mark color. ");
4699 }
4700
help_mix_color(prefs_info * prf)4701 static const char *help_mix_color(prefs_info *prf)
4702 {
4703 return(" This is the color of the mix handle. ");
4704 }
4705
help_sinc_width(prefs_info * prf)4706 static const char *help_sinc_width(prefs_info *prf)
4707 {
4708 return("\
4709 If sampling rate conversion is needed, this sets \n\
4710 the width of the sinc used for low-pass filtering. ");
4711 }
4712
help_show_listener(prefs_info * prf)4713 static const char *help_show_listener(prefs_info *prf)
4714 {
4715 return(" This option chooses whether to open the listener window. ");
4716 }
4717
help_listener_prompt(prefs_info * prf)4718 static const char *help_listener_prompt(prefs_info *prf)
4719 {
4720 return(" This is the prompt displayed in the listener window. ");
4721 }
4722
help_print_length(prefs_info * prf)4723 static const char *help_print_length(prefs_info *prf)
4724 {
4725 return("\
4726 When a vector is printed in the listener, this sets\n\
4727 the maximum number of values displayed. ");
4728 }
4729
help_listener_font(prefs_info * prf)4730 static const char *help_listener_font(prefs_info *prf)
4731 {
4732 return(" This is the font used in the listener. ");
4733 }
4734
help_listener_color(prefs_info * prf)4735 static const char *help_listener_color(prefs_info *prf)
4736 {
4737 return(" This is the background color of the listener. ");
4738 }
4739
help_dac_size(prefs_info * prf)4740 static const char *help_dac_size(prefs_info *prf)
4741 {
4742 return(" This is the DAC buffer size. ");
4743 }
4744
help_dac_combines_channels(prefs_info * prf)4745 static const char *help_dac_combines_channels(prefs_info *prf)
4746 {
4747 return("\
4748 If the DAC has fewer output channels than the sound you\n\
4749 want to play, and this option is set, then the extra \n\
4750 channels are mixed into the existing ones. ");
4751 }
4752
4753 #if USE_MOTIF
help_view_files_directory(prefs_info * prf)4754 static const char *help_view_files_directory(prefs_info *prf)
4755 {
4756 return(" This directory is added to the View:files dialog's list. ");
4757 }
4758 #endif
4759
help_raw_chans(prefs_info * prf)4760 static const char *help_raw_chans(prefs_info *prf)
4761 {
4762 return("\
4763 When a raw (no header) sound is opened, this sets the \n\
4764 default number of channels. ");
4765 }
4766
help_raw_srate(prefs_info * prf)4767 static const char *help_raw_srate(prefs_info *prf)
4768 {
4769 return("\
4770 When a raw (no header) sound is opened, this sets the \n\
4771 default sampling rate. ");
4772 }
4773
help_raw_sample_type(prefs_info * prf)4774 static const char *help_raw_sample_type(prefs_info *prf)
4775 {
4776 return("\
4777 When a raw (no header) sound is opened, this sets the \n\
4778 default sample type. ");
4779 }
4780
help_tiny_font(prefs_info * prf)4781 static const char *help_tiny_font(prefs_info *prf)
4782 {
4783 return(" When graph space is tight, Snd uses this font. ");
4784 }
4785
help_fft_size(prefs_info * prf)4786 static const char *help_fft_size(prefs_info *prf)
4787 {
4788 return(" This is the default FFT size. ");
4789 }
4790
help_transform_peaks(prefs_info * prf)4791 static const char *help_transform_peaks(prefs_info *prf)
4792 {
4793 return(" If this is set, FFTs include peak listings. ");
4794 }
4795
help_mark_tag_size(prefs_info * prf)4796 static const char *help_mark_tag_size(prefs_info *prf)
4797 {
4798 return(" This is the size of the upper tag on a mark. ");
4799 }
4800
help_mix_tag_size(prefs_info * prf)4801 static const char *help_mix_tag_size(prefs_info *prf)
4802 {
4803 return(" This sets the mix tag size. ");
4804 }
4805
help_mix_waveforms(prefs_info * prf)4806 static const char *help_mix_waveforms(prefs_info *prf)
4807 {
4808 return(" If this is set, mixes display their waveforms. ");
4809 }
4810
help_speed_control(prefs_info * prf)4811 static const char *help_speed_control(prefs_info *prf)
4812 {
4813 return("\
4814 This chooses how the speed control in the control panel\n\
4815 divides up the speeds; as a continuous scale, by simple ratios, etc. ");
4816 }
4817
help_listener_text_color(prefs_info * prf)4818 static const char *help_listener_text_color(prefs_info *prf)
4819 {
4820 return(" This is the listener text color. ");
4821 }
4822
help_init_window_size(prefs_info * prf)4823 static const char *help_init_window_size(prefs_info *prf)
4824 {
4825 return(" This sets Snd's size when it first comes up. ");
4826 }
4827
4828