1 #include "snd.h"
2
3
4 #if (!USE_NO_GUI)
5
6 /* our "current path" */
7 static point_t points[POINT_BUFFER_SIZE];
8 static point_t points1[POINT_BUFFER_SIZE];
9
set_grf_points(int xi,int j,int ymin,int ymax)10 void set_grf_points(int xi, int j, int ymin, int ymax)
11 {
12 points[j].x = xi;
13 points1[j].x = xi;
14 points[j].y = ymax;
15 points1[j].y = ymin;
16 }
17
18
set_grf_point(int xi,int j,int yi)19 void set_grf_point(int xi, int j, int yi)
20 {
21 points[j].x = xi;
22 points[j].y = yi;
23 }
24
25
get_grf_points(void)26 point_t *get_grf_points(void) {return(points);}
27
get_grf_points1(void)28 point_t *get_grf_points1(void) {return(points1);}
29
30
draw_both_grf_points(int dot_size,graphics_context * ax,int j,graph_style_t graph_style)31 void draw_both_grf_points(int dot_size, graphics_context *ax, int j, graph_style_t graph_style)
32 {
33 int i;
34 switch (graph_style)
35 {
36 case GRAPH_LINES:
37 default:
38 draw_lines(ax, points, j);
39 draw_lines(ax, points1, j);
40 break;
41
42 case GRAPH_DOTS:
43 draw_points(ax, points, j, dot_size);
44 draw_points(ax, points1, j, dot_size);
45 break;
46
47 case GRAPH_FILLED:
48 fill_two_sided_polygons(ax, points, points1, j);
49 break;
50
51 case GRAPH_DOTS_AND_LINES:
52 if (dot_size > 1)
53 {
54 draw_points(ax, points, j, dot_size);
55 draw_points(ax, points1, j, dot_size);
56 }
57 draw_lines(ax, points, j);
58 draw_lines(ax, points1, j);
59 break;
60
61 case GRAPH_LOLLIPOPS:
62 if (dot_size == 1)
63 {
64 for (i = 0; i < j; i++)
65 draw_line(ax, points[i].x, points[i].y, points1[i].x, points1[i].y);
66 }
67 else
68 {
69 int size8, size4;
70 size8 = dot_size / 8;
71 size4 = dot_size / 4;
72 if (size4 < 1) size4 = 1;
73 draw_points(ax, points, j, dot_size);
74 draw_points(ax, points1, j, dot_size);
75 for (i = 0; i < j; i++)
76 fill_rectangle(ax, points[i].x - size8, points[i].y, size4, points1[i].y - points[i].y);
77 }
78 break;
79 }
80 }
81
82
draw_grf_points(int dot_size,graphics_context * ax,int j,axis_info * ap,mus_float_t y0,graph_style_t graph_style)83 void draw_grf_points(int dot_size, graphics_context *ax, int j, axis_info *ap, mus_float_t y0, graph_style_t graph_style)
84 {
85 int i, gy0;
86 switch (graph_style)
87 {
88 case GRAPH_LINES:
89 default:
90 draw_lines(ax, points, j);
91 break;
92
93 case GRAPH_DOTS:
94 draw_points(ax, points, j, dot_size);
95 break;
96
97 case GRAPH_FILLED:
98 fill_polygons(ax, points, j, grf_y(y0, ap));
99 break;
100
101 case GRAPH_DOTS_AND_LINES:
102 if (dot_size > 1)
103 draw_points(ax, points, j, dot_size);
104 draw_lines(ax, points, j);
105 break;
106
107 case GRAPH_LOLLIPOPS:
108 gy0 = grf_y(y0, ap);
109 if (dot_size == 1)
110 for (i = 0; i < j; i++)
111 draw_line(ax, points[i].x, points[i].y, points[i].x, gy0);
112 else
113 {
114 int size8, size4;
115 size8 = dot_size / 8;
116 size4 = dot_size / 4;
117 if (size4 < 1) size4 = 1;
118 draw_points(ax, points, j, dot_size);
119 for (i = 0; i < j; i++)
120 if (points[i].y > gy0)
121 fill_rectangle(ax, points[i].x - size8, gy0, size4, points[i].y - gy0);
122 else fill_rectangle(ax, points[i].x - size8, points[i].y, size4, gy0 - points[i].y);
123 }
124 break;
125 }
126 }
127
128
draw_cursor(chan_info * cp)129 void draw_cursor(chan_info *cp)
130 {
131 cursor_style_t cur;
132 axis_info *ap;
133 graphics_context *ax;
134
135 if (!(cp->graph_time_on)) return;
136 ap = cp->axis;
137
138 ax = cursor_context(cp);
139
140 if ((ss->tracking) && (cp->sound->playing))
141 cur = cp->tracking_cursor_style;
142 else cur = cp->cursor_style;
143
144 switch (cur)
145 {
146 case CURSOR_CROSS:
147 draw_line(ax, cp->cx, cp->cy - cp->cursor_size, cp->cx, cp->cy + cp->cursor_size);
148 draw_line(ax, cp->cx - cp->cursor_size, cp->cy, cp->cx + cp->cursor_size, cp->cy);
149 break;
150
151 case CURSOR_LINE:
152 if ((with_inset_graph(ss)) &&
153 (cp->inset_graph))
154 draw_inset_line_cursor(cp, ax);
155 else draw_line(ax, cp->cx, ap->y_axis_y0 - 1, cp->cx, ap->y_axis_y1);
156 break;
157
158 case CURSOR_PROC:
159 Xen_call_with_3_args((Xen_is_procedure(cp->cursor_proc)) ? (cp->cursor_proc) : (ss->cursor_proc),
160 C_int_to_Xen_sound(cp->sound->index),
161 C_int_to_Xen_integer(cp->chan),
162 /* this was time-graph, which was useless. It's now #t if we're in tracking-cursor mode */
163 C_bool_to_Xen_boolean(ss->tracking),
164 S_cursor_style " procedure");
165 break;
166 }
167
168 /* now draw the play triangle below the x axis */
169 fill_polygon(ax, 4,
170 cp->cx, ap->y_axis_y0,
171 cp->cx + play_arrow_size(ss), ap->y_axis_y0 + play_arrow_size(ss),
172 cp->cx, ap->y_axis_y0 + 2 * play_arrow_size(ss),
173 cp->cx, ap->y_axis_y0);
174
175 }
176
177
178
179 /* -------------------------------------------------------------------------------- */
180
181 #define AXIS_CONTEXT_ID_OK(Id) ((Id >= CHAN_GC) && (Id <= CHAN_TMPGC))
182 #define NO_SUCH_WIDGET Xen_make_error_type("no-such-widget")
183
184 #if USE_MOTIF
get_ax(chan_info * cp,int ax_id,const char * caller,Xen ignored)185 static graphics_context *get_ax(chan_info *cp, int ax_id, const char *caller, Xen ignored)
186 {
187 if ((cp) && (AXIS_CONTEXT_ID_OK(ax_id)))
188 return(set_context(cp, (chan_gc_t)ax_id));
189
190 Xen_error(Xen_make_error_type("no-such-graphics-context"),
191 Xen_list_6(C_string_to_Xen_string("~A: no such graphics context: ~A, sound index: ~A (~A), chan: ~A"),
192 C_string_to_Xen_string(caller),
193 C_int_to_Xen_integer(ax_id),
194 C_int_to_Xen_sound(cp->sound->index),
195 C_string_to_Xen_string(cp->sound->short_filename),
196 C_int_to_Xen_integer(cp->chan)));
197 return(NULL);
198 }
199
200
get_ax_no_cr(chan_info * cp,int ax_id,const char * caller)201 static graphics_context *get_ax_no_cr(chan_info *cp, int ax_id, const char *caller)
202 {
203 return(get_ax(cp,ax_id, caller, Xen_false));
204 }
205 #endif
206
207
208 #define TO_C_AXIS_CONTEXT(Snd, Chn, Ax, Caller, Cr) get_ax(get_cp(Snd, Chn, Caller), (Xen_is_integer(Ax)) ? Xen_integer_to_C_int(Ax) : (int)CHAN_GC, Caller, Cr)
209 #define TO_C_AXIS_CONTEXT_NO_CR(Snd, Chn, Ax, Caller) get_ax_no_cr(get_cp(Snd, Chn, Caller), (Xen_is_integer(Ax)) ? Xen_integer_to_C_int(Ax) : (int)CHAN_GC, Caller)
210
211
g_draw_line(Xen x0,Xen y0,Xen x1,Xen y1,Xen snd,Xen chn,Xen ax,Xen xcr)212 static Xen g_draw_line(Xen x0, Xen y0, Xen x1, Xen y1, Xen snd, Xen chn, Xen ax, Xen xcr)
213 {
214 #define H_draw_line "(" S_draw_line " x0 y0 x1 y1 :optional snd chn (ax " S_time_graph ") cr): draw a line"
215
216 Snd_assert_channel(S_draw_line, snd, chn, 5);
217 Xen_check_type(Xen_is_integer(x0), x0, 1, S_draw_line, "an integer");
218 Xen_check_type(Xen_is_integer(y0), y0, 2, S_draw_line, "an integer");
219 Xen_check_type(Xen_is_integer(x1), x1, 3, S_draw_line, "an integer");
220 Xen_check_type(Xen_is_integer(y1), y1, 4, S_draw_line, "an integer");
221 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 7, S_draw_line, "an integer such as " S_time_graph);
222
223 draw_line(TO_C_AXIS_CONTEXT(snd, chn, ax, S_draw_line, xcr),
224 Xen_integer_to_C_int(x0),
225 Xen_integer_to_C_int(y0),
226 Xen_integer_to_C_int(x1),
227 Xen_integer_to_C_int(y1));
228 return(Xen_false);
229 }
230
231
g_draw_dot(Xen x0,Xen y0,Xen size,Xen snd,Xen chn,Xen ax,Xen xcr)232 static Xen g_draw_dot(Xen x0, Xen y0, Xen size, Xen snd, Xen chn, Xen ax, Xen xcr)
233 {
234 #define H_draw_dot "(" S_draw_dot " x0 y0 size :optional snd chn (ax " S_time_graph ") cr): draw a dot"
235
236 Snd_assert_channel(S_draw_dot, snd, chn, 4);
237 Xen_check_type(Xen_is_integer(x0), x0, 1, S_draw_dot, "an integer");
238 Xen_check_type(Xen_is_integer(y0), y0, 2, S_draw_dot, "an integer");
239 Xen_check_type(Xen_is_integer(size), size, 3, S_draw_dot, "an integer");
240 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 6, S_draw_dot, "an integer such as " S_time_graph);
241
242 draw_dot(TO_C_AXIS_CONTEXT(snd, chn, ax, S_draw_dot, xcr),
243 Xen_integer_to_C_int(x0),
244 Xen_integer_to_C_int(y0),
245 Xen_integer_to_C_int(size));
246 return(Xen_false);
247 }
248
249
g_fill_rectangle(Xen x0,Xen y0,Xen width,Xen height,Xen snd,Xen chn,Xen ax,Xen erase,Xen xcr)250 static Xen g_fill_rectangle(Xen x0, Xen y0, Xen width, Xen height, Xen snd, Xen chn, Xen ax, Xen erase, Xen xcr)
251 {
252 #define H_fill_rectangle "(" S_fill_rectangle " x0 y0 width height :optional snd chn (ax " S_time_graph ") erase cr): draw a filled rectangle"
253
254 Snd_assert_channel(S_fill_rectangle, snd, chn, 5);
255 Xen_check_type(Xen_is_integer(x0), x0, 1, S_fill_rectangle, "an integer");
256 Xen_check_type(Xen_is_integer(y0), y0, 2, S_fill_rectangle, "an integer");
257 Xen_check_type(Xen_is_integer(width), width, 3, S_fill_rectangle, "an integer");
258 Xen_check_type(Xen_is_integer(height), height, 4, S_fill_rectangle, "an integer");
259 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 7, S_fill_rectangle, "an integer such as " S_time_graph);
260 Xen_check_type(Xen_is_boolean_or_unbound(erase), erase, 8, S_fill_rectangle, "a boolean");
261
262 if ((Xen_is_boolean(erase)) &&
263 (Xen_is_true(erase)))
264 erase_rectangle(get_cp(snd, chn, S_fill_rectangle),
265 TO_C_AXIS_CONTEXT(snd, chn, ax, S_fill_rectangle, xcr),
266 Xen_integer_to_C_int(x0),
267 Xen_integer_to_C_int(y0),
268 Xen_integer_to_C_int(width),
269 Xen_integer_to_C_int(height));
270 else fill_rectangle(TO_C_AXIS_CONTEXT(snd, chn, ax, S_fill_rectangle, xcr),
271 Xen_integer_to_C_int(x0),
272 Xen_integer_to_C_int(y0),
273 Xen_integer_to_C_int(width),
274 Xen_integer_to_C_int(height));
275 return(Xen_false);
276 }
277
278
g_draw_string(Xen text,Xen x0,Xen y0,Xen snd,Xen chn,Xen ax,Xen xcr)279 static Xen g_draw_string(Xen text, Xen x0, Xen y0, Xen snd, Xen chn, Xen ax, Xen xcr)
280 {
281 #define H_draw_string "(" S_draw_string " text x0 y0 :optional snd chn (ax " S_time_graph ") cr): draw a string"
282
283 const char *tmp = NULL;
284 Snd_assert_channel(S_draw_string, snd, chn, 4);
285 Xen_check_type(Xen_is_string(text), text, 1, S_draw_string, "a string");
286 Xen_check_type(Xen_is_integer(x0), x0, 2, S_draw_string, "an integer");
287 Xen_check_type(Xen_is_integer(y0), y0, 3, S_draw_string, "an integer");
288 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 6, S_draw_string, "an integer such as " S_time_graph);
289
290 tmp = Xen_string_to_C_string(text);
291 #if USE_MOTIF
292 /* snd-xdraw to make motif draw-string act in the same way (coordinate-wise) as gtk */
293 /* despite the name, this is not a gtk function */
294 gtk_style_draw_string(TO_C_AXIS_CONTEXT(snd, chn, ax, S_draw_string, xcr),
295 #endif
296 Xen_integer_to_C_int(x0),
297 Xen_integer_to_C_int(y0),
298 tmp,
299 mus_strlen(tmp));
300 return(text);
301 }
302
303
vector_to_points(Xen pts,const char * caller,int * vector_len)304 static point_t *vector_to_points(Xen pts, const char *caller, int *vector_len)
305 {
306 int i, j, vlen = 0, len = 0;
307 point_t *pack_pts;
308
309 vlen = Xen_vector_length(pts);
310 if (vlen & 1)
311 Xen_error(Xen_make_error_type("bad-length"),
312 Xen_list_3(C_string_to_Xen_string("~A: length of vector of points (~A) must be even"),
313 C_string_to_Xen_string(caller),
314 C_int_to_Xen_integer(vlen)));
315 if (vlen <= 0)
316 Xen_error(NO_DATA,
317 Xen_list_3(C_string_to_Xen_string("~A: empty points vector? ~A"),
318 C_string_to_Xen_string(caller),
319 pts));
320 len = vlen / 2;
321 if (len > 10000000) len = 10000000; /* gcc gabbles stupidly about calloc overflow! */
322 (*vector_len) = len;
323 pack_pts = (point_t *)calloc(len, sizeof(point_t));
324
325 for (i = 0, j = 0; i < len; i++, j += 2)
326 {
327 Xen p;
328 p = Xen_vector_ref(pts, j);
329 Xen_check_type(Xen_is_integer(p), p, j, caller, "an integer");
330 pack_pts[i].x = Xen_integer_to_C_int(p);
331 p = Xen_vector_ref(pts, j + 1);
332 Xen_check_type(Xen_is_integer(p), p, j + 1, caller, "an integer");
333 pack_pts[i].y = Xen_integer_to_C_int(p);
334 }
335 return(pack_pts);
336 }
337
338
g_draw_lines(Xen pts,Xen snd,Xen chn,Xen ax,Xen xcr)339 static Xen g_draw_lines(Xen pts, Xen snd, Xen chn, Xen ax, Xen xcr)
340 {
341 /* pts should be a vector of integers as (x y) pairs */
342 #define H_draw_lines "(" S_draw_lines " lines :optional snd chn (ax " S_time_graph ") cr): draw a vector of lines"
343
344 point_t *pack_pts;
345 graphics_context *ax1;
346 int vlen = 0;
347
348 Snd_assert_channel(S_draw_lines, snd, chn, 2);
349 Xen_check_type(Xen_is_vector(pts), pts, 1, S_draw_lines, "a vector");
350 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 4, S_draw_lines, "an integer such as " S_time_graph);
351
352 ax1 = TO_C_AXIS_CONTEXT(snd, chn, ax, S_draw_lines, xcr);
353
354 pack_pts = vector_to_points(pts, S_draw_lines, &vlen);
355 draw_lines(ax1, pack_pts, vlen);
356
357 free(pack_pts);
358 return(pts);
359 }
360
361
g_draw_dots(Xen pts,Xen size,Xen snd,Xen chn,Xen ax,Xen xcr)362 static Xen g_draw_dots(Xen pts, Xen size, Xen snd, Xen chn, Xen ax, Xen xcr)
363 {
364 /* pts should be a vector of integers as (x y) pairs */
365 #define H_draw_dots "(" S_draw_dots " positions :optional dot-size snd chn (ax " S_time_graph ") cr): draw a vector of dots"
366
367 point_t *pack_pts;
368 graphics_context *ax1;
369 int vlen = 0;
370
371 Snd_assert_channel(S_draw_dots, snd, chn, 3);
372 Xen_check_type(Xen_is_vector(pts), pts, 1, S_draw_dots, "a vector");
373 Xen_check_type(Xen_is_integer_or_unbound(size), size, 2, S_draw_dots, "an integer");
374 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 5, S_draw_dots, "an integer such as " S_time_graph);
375
376 ax1 = TO_C_AXIS_CONTEXT(snd, chn, ax, S_draw_dots, xcr);
377
378 pack_pts = vector_to_points(pts, S_draw_dots, &vlen);
379 draw_points(ax1,
380 pack_pts,
381 vlen,
382 (Xen_is_integer(size)) ? Xen_integer_to_C_int(size) : 1);
383
384 free(pack_pts);
385 return(pts);
386 }
387
388
g_fill_polygon(Xen pts,Xen snd,Xen chn,Xen ax_id,Xen xcr)389 static Xen g_fill_polygon(Xen pts, Xen snd, Xen chn, Xen ax_id, Xen xcr)
390 {
391 #define H_fill_polygon "(" S_fill_polygon " points :optional snd chn (ax " S_time_graph ") cr): draw a filled polygon"
392
393 point_t *pack_pts;
394 graphics_context *ax;
395 int vlen = 0;
396
397 Snd_assert_channel(S_fill_polygon, snd, chn, 2);
398 Xen_check_type(Xen_is_vector(pts), pts, 1, S_fill_polygon, "a vector");
399 Xen_check_type(Xen_is_integer_or_unbound(ax_id), ax_id, 4, S_fill_polygon, "an integer such as " S_time_graph);
400
401 ax = TO_C_AXIS_CONTEXT(snd, chn, ax_id, S_fill_polygon, xcr);
402
403 pack_pts = vector_to_points(pts, S_fill_polygon, &vlen);
404 #if USE_MOTIF
405 XFillPolygon(ax->dp, ax->wn, ax->gc, pack_pts, vlen, Complex, CoordModeOrigin);
406 #endif
407
408 free(pack_pts);
409 return(pts);
410 }
411
412
g_make_bezier(Xen args1)413 static Xen g_make_bezier(Xen args1)
414 {
415 /* used in musglyphs.rb -- not currently used anywhere else */
416
417 #define S_make_bezier "make-bezier"
418 #define H_make_bezier "(" S_make_bezier " x0 y0 x1 y1 x2 y2 x3 y3 n): return a vector of points corresponding to the bezier curve \
419 defined by the 4 controlling points x0..y3; 'n' is how many points to return"
420 /* XDrawBezier from cmn's glfed.c (where it was assuming PostScript coordinates) */
421
422 int ax, ay, bx, by, cx, cy, i;
423 float incr, val;
424 int x[4];
425 int y[4];
426 int n = 50;
427 Xen pts, args;
428
429 args = Xen_copy_arg(args1);
430 for (i = 0; i < 4; i++)
431 {
432 x[i] = Xen_integer_to_C_int(Xen_car(args));
433 y[i] = Xen_integer_to_C_int(Xen_cadr(args));
434 args = Xen_cddr(args);
435 }
436 if (!Xen_is_null(args))
437 n = Xen_integer_to_C_int(Xen_car(args));
438
439 cx = 3 * (x[1] - x[0]);
440 cy = 3 * (y[1] - y[0]);
441 bx = 3 * (x[2] - x[1]) - cx;
442 by = 3 * (y[2] - y[1]) - cy;
443 ax = x[3] - (x[0] + cx + bx);
444 ay = y[3] - (y[0] + cy + by);
445 incr = 1.0 / (double)n;
446 pts = Xen_make_vector(2 * (n + 1), Xen_integer_zero);
447
448 Xen_vector_set(pts, 0, C_int_to_Xen_integer(x[0]));
449 Xen_vector_set(pts, 1, C_int_to_Xen_integer(y[0]));
450
451 for (i = 1, val = incr; i <= n; i++, val += incr)
452 {
453 Xen_vector_set(pts, i * 2, C_int_to_Xen_integer((int)(x[0] + val * (cx + (val * (bx + (val * ax)))))));
454 Xen_vector_set(pts, i * 2 + 1, C_int_to_Xen_integer((int)(y[0] + val * (cy + (val * (by + (val * ay)))))));
455 }
456 return(pts);
457 }
458
459
g_foreground_color(Xen snd,Xen chn,Xen xax)460 static Xen g_foreground_color(Xen snd, Xen chn, Xen xax)
461 {
462 #define H_foreground_color "(" S_foreground_color " :optional snd chn (ax " S_time_graph ")): current drawing color"
463 chan_info *cp;
464 graphics_context *ax;
465
466 Snd_assert_channel(S_foreground_color, snd, chn, 1);
467 Xen_check_type(Xen_is_integer_or_unbound(xax), xax, 3, S_foreground_color, "an integer");
468
469 cp = get_cp(snd, chn, S_foreground_color);
470 if (!cp) return(Xen_false);
471
472 ax = get_ax_no_cr(cp, (Xen_is_integer(xax)) ? Xen_integer_to_C_int(xax) : (int)CHAN_GC, S_foreground_color);
473 return(Xen_wrap_pixel(get_foreground_color(ax)));
474 }
475
476
g_set_foreground_color(Xen color,Xen snd,Xen chn,Xen ax)477 static Xen g_set_foreground_color(Xen color, Xen snd, Xen chn, Xen ax)
478 {
479 chan_info *cp;
480
481 Snd_assert_channel(S_set S_foreground_color, snd, chn, 2);
482 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_foreground_color, "a color");
483 Xen_check_type(Xen_is_integer_or_unbound(ax), ax, 4, S_set S_foreground_color, "an integer");
484
485 cp = get_cp(snd, chn, S_set S_foreground_color);
486 if (!cp) return(Xen_false);
487
488 set_foreground_color(get_ax_no_cr(cp, (Xen_is_integer(ax)) ? Xen_integer_to_C_int(ax) : (int)CHAN_GC, S_set S_foreground_color),
489 Xen_unwrap_pixel(color));
490 return(color);
491 }
492
with_four_setter_args(g_set_foreground_color_reversed,g_set_foreground_color)493 with_four_setter_args(g_set_foreground_color_reversed, g_set_foreground_color)
494
495
496 #if USE_MOTIF
497
498 static Xen g_set_current_font(Xen id, Xen snd, Xen chn, Xen ax_id)
499 {
500 graphics_context *ax;
501
502 Snd_assert_channel(S_set S_current_font, snd, chn, 2);
503 Xen_check_type(Xen_is_integer_or_unbound(ax_id), ax_id, 4, S_set S_current_font, "an integer such as time-graph");
504 Xen_check_type((Xen_is_list(id)) &&
505 (Xen_list_length(id) >= 2) &&
506 (Xen_is_symbol(Xen_car(id))) &&
507 (strcmp("Font", Xen_symbol_to_C_string(Xen_car(id))) == 0), id, 1, S_set S_current_font, "a Font");
508 ax = TO_C_AXIS_CONTEXT_NO_CR(snd, chn, ax_id, S_current_font);
509 ax->current_font = (Font)Xen_ulong_to_C_ulong(Xen_cadr(id));
510 XSetFont(ax->dp, ax->gc, ax->current_font);
511 return(id);
512 }
513
514
g_current_font(Xen snd,Xen chn,Xen ax_id)515 static Xen g_current_font(Xen snd, Xen chn, Xen ax_id)
516 {
517 #define H_current_font "(" S_current_font " :optional snd chn (ax " S_time_graph ")): current font id"
518 graphics_context *ax;
519 chan_info *cp;
520
521 Snd_assert_channel(S_current_font, snd, chn, 1);
522 Xen_check_type(Xen_is_integer_or_unbound(ax_id), ax_id, 3, S_current_font, "an integer such as time-graph");
523 cp = get_cp(snd, chn, S_current_font);
524 if (!cp) return(Xen_false);
525
526 ax = get_ax_no_cr(cp, (Xen_is_integer(ax_id)) ? Xen_integer_to_C_int(ax_id) : (int)CHAN_GC, S_current_font);
527 if (ax->current_font == 0)
528 {
529 if ((cp->axis) && (cp->axis->ax))
530 return(Xen_list_2(C_string_to_Xen_symbol("Font"),
531 C_ulong_to_Xen_ulong(cp->axis->ax->current_font)));
532 else return(Xen_false);
533 }
534 return(Xen_list_2(C_string_to_Xen_symbol("Font"),
535 C_ulong_to_Xen_ulong(ax->current_font)));
536 }
537 #endif
538
with_four_setter_args(g_set_current_font_reversed,g_set_current_font)539 with_four_setter_args(g_set_current_font_reversed, g_set_current_font)
540
541 static Xen g_make_graph_data(Xen snd, Xen chn, Xen edpos, Xen lo, Xen hi)
542 {
543 #define H_make_graph_data "(" S_make_graph_data " :optional snd chn edpos low high): \
544 return either a " S_vct " (if the graph has one trace), or a list of two " S_vct "s (the two sides of the envelope graph). \
545 'edpos' defaults to the " S_current_edit_position ", 'low' defaults to the current window left sample, and \
546 'high' defaults to the current rightmost sample. (" S_graph_data " (" S_make_graph_data ")) reimplements the time domain graph."
547
548 chan_info *cp;
549
550 Snd_assert_channel(S_make_graph_data, snd, chn, 1);
551 cp = get_cp(snd, chn, S_make_graph_data);
552 if (!cp) return(Xen_false);
553
554 Xen_check_type(Xen_is_integer_or_unbound(lo), lo, 4, S_make_graph_data, "an integer");
555 Xen_check_type(Xen_is_integer_or_unbound(hi), hi, 5, S_make_graph_data, "an integer");
556
557 return(make_graph_data(cp,
558 to_c_edit_position(cp, edpos, S_make_graph_data, 3),
559 (Xen_is_llong(lo)) ? Xen_llong_to_C_llong(lo) : -1,
560 (Xen_is_llong(hi)) ? Xen_llong_to_C_llong(hi) : -1));
561 }
562
563
g_graph_data(Xen data,Xen snd,Xen chn,Xen ax,Xen lo,Xen hi,Xen style,Xen xcr)564 static Xen g_graph_data(Xen data, Xen snd, Xen chn, Xen ax, Xen lo, Xen hi, Xen style, Xen xcr)
565 {
566 #define H_graph_data "(" S_graph_data " data :optional snd chn (context " S_copy_context ") low high graph-style cr): \
567 display 'data' in the time domain graph of snd's channel chn using the graphics context context (normally " S_copy_context "), placing the \
568 data in the recipient's graph between points low and high in the drawing mode graphic-style."
569
570 chan_info *cp;
571 vct *v0, *v1 = NULL;
572
573 Snd_assert_channel(S_graph_data, snd, chn, 2);
574
575 cp = get_cp(snd, chn, S_graph_data);
576 if (!cp) return(Xen_false);
577
578 if (Xen_is_false(data)) return(Xen_false);
579 Xen_check_type((Xen_is_list(data) &&
580 (Xen_list_length(data) == 2) &&
581 (mus_is_vct(Xen_car(data))) &&
582 (mus_is_vct(Xen_cadr(data)))) ||
583 (mus_is_vct(data)),
584 data, 1, S_graph_data, "a list of 2 " S_vct "s or a " S_vct);
585 Xen_check_type(Xen_is_integer_boolean_or_unbound(ax), ax, 4, S_graph_data, "an integer");
586 Xen_check_type(Xen_is_llong(lo) || Xen_is_false(lo) || !Xen_is_bound(lo), lo, 5, S_graph_data, "a sample number");
587 Xen_check_type(Xen_is_llong(hi) || Xen_is_false(hi) || !Xen_is_bound(hi), hi, 6, S_graph_data, "a sample number");
588 Xen_check_type(Xen_is_integer_boolean_or_unbound(style), style, 7, S_graph_data, "an integer");
589
590 if (Xen_is_list(data))
591 {
592 v0 = xen_to_vct(Xen_car(data));
593 v1 = xen_to_vct(Xen_cadr(data));
594 }
595 else v0 = xen_to_vct(data);
596
597 draw_graph_data(cp,
598 (Xen_is_llong(lo)) ? Xen_llong_to_C_llong(lo) : -1,
599 (Xen_is_llong(hi)) ? Xen_llong_to_C_llong(hi) : -1,
600 mus_vct_length(v0),
601 mus_vct_data(v0),
602 (v1) ? (mus_vct_data(v1)) : NULL,
603 get_ax(cp, (Xen_is_integer(ax)) ? Xen_integer_to_C_int(ax) : (int)CHAN_GC, S_graph_data, xcr),
604 (Xen_is_integer(style)) ? (graph_style_t)Xen_integer_to_C_int(style) : cp->time_graph_style);
605 return(data);
606 }
607
608
g_main_widgets(void)609 static Xen g_main_widgets(void)
610 {
611 #define H_main_widgets "(" S_main_widgets "): top level \
612 widgets (list (0)main-app (1)main-shell (2)main-pane (3)sound-pane (4)listener-pane (5)notebook-outer-pane)"
613
614 Xen bad_temp, res; /* needed by old gcc -- gets confused by straight arg list */
615 int loc;
616 #if USE_MOTIF
617 bad_temp = Xen_list_2(C_string_to_Xen_symbol("XtAppContext"),
618 C_ulong_to_Xen_ulong((unsigned long)main_app(ss)));
619 #endif
620 loc = snd_protect(bad_temp);
621 res = Xen_cons(bad_temp,
622 Xen_cons(Xen_wrap_widget(main_shell(ss)),
623 Xen_cons(Xen_wrap_widget(main_pane(ss)),
624 Xen_cons(Xen_wrap_widget(sound_pane(ss)),
625 Xen_cons(Xen_wrap_widget(ss->listener_pane),
626 Xen_cons(Xen_wrap_widget(sound_pane_box(ss)),
627 Xen_empty_list))))));
628 snd_unprotect_at(loc);
629 return(res);
630 }
631
632
633 static Xen dialog_widgets;
634 static Xen new_widget_hook;
635 /* ideally this would be an "after method" on XtCreateWidget */
636
run_new_widget_hook(widget_t w)637 void run_new_widget_hook(widget_t w)
638 {
639 if (Xen_hook_has_list(new_widget_hook))
640 run_hook(new_widget_hook, Xen_list_1(Xen_wrap_widget(w)), S_new_widget_hook);
641 }
642
643
check_dialog_widget_table(void)644 static void check_dialog_widget_table(void)
645 {
646 if (!(Xen_is_vector(dialog_widgets)))
647 {
648 dialog_widgets = Xen_make_vector(NUM_DIALOGS, Xen_false);
649 Xen_GC_protect(dialog_widgets);
650 }
651 }
652
653
g_dialog_widgets(void)654 static Xen g_dialog_widgets(void)
655 {
656 #define H_dialog_widgets "(" S_dialog_widgets "): dialog widgets (each " PROC_FALSE " if not yet created): (list \
657 (0 " S_color_orientation_dialog ") (1 " S_enved_dialog ") (2 " S_transform_dialog ") \
658 (3 " S_open_file_dialog ") (4 " S_save_sound_dialog ") (5 " S_view_files_dialog ") (6 raw data dialog) (7 new file dialog) \
659 (8 " S_mix_file_dialog ") (9 " S_edit_header_dialog ") (10 " S_find_dialog ") (11 " S_help_dialog ") \
660 (12 " S_view_mixes_dialog ") (13 " S_print_dialog ") (14 " S_view_regions_dialog ") \
661 (15 " S_info_dialog ") (16 extra controls dialog) (17 " S_save_selection_dialog ") (18 " S_insert_file_dialog ") \
662 (19 " S_save_region_dialog ") (20 " S_preferences_dialog "))"
663
664 check_dialog_widget_table();
665 return(Xen_vector_to_Xen_list(dialog_widgets));
666 }
667
668
set_dialog_widget(snd_dialog_t which,widget_t wid)669 void set_dialog_widget(snd_dialog_t which, widget_t wid)
670 {
671 if (!ss->dialogs)
672 {
673 ss->dialogs_size = 8;
674 ss->num_dialogs = 0;
675 ss->dialogs = (widget_t *)calloc(ss->dialogs_size, sizeof(widget_t));
676 }
677 else
678 {
679 if (ss->num_dialogs == ss->dialogs_size)
680 {
681 int i;
682 ss->dialogs_size += 8;
683 ss->dialogs = (widget_t *)realloc(ss->dialogs, ss->dialogs_size * sizeof(widget_t));
684 for (i = ss->num_dialogs; i < ss->dialogs_size; i++) ss->dialogs[i] = NULL;
685 }
686 }
687 ss->dialogs[ss->num_dialogs++] = wid;
688 check_dialog_widget_table();
689
690 if (Xen_is_false(Xen_vector_ref(dialog_widgets, (int)which)))
691 Xen_vector_set(dialog_widgets, (int)which,
692 Xen_wrap_widget(wid));
693 else
694 {
695 if (Xen_is_widget(Xen_vector_ref(dialog_widgets, (int)which)))
696 Xen_vector_set(dialog_widgets, (int)which,
697 Xen_list_2(Xen_wrap_widget(wid),
698 Xen_vector_ref(dialog_widgets, (int)which)));
699 else Xen_vector_set(dialog_widgets, (int)which,
700 Xen_cons(Xen_wrap_widget(wid),
701 Xen_vector_ref(dialog_widgets, (int)which)));
702 }
703 run_new_widget_hook(wid);
704 }
705
706
g_widget_position(Xen wid)707 static Xen g_widget_position(Xen wid)
708 {
709 #define H_widget_position "(" S_widget_position " wid): widget's position, (list x y), in pixels"
710 widget_t w;
711 Xen_check_type(Xen_is_widget(wid), wid, 1, S_widget_position, "a Widget");
712 w = (widget_t)(Xen_unwrap_widget(wid));
713 if (!w)
714 Xen_error(NO_SUCH_WIDGET,
715 Xen_list_2(C_string_to_Xen_string(S_widget_position ": no such widget: ~A"),
716 wid));
717 return(Xen_list_2(C_int_to_Xen_integer(widget_x(w)),
718 C_int_to_Xen_integer(widget_y(w))));
719 }
720
721
g_set_widget_position(Xen wid,Xen xy)722 static Xen g_set_widget_position(Xen wid, Xen xy)
723 {
724 widget_t w;
725 Xen_check_type(Xen_is_widget(wid), wid, 1, S_set S_widget_position, "a Widget");
726 Xen_check_type(Xen_is_list(xy) && (Xen_list_length(xy) == 2), xy, 2, S_set S_widget_position, "a list: (x y)");
727 w = (widget_t)(Xen_unwrap_widget(wid));
728 if (w)
729 {
730 Xen_check_type(Xen_is_integer(Xen_car(xy)), Xen_car(xy), 0, S_set S_widget_position, "an integer");
731 Xen_check_type(Xen_is_integer(Xen_cadr(xy)), Xen_cadr(xy), 0, S_set S_widget_position, "an integer");
732 set_widget_position(w,
733 mus_iclamp(0, Xen_integer_to_C_int(Xen_car(xy)), LOTSA_PIXELS),
734 mus_iclamp(0, Xen_integer_to_C_int(Xen_cadr(xy)), LOTSA_PIXELS));
735 }
736 else Xen_error(NO_SUCH_WIDGET,
737 Xen_list_2(C_string_to_Xen_string(S_set S_widget_position ": no such widget: ~A"),
738 wid));
739 return(wid);
740 }
741
742
g_widget_size(Xen wid)743 static Xen g_widget_size(Xen wid)
744 {
745 #define H_widget_size "(" S_widget_size " wid): widget's size, (list width height), in pixels"
746 widget_t w;
747 Xen_check_type(Xen_is_widget(wid), wid, 1, S_widget_size, "a Widget");
748 w = (widget_t)(Xen_unwrap_widget(wid));
749 if (!w)
750 Xen_error(NO_SUCH_WIDGET,
751 Xen_list_2(C_string_to_Xen_string(S_widget_size ": no such widget: ~A"),
752 wid));
753 return(Xen_list_2(C_int_to_Xen_integer(widget_width(w)),
754 C_int_to_Xen_integer(widget_height(w))));
755 }
756
757
g_set_widget_size(Xen wid,Xen wh)758 static Xen g_set_widget_size(Xen wid, Xen wh)
759 {
760 widget_t w;
761 Xen_check_type(Xen_is_widget(wid), wid, 1, S_set S_widget_size, "a Widget");
762 Xen_check_type(Xen_is_list(wh) && (Xen_list_length(wh) == 2), wh, 2, S_set S_widget_size, "a list: (width height)");
763 w = (widget_t)(Xen_unwrap_widget(wid));
764 if (w)
765 {
766 Xen_check_type(Xen_is_integer(Xen_car(wh)), Xen_car(wh), 0, S_set S_widget_size, "an integer");
767 Xen_check_type(Xen_is_integer(Xen_cadr(wh)), Xen_cadr(wh), 0, S_set S_widget_size, "an integer");
768 set_widget_size(w,
769 mus_iclamp(1, Xen_integer_to_C_int(Xen_car(wh)), LOTSA_PIXELS),
770 mus_iclamp(1, Xen_integer_to_C_int(Xen_cadr(wh)), LOTSA_PIXELS));
771 }
772 else Xen_error(NO_SUCH_WIDGET,
773 Xen_list_2(C_string_to_Xen_string(S_set S_widget_size ": no such widget: ~A"),
774 wid));
775 return(wid);
776 }
777
778
g_widget_text(Xen wid)779 static Xen g_widget_text(Xen wid)
780 {
781 #define H_widget_text "(" S_widget_text " wid): widget's text or label"
782 widget_t w;
783
784 Xen res = Xen_false;
785 Xen_check_type(Xen_is_widget(wid), wid, 1, S_widget_text, "a Widget");
786
787 w = (widget_t)(Xen_unwrap_widget(wid));
788 if (w)
789 {
790 #if USE_MOTIF
791 char *text = NULL;
792 if ((XmIsText(w)) || (XmIsTextField(w)))
793 {
794 text = XmTextGetString(w);
795 res = C_string_to_Xen_string(text);
796 }
797 else
798 {
799 XmString s1 = NULL;
800 XtVaGetValues(w, XmNlabelString, &s1, NULL);
801 if (XmStringEmpty(s1)) return(Xen_false);
802 text = (char *)XmStringUnparse(s1, NULL, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
803 XmStringFree(s1);
804 res = C_string_to_Xen_string(text);
805 }
806 if (text) XtFree(text);
807 return(res);
808 #endif
809 }
810 else Xen_error(NO_SUCH_WIDGET,
811 Xen_list_2(C_string_to_Xen_string(S_widget_text ": no such widget: ~A"),
812 wid));
813 return(res);
814 }
815
816
g_set_widget_text(Xen wid,Xen text)817 static Xen g_set_widget_text(Xen wid, Xen text)
818 {
819 widget_t w;
820
821 Xen_check_type(Xen_is_widget(wid), wid, 1, S_set S_widget_text, "a Widget");
822 Xen_check_type(Xen_is_string(text) || Xen_is_false(text), text, 2, S_set S_widget_text, "a string");
823
824 w = (widget_t)(Xen_unwrap_widget(wid));
825 if (w)
826 {
827 const char *str = NULL;
828 if (Xen_is_string(text)) str = Xen_string_to_C_string(text);
829 #if USE_MOTIF
830 if ((XmIsText(w)) || (XmIsTextField(w)))
831 XmTextSetString(w, (char *)str);
832 else set_button_label(w, str);
833 #endif
834 }
835 else Xen_error(NO_SUCH_WIDGET,
836 Xen_list_2(C_string_to_Xen_string(S_set S_widget_text ": no such widget: ~A"),
837 wid));
838 return(text);
839 }
840
841
g_hide_widget(Xen wid)842 static Xen g_hide_widget(Xen wid)
843 {
844 #define H_hide_widget "(" S_hide_widget " widget): hide or undisplay widget"
845 widget_t w;
846 Xen_check_type(Xen_is_widget(wid), wid, 1, S_hide_widget, "a Widget");
847 w = (widget_t)(Xen_unwrap_widget(wid));
848 if (w)
849 {
850 #if USE_MOTIF
851 XtUnmanageChild(w);
852 #endif
853 }
854 else Xen_error(NO_SUCH_WIDGET,
855 Xen_list_2(C_string_to_Xen_string(S_hide_widget ": no such widget: ~A"),
856 wid));
857 return(wid);
858 }
859
860
g_show_widget(Xen wid)861 static Xen g_show_widget(Xen wid)
862 {
863 #define H_show_widget "(" S_show_widget " widget): show or display widget"
864 widget_t w;
865 Xen_check_type(Xen_is_widget(wid), wid, 1, S_show_widget, "a Widget");
866 w = (widget_t)(Xen_unwrap_widget(wid));
867 if (w)
868 {
869 #if USE_MOTIF
870 XtManageChild(w);
871 #endif
872 }
873 else Xen_error(NO_SUCH_WIDGET,
874 Xen_list_2(C_string_to_Xen_string(S_show_widget ": no such widget: ~A"),
875 wid));
876 return(wid);
877 }
878
879
g_focus_widget(Xen wid)880 static Xen g_focus_widget(Xen wid)
881 {
882 #define H_focus_widget "(" S_focus_widget " widget): cause widget to receive input focus"
883 widget_t w;
884 Xen_check_type(Xen_is_widget(wid), wid, 1, S_focus_widget, "a Widget");
885 w = (widget_t)(Xen_unwrap_widget(wid));
886 if (w)
887 goto_window(w);
888 else Xen_error(NO_SUCH_WIDGET,
889 Xen_list_2(C_string_to_Xen_string(S_focus_widget ": no such widget: ~A"),
890 wid));
891 return(wid);
892 }
893
894
g_snd_gcs(void)895 static Xen g_snd_gcs(void)
896 {
897 #define H_snd_gcs "(" S_snd_gcs "): a list of Snd graphics contexts (list (0 basic) (1 selected_basic) (2 combined) (3 \
898 cursor) (4 selected_cursor) (5 selection) (6 selected_selection) (7 erase) (8 selected_erase) (9 mark) (10 selected_mark) (11 mix) (12 \
899 fltenv_basic) (13 fltenv_data))."
900
901 #if USE_MOTIF
902 #define Xen_wrap_snd_gc(Value) Xen_list_2(C_string_to_Xen_symbol("GC"), Xen_wrap_C_pointer(Value))
903 #endif
904
905 #if (!USE_NO_GUI)
906 return(Xen_cons(Xen_wrap_snd_gc(ss->basic_gc),
907 Xen_cons(Xen_wrap_snd_gc(ss->selected_basic_gc),
908 Xen_cons(Xen_wrap_snd_gc(ss->combined_basic_gc),
909 Xen_cons(Xen_wrap_snd_gc(ss->cursor_gc),
910 Xen_cons(Xen_wrap_snd_gc(ss->selected_cursor_gc),
911 Xen_cons(Xen_wrap_snd_gc(ss->selection_gc),
912 Xen_cons(Xen_wrap_snd_gc(ss->selected_selection_gc),
913 Xen_cons(Xen_wrap_snd_gc(ss->erase_gc),
914 Xen_cons(Xen_wrap_snd_gc(ss->selected_erase_gc),
915 Xen_cons(Xen_wrap_snd_gc(ss->mark_gc),
916 Xen_cons(Xen_wrap_snd_gc(ss->selected_mark_gc),
917 Xen_cons(Xen_wrap_snd_gc(ss->mix_gc),
918 Xen_cons(Xen_wrap_snd_gc(ss->fltenv_basic_gc),
919 Xen_cons(Xen_wrap_snd_gc(ss->fltenv_data_gc),
920 Xen_empty_list)))))))))))))));
921 #else
922 return(Xen_empty_list);
923 #endif
924 }
925
926
g_snd_color(Xen choice)927 static Xen g_snd_color(Xen choice)
928 {
929 #define H_snd_color "(" S_snd_color " num): color associated with 'num' -- see table of colors in snd-draw.c"
930 color_t col;
931 Xen_check_type(Xen_is_integer(choice), choice, 1, S_snd_color, "an integer");
932
933 switch (Xen_integer_to_C_int(choice))
934 {
935 case 0: col = ss->white; break;
936 case 1: col = ss->black; break;
937 case 2: col = ss->red; break;
938 case 3: col = ss->yellow; break;
939 case 4: col = ss->green; break;
940 case 5: col = ss->light_blue; break;
941 case 6: col = ss->lighter_blue; break;
942
943 case 7: col = ss->data_color; break;
944 case 8: col = ss->selected_data_color; break;
945 case 9: col = ss->mark_color; break;
946 case 10: col = ss->graph_color; break;
947 case 11: col = ss->selected_graph_color; break;
948 case 12: col = ss->listener_color; break;
949 case 13: col = ss->listener_text_color; break;
950
951 case 14: col = ss->basic_color; break;
952 case 15: col = ss->selection_color; break;
953 case 16: col = ss->zoom_color; break;
954 case 17: col = ss->position_color; break;
955 case 18: col = ss->highlight_color; break;
956 case 19: col = ss->enved_waveform_color; break;
957 case 20: col = ss->cursor_color; break;
958
959 case 21: col = ss->text_focus_color; break;
960 case 22: col = ss->filter_control_waveform_color; break;
961 case 23: col = ss->mix_color; break;
962 case 25: col = ss->sash_color; break;
963
964 case 31: col = ss->grid_color; break;
965 case 32: col = ss->selected_grid_color; break;
966 case 33:
967 if (ss->axis_color_set)
968 col = ss->axis_color;
969 else col = ss->black;
970 break;
971 default: col = ss->black; break;
972 }
973 return(Xen_wrap_pixel(col));
974 }
975
976
g_snd_font(Xen choice)977 static Xen g_snd_font(Xen choice)
978 {
979 #if USE_MOTIF
980 #define WRAP_FONT(Value) Xen_list_2(C_string_to_Xen_symbol("Font"), C_ulong_to_Xen_ulong((unsigned long)Value))
981 #endif
982
983 #define H_snd_font "(" S_snd_font " num): font associated with 'num' -- see table of fonts in snd-draw.c"
984 Xen_check_type(Xen_is_integer(choice), choice, 1, S_snd_font, "an integer");
985
986 switch (Xen_integer_to_C_int(choice))
987 {
988 #if USE_MOTIF
989 case 0: return(WRAP_FONT(ss->peaks_fontstruct->fid));
990 case 1: return(WRAP_FONT(ss->bold_peaks_fontstruct->fid));
991 case 2: return(WRAP_FONT(ss->tiny_fontstruct->fid));
992 case 3: return(WRAP_FONT(ss->axis_label_fontstruct->fid));
993 case 4: return(WRAP_FONT(ss->axis_numbers_fontstruct->fid));
994 case 5: return(WRAP_FONT(ss->listener_fontstruct->fid));
995 #endif
996 default: return(Xen_false);
997 }
998 return(Xen_false);
999 }
1000
1001
1002 #if HAVE_GL
1003 static mus_float_t gl_currents[6] = {DEFAULT_SPECTRO_X_ANGLE, DEFAULT_SPECTRO_Y_ANGLE, DEFAULT_SPECTRO_Z_ANGLE,
1004 DEFAULT_SPECTRO_X_SCALE, DEFAULT_SPECTRO_Y_SCALE, DEFAULT_SPECTRO_Z_SCALE};
1005 static mus_float_t x_currents[6] = {90.0, 0.0, 358.0, 1.0, 1.0, 0.1};
1006
sgl_save_currents(void)1007 void sgl_save_currents(void)
1008 {
1009 mus_float_t *vals;
1010 if (with_gl(ss)) vals = gl_currents; else vals = x_currents;
1011 vals[0] = spectro_x_angle(ss);
1012 vals[1] = spectro_y_angle(ss);
1013 vals[2] = spectro_z_angle(ss);
1014 vals[3] = spectro_x_scale(ss);
1015 vals[4] = spectro_y_scale(ss);
1016 vals[5] = spectro_z_scale(ss);
1017 }
1018
1019
sgl_set_currents(bool with_dialogs)1020 void sgl_set_currents(bool with_dialogs)
1021 {
1022 mus_float_t *vals;
1023 if (with_gl(ss)) vals = gl_currents; else vals = x_currents;
1024 in_set_spectro_x_angle(vals[0]);
1025 in_set_spectro_y_angle(vals[1]);
1026 in_set_spectro_z_angle(vals[2]);
1027 in_set_spectro_x_scale(vals[3]);
1028 in_set_spectro_y_scale(vals[4]);
1029 in_set_spectro_z_scale(vals[5]);
1030 if (with_dialogs) reflect_spectro();
1031 chans_field(FCP_X_ANGLE, vals[0]);
1032 chans_field(FCP_Y_ANGLE, vals[1]);
1033 chans_field(FCP_Z_ANGLE, vals[2]);
1034 chans_field(FCP_X_SCALE, vals[3]);
1035 chans_field(FCP_Y_SCALE, vals[4]);
1036 chans_field(FCP_Z_SCALE, vals[5]);
1037 }
1038 #endif
1039
1040
1041
1042 /* -------- shared color funcs -------- */
1043
g_is_color(Xen obj)1044 static Xen g_is_color(Xen obj)
1045 {
1046 #define H_is_color "(" S_is_color " obj): " PROC_TRUE " if obj is a color"
1047 return(C_bool_to_Xen_boolean(Xen_is_pixel(obj)));
1048 }
1049
1050
check_color_range(const char * caller,Xen val)1051 mus_float_t check_color_range(const char *caller, Xen val)
1052 {
1053 mus_float_t rf;
1054 rf = Xen_real_to_C_double(val);
1055 if ((rf > 1.0) || (rf < 0.0))
1056 Xen_out_of_range_error(caller, 1, val, "value must be between 0.0 and 1.0");
1057 return(rf);
1058 }
1059
1060
g_set_cursor_color(Xen color)1061 static Xen g_set_cursor_color(Xen color)
1062 {
1063 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_cursor_color, "a color");
1064 color_cursor(Xen_unwrap_pixel(color));
1065 for_each_chan(update_graph);
1066 return(color);
1067 }
1068
1069
g_cursor_color(void)1070 static Xen g_cursor_color(void)
1071 {
1072 #define H_cursor_color "(" S_cursor_color "): cursor color"
1073 return(Xen_wrap_pixel(ss->cursor_color));
1074 }
1075
1076
1077 #if USE_MOTIF
highlight_recolor_everything(widget_t w,color_t color)1078 static void highlight_recolor_everything(widget_t w, color_t color)
1079 {
1080 Pixel curcol;
1081 if (XtIsWidget(w))
1082 {
1083 XtVaGetValues(w, XmNbackground, &curcol, NULL);
1084 if (curcol == color)
1085 XmChangeColor(w, ss->highlight_color);
1086 }
1087 }
1088 #endif
1089
1090
set_highlight_color(color_t color)1091 void set_highlight_color(color_t color)
1092 {
1093 #if USE_MOTIF
1094 color_t old_color;
1095 old_color = ss->highlight_color;
1096 #endif
1097 ss->highlight_color = color;
1098 #if HAVE_SCHEME
1099 s7_symbol_set_value(s7, ss->highlight_color_symbol, Xen_wrap_pixel(color));
1100 #endif
1101 #if USE_MOTIF
1102 map_over_children_with_color(main_shell(ss), highlight_recolor_everything, old_color);
1103 #endif
1104 }
1105
1106
g_set_highlight_color(Xen color)1107 static Xen g_set_highlight_color(Xen color)
1108 {
1109 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_highlight_color, "a color");
1110 set_highlight_color(Xen_unwrap_pixel(color));
1111 return(color);
1112 }
1113
1114
g_highlight_color(void)1115 static Xen g_highlight_color(void)
1116 {
1117 #define H_highlight_color "(" S_highlight_color "): color of highlighted text or buttons"
1118 return(Xen_wrap_pixel(ss->highlight_color));
1119 }
1120
1121
g_set_mark_color(Xen color)1122 static Xen g_set_mark_color(Xen color)
1123 {
1124 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_mark_color, "a color");
1125 color_marks(Xen_unwrap_pixel(color));
1126 for_each_chan(update_graph);
1127 return(color);
1128 }
1129
1130
g_mark_color(void)1131 static Xen g_mark_color(void)
1132 {
1133 #define H_mark_color "(" S_mark_color "): mark color"
1134 return(Xen_wrap_pixel(ss->mark_color));
1135 }
1136
1137
set_zoom_color(color_t color)1138 void set_zoom_color(color_t color)
1139 {
1140 ss->zoom_color = color;
1141 #if HAVE_SCHEME
1142 s7_symbol_set_value(s7, ss->zoom_color_symbol, Xen_wrap_pixel(color));
1143 #endif
1144 color_chan_components(ss->zoom_color, COLOR_ZOOM);
1145 }
1146
1147
g_set_zoom_color(Xen color)1148 static Xen g_set_zoom_color(Xen color)
1149 {
1150 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_zoom_color, "a color");
1151 set_zoom_color(Xen_unwrap_pixel(color));
1152 return(color);
1153 }
1154
1155
g_zoom_color(void)1156 static Xen g_zoom_color(void)
1157 {
1158 #define H_zoom_color "(" S_zoom_color "): color of zoom sliders"
1159 return(Xen_wrap_pixel(ss->zoom_color));
1160 }
1161
1162
set_position_color(color_t color)1163 void set_position_color(color_t color)
1164 {
1165 ss->position_color = color;
1166 #if HAVE_SCHEME
1167 s7_symbol_set_value(s7, ss->position_color_symbol, Xen_wrap_pixel(color));
1168 #endif
1169 color_chan_components(ss->position_color, COLOR_POSITION);
1170 }
1171
1172
g_set_position_color(Xen color)1173 static Xen g_set_position_color(Xen color)
1174 {
1175 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_position_color, "a color");
1176 set_position_color(Xen_unwrap_pixel(color));
1177 return(color);
1178 }
1179
1180
g_position_color(void)1181 static Xen g_position_color(void)
1182 {
1183 #define H_position_color "(" S_position_color "): color of position sliders"
1184 return(Xen_wrap_pixel(ss->position_color));
1185 }
1186
1187
g_set_listener_color(Xen color)1188 static Xen g_set_listener_color(Xen color)
1189 {
1190 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_listener_color, "a color");
1191 color_listener(Xen_unwrap_pixel(color));
1192 return(color);
1193 }
1194
1195
g_listener_color(void)1196 static Xen g_listener_color(void)
1197 {
1198 #define H_listener_color "(" S_listener_color "): background color of the lisp listener"
1199 return(Xen_wrap_pixel(ss->listener_color));
1200 }
1201
1202
g_set_listener_text_color(Xen color)1203 static Xen g_set_listener_text_color(Xen color)
1204 {
1205 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_listener_text_color, "a color");
1206 color_listener_text(Xen_unwrap_pixel(color));
1207 return(color);
1208 }
1209
1210
g_listener_text_color(void)1211 static Xen g_listener_text_color(void)
1212 {
1213 #define H_listener_text_color "(" S_listener_text_color "): text color in the lisp listener"
1214 return(Xen_wrap_pixel(ss->listener_text_color));
1215 }
1216
1217
g_set_enved_waveform_color(Xen color)1218 static Xen g_set_enved_waveform_color(Xen color)
1219 {
1220 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_enved_waveform_color, "a color");
1221 ss->enved_waveform_color = Xen_unwrap_pixel(color);
1222 #if HAVE_SCHEME
1223 s7_symbol_set_value(s7, ss->enved_waveform_color_symbol, color);
1224 #endif
1225 color_enved_waveform(Xen_unwrap_pixel(color));
1226 return(color);
1227 }
1228
1229
g_enved_waveform_color(void)1230 static Xen g_enved_waveform_color(void)
1231 {
1232 #define H_enved_waveform_color "(" S_enved_waveform_color "): color of the envelope editor wave display"
1233 return(Xen_wrap_pixel(ss->enved_waveform_color));
1234 }
1235
1236
g_set_filter_control_waveform_color(Xen color)1237 static Xen g_set_filter_control_waveform_color(Xen color)
1238 {
1239 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_filter_control_waveform_color, "a color");
1240 ss->filter_control_waveform_color = Xen_unwrap_pixel(color);
1241 #if HAVE_SCHEME
1242 s7_symbol_set_value(s7, ss->filter_control_waveform_color_symbol, color);
1243 #endif
1244 color_filter_waveform(Xen_unwrap_pixel(color));
1245 return(color);
1246 }
1247
1248
g_filter_control_waveform_color(void)1249 static Xen g_filter_control_waveform_color(void)
1250 {
1251 #define H_filter_control_waveform_color "(" S_filter_control_waveform_color "): color of the filter waveform"
1252 return(Xen_wrap_pixel(ss->filter_control_waveform_color));
1253 }
1254
1255
g_set_selection_color(Xen color)1256 static Xen g_set_selection_color(Xen color)
1257 {
1258 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_selection_color, "a color");
1259 color_selection(Xen_unwrap_pixel(color));
1260 for_each_chan(update_graph);
1261 return(color);
1262 }
1263
1264
g_selection_color(void)1265 static Xen g_selection_color(void)
1266 {
1267 #define H_selection_color "(" S_selection_color "): selection color"
1268 return(Xen_wrap_pixel(ss->selection_color));
1269 }
1270
1271
g_set_text_focus_color(Xen color)1272 static Xen g_set_text_focus_color(Xen color)
1273 {
1274 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_text_focus_color, "a color");
1275 ss->text_focus_color = Xen_unwrap_pixel(color);
1276 #if HAVE_SCHEME
1277 s7_symbol_set_value(s7, ss->text_focus_color_symbol, color);
1278 #endif
1279 return(color);
1280 }
1281
1282
g_text_focus_color(void)1283 static Xen g_text_focus_color(void)
1284 {
1285 #define H_text_focus_color "(" S_text_focus_color "): color used to show a text field has focus"
1286 return(Xen_wrap_pixel(ss->text_focus_color));
1287 }
1288
1289
g_set_sash_color(Xen color)1290 static Xen g_set_sash_color(Xen color)
1291 {
1292 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_sash_color, "a color");
1293 ss->sash_color = Xen_unwrap_pixel(color);
1294 #if HAVE_SCHEME
1295 s7_symbol_set_value(s7, ss->sash_color_symbol, color);
1296 #endif
1297 return(color);
1298 }
1299
1300
g_sash_color(void)1301 static Xen g_sash_color(void)
1302 {
1303 #define H_sash_color "(" S_sash_color "): color used to draw paned window sashes"
1304 return(Xen_wrap_pixel(ss->sash_color));
1305 }
1306
1307
g_data_color(void)1308 static Xen g_data_color(void)
1309 {
1310 #define H_data_color "(" S_data_color "): color used to draw unselected data"
1311 return(Xen_wrap_pixel(ss->data_color));
1312 }
1313
1314
set_data_color(color_t color)1315 void set_data_color(color_t color)
1316 {
1317 ss->data_color = color;
1318 #if HAVE_SCHEME
1319 s7_symbol_set_value(s7, ss->data_color_symbol, Xen_wrap_pixel(color));
1320 #endif
1321 color_data(color);
1322 ss->grid_color = get_in_between_color(ss->data_color, ss->graph_color);
1323 for_each_chan(update_graph);
1324 }
1325
1326
g_set_data_color(Xen color)1327 static Xen g_set_data_color(Xen color)
1328 {
1329 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_data_color, "a color");
1330 set_data_color(Xen_unwrap_pixel(color));
1331 return(color);
1332 }
1333
1334
set_selected_data_color(color_t color)1335 void set_selected_data_color(color_t color)
1336 {
1337 chan_info *cp;
1338 ss->selected_data_color = color;
1339 #if HAVE_SCHEME
1340 s7_symbol_set_value(s7, ss->selected_data_color_symbol, Xen_wrap_pixel(color));
1341 #endif
1342 color_selected_data(color);
1343 ss->selected_grid_color = get_in_between_color(ss->selected_data_color, ss->selected_graph_color);
1344 cp = selected_channel();
1345 if (cp) update_graph(cp);
1346 }
1347
1348
g_set_selected_data_color(Xen color)1349 static Xen g_set_selected_data_color(Xen color)
1350 {
1351 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_selected_data_color, "a color");
1352 set_selected_data_color(Xen_unwrap_pixel(color));
1353 return(color);
1354 }
1355
1356
g_selected_data_color(void)1357 static Xen g_selected_data_color(void)
1358 {
1359 #define H_selected_data_color "(" S_selected_data_color "): color used for selected data"
1360 return(Xen_wrap_pixel(ss->selected_data_color));
1361 }
1362
1363
set_graph_color(color_t color)1364 void set_graph_color(color_t color)
1365 {
1366 color_graph(color);
1367 ss->graph_color = color;
1368 #if HAVE_SCHEME
1369 s7_symbol_set_value(s7, ss->graph_color_symbol, Xen_wrap_pixel(color));
1370 #endif
1371 color_unselected_graphs(color);
1372 ss->grid_color = get_in_between_color(ss->data_color, ss->graph_color);
1373 }
1374
1375
g_set_graph_color(Xen color)1376 static Xen g_set_graph_color(Xen color)
1377 {
1378 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_graph_color, "a color");
1379 set_graph_color(Xen_unwrap_pixel(color));
1380 return(color);
1381 }
1382
1383
g_graph_color(void)1384 static Xen g_graph_color(void)
1385 {
1386 #define H_graph_color "(" S_graph_color "): background color used for unselected data"
1387 return(Xen_wrap_pixel(ss->graph_color));
1388 }
1389
1390
set_selected_graph_color(color_t color)1391 void set_selected_graph_color(color_t color)
1392 {
1393 chan_info *cp;
1394 ss->selected_graph_color = color;
1395 #if HAVE_SCHEME
1396 s7_symbol_set_value(s7, ss->selected_graph_color_symbol, Xen_wrap_pixel(color));
1397 #endif
1398 color_selected_graph(color);
1399 ss->selected_grid_color = get_in_between_color(ss->selected_data_color, ss->selected_graph_color);
1400 cp = selected_channel();
1401 if (cp)
1402 {
1403 #if USE_MOTIF
1404 XtVaSetValues(channel_graph(cp), XmNbackground, ss->selected_graph_color, NULL);
1405 #endif
1406 }
1407 }
1408
1409
g_set_selected_graph_color(Xen color)1410 static Xen g_set_selected_graph_color(Xen color)
1411 {
1412 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_selected_graph_color, "a color");
1413 set_selected_graph_color(Xen_unwrap_pixel(color));
1414 return(color);
1415 }
1416
1417
g_selected_graph_color(void)1418 static Xen g_selected_graph_color(void)
1419 {
1420 #define H_selected_graph_color "(" S_selected_graph_color "): background color of selected data"
1421 return(Xen_wrap_pixel(ss->selected_graph_color));
1422 }
1423
1424
g_set_axis_color(Xen color)1425 static Xen g_set_axis_color(Xen color)
1426 {
1427 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_axis_color, "a color");
1428 ss->axis_color = Xen_unwrap_pixel(color);
1429 ss->axis_color_set = true;
1430 #if HAVE_SCHEME
1431 s7_symbol_set_value(s7, ss->axis_color_symbol, color);
1432 #endif
1433 for_each_chan(update_graph);
1434 return(color);
1435 }
1436
1437
g_axis_color(void)1438 static Xen g_axis_color(void)
1439 {
1440 #define H_axis_color "(" S_axis_color "): color of axis (defaults to current data color)"
1441 return(Xen_wrap_pixel(ss->axis_color));
1442 }
1443
1444
g_basic_color(void)1445 static Xen g_basic_color(void)
1446 {
1447 #define H_basic_color "(" S_basic_color "): Snd's basic color"
1448 return(Xen_wrap_pixel(ss->basic_color));
1449 }
1450
1451 #if USE_MOTIF
recolor_everything(widget_t w,color_t color)1452 static void recolor_everything(widget_t w, color_t color)
1453 {
1454 Pixel curcol;
1455 if (XtIsWidget(w))
1456 {
1457 XtVaGetValues(w, XmNbackground, &curcol, NULL);
1458 if (curcol == color)
1459 XmChangeColor(w, ss->basic_color);
1460 }
1461 }
1462
g_color_to_list(Xen obj)1463 static Xen g_color_to_list(Xen obj)
1464 {
1465 #define H_color_to_list "(" S_color_to_list " obj): 'obj' rgb values as a list of floats"
1466 Colormap cmap;
1467 XColor tmp_color;
1468 Display *dpy;
1469
1470 Xen_check_type(Xen_is_pixel(obj), obj, 1, S_color_to_list, "a color");
1471
1472 dpy = XtDisplay(main_shell(ss));
1473 cmap = DefaultColormap(dpy, DefaultScreen(dpy));
1474 tmp_color.flags = DoRed | DoGreen | DoBlue;
1475 tmp_color.pixel = Xen_unwrap_pixel(obj);
1476 XQueryColor(dpy, cmap, &tmp_color);
1477 return(Xen_list_3(C_double_to_Xen_real(rgb_to_float(tmp_color.red)),
1478 C_double_to_Xen_real(rgb_to_float(tmp_color.green)),
1479 C_double_to_Xen_real(rgb_to_float(tmp_color.blue))));
1480 }
1481
1482
g_make_color(Xen r,Xen g,Xen b,Xen alpha)1483 static Xen g_make_color(Xen r, Xen g, Xen b, Xen alpha)
1484 {
1485 /* alpha is ignored in Motif */
1486 #define H_make_color "(" S_make_color " r g b alpha): return a color object with the indicated rgb values"
1487 Colormap cmap;
1488 XColor tmp_color;
1489 Display *dpy;
1490 mus_float_t rf, gf, bf;
1491
1492 Xen_check_type(Xen_is_number(r), r, 1, S_make_color, "a number");
1493 /* someday accept a list as r */
1494 Xen_check_type(Xen_is_number(g), g, 2, S_make_color, "a number");
1495 Xen_check_type(Xen_is_number(b), b, 3, S_make_color, "a number");
1496
1497 rf = check_color_range(S_make_color, r);
1498 gf = check_color_range(S_make_color, g);
1499 bf = check_color_range(S_make_color, b);
1500 dpy = XtDisplay(main_shell(ss));
1501 cmap = DefaultColormap(dpy, DefaultScreen(dpy));
1502 tmp_color.flags = DoRed | DoGreen | DoBlue;
1503 tmp_color.red = float_to_rgb(rf);
1504 tmp_color.green = float_to_rgb(gf);
1505 tmp_color.blue = float_to_rgb(bf);
1506
1507 if ((XAllocColor(dpy, cmap, &tmp_color)) == 0)
1508 Xen_error(Xen_make_error_type("no-such-color"),
1509 Xen_list_4(C_string_to_Xen_string(S_make_color ": can't allocate this color! (~A ~A ~A)"),
1510 r, g, b));
1511
1512 return(Xen_wrap_pixel(tmp_color.pixel));
1513 }
1514 #endif
1515
1516
set_basic_color(color_t color)1517 void set_basic_color(color_t color)
1518 {
1519 #if USE_MOTIF
1520 color_t old_color;
1521 old_color = ss->basic_color;
1522 #endif
1523 #if HAVE_SCHEME
1524 s7_symbol_set_value(s7, ss->basic_color_symbol, Xen_wrap_pixel(color));
1525 #endif
1526 ss->basic_color = color;
1527 #if USE_MOTIF
1528 map_over_children_with_color(main_shell(ss), recolor_everything, old_color);
1529 #endif
1530
1531 #if USE_MOTIF
1532 make_sound_icons_transparent_again(old_color, ss->basic_color);
1533 make_mixer_icons_transparent_again(old_color, ss->basic_color);
1534 #endif
1535 }
1536
1537
g_set_basic_color(Xen color)1538 static Xen g_set_basic_color(Xen color)
1539 {
1540 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_basic_color, "a color");
1541 set_basic_color(Xen_unwrap_pixel(color));
1542 return(color);
1543 }
1544
1545
g_mix_color(Xen mix_id)1546 static Xen g_mix_color(Xen mix_id)
1547 {
1548 #define H_mix_color "(" S_mix_color " :optional mix-id): color of all mix tags (if mix-id is omitted), or of mix-id's tag"
1549 if (xen_is_mix(mix_id))
1550 return(Xen_wrap_pixel(mix_color_from_id(Xen_mix_to_C_int(mix_id))));
1551 return(Xen_wrap_pixel(ss->mix_color));
1552 }
1553
1554
g_set_mix_color(Xen color,Xen mix_id)1555 static Xen g_set_mix_color(Xen color, Xen mix_id)
1556 {
1557 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_mix_color, "a color");
1558 Xen_check_type(xen_is_mix(mix_id) || !Xen_is_bound(mix_id), mix_id, 2, S_set S_mix_color, "a mix");
1559 if (xen_is_mix(mix_id))
1560 mix_set_color_from_id(Xen_mix_to_C_int(mix_id), Xen_unwrap_pixel(color));
1561 else color_mixes(Xen_unwrap_pixel(color));
1562 return(color);
1563 }
1564
with_two_setter_args(g_set_mix_color_reversed,g_set_mix_color)1565 with_two_setter_args(g_set_mix_color_reversed, g_set_mix_color)
1566
1567
1568 bool foreground_color_ok(Xen color, graphics_context *ax)
1569 {
1570 if (Xen_is_pixel(color))
1571 {
1572 set_foreground_color(ax, (color_t)Xen_unwrap_pixel(color));
1573 return(true);
1574 }
1575 return(false);
1576 }
1577
1578
1579
g_combined_data_color(Xen snd,Xen chn)1580 static Xen g_combined_data_color(Xen snd, Xen chn)
1581 {
1582 #define H_combined_data_color "(" S_combined_data_color " snd chn): color of this channel's data if graphed with channels-combined"
1583 chan_info *cp;
1584
1585 Snd_assert_channel(S_combined_data_color, snd, chn, 1);
1586 cp = get_cp(snd, chn, S_combined_data_color);
1587 if (!cp) return(Xen_false);
1588
1589 return(Xen_wrap_pixel(cp->combined_data_color));
1590 }
1591
1592
g_set_combined_data_color(Xen color,Xen snd,Xen chn)1593 static Xen g_set_combined_data_color(Xen color, Xen snd, Xen chn)
1594 {
1595 chan_info *cp;
1596
1597 Xen_check_type(Xen_is_pixel(color), color, 1, S_set S_combined_data_color, "a color");
1598 Snd_assert_channel(S_combined_data_color, snd, chn, 1);
1599 cp = get_cp(snd, chn, S_combined_data_color);
1600 if (!cp) return(Xen_false);
1601
1602 cp->combined_data_color = Xen_unwrap_pixel(color);
1603 update_graph(cp);
1604 return(color);
1605 }
1606
with_three_setter_args(g_set_combined_data_color_reversed,g_set_combined_data_color)1607 with_three_setter_args(g_set_combined_data_color_reversed, g_set_combined_data_color)
1608
1609
1610
1611 Xen_wrap_8_optional_args(g_draw_line_w, g_draw_line)
1612 Xen_wrap_7_optional_args(g_draw_dot_w, g_draw_dot)
1613 Xen_wrap_5_optional_args(g_draw_lines_w, g_draw_lines)
1614 Xen_wrap_6_optional_args(g_draw_dots_w, g_draw_dots)
1615 Xen_wrap_7_optional_args(g_draw_string_w, g_draw_string)
1616 Xen_wrap_9_optional_args(g_fill_rectangle_w, g_fill_rectangle)
1617 Xen_wrap_5_optional_args(g_fill_polygon_w, g_fill_polygon)
1618 Xen_wrap_3_optional_args(g_foreground_color_w, g_foreground_color)
1619 Xen_wrap_3_optional_args(g_current_font_w, g_current_font)
1620 Xen_wrap_no_args(g_main_widgets_w, g_main_widgets)
1621 Xen_wrap_no_args(g_dialog_widgets_w, g_dialog_widgets)
1622 Xen_wrap_1_arg(g_widget_size_w, g_widget_size)
1623 Xen_wrap_2_args(g_set_widget_size_w, g_set_widget_size)
1624 Xen_wrap_1_arg(g_widget_position_w, g_widget_position)
1625 Xen_wrap_2_args(g_set_widget_position_w, g_set_widget_position)
1626 Xen_wrap_1_arg(g_widget_text_w, g_widget_text)
1627 Xen_wrap_2_args(g_set_widget_text_w, g_set_widget_text)
1628 Xen_wrap_1_arg(g_hide_widget_w, g_hide_widget)
1629 Xen_wrap_1_arg(g_show_widget_w, g_show_widget)
1630 Xen_wrap_1_arg(g_focus_widget_w, g_focus_widget)
1631 Xen_wrap_5_optional_args(g_make_graph_data_w, g_make_graph_data)
1632 Xen_wrap_8_optional_args(g_graph_data_w, g_graph_data)
1633 Xen_wrap_any_args(g_make_bezier_w, g_make_bezier)
1634 Xen_wrap_no_args(g_snd_gcs_w, g_snd_gcs)
1635 Xen_wrap_1_arg(g_snd_color_w, g_snd_color)
1636 Xen_wrap_1_arg(g_snd_font_w, g_snd_font)
1637
1638 Xen_wrap_no_args(g_selection_color_w, g_selection_color)
1639 Xen_wrap_1_arg(g_set_selection_color_w, g_set_selection_color)
1640 Xen_wrap_no_args(g_zoom_color_w, g_zoom_color)
1641 Xen_wrap_1_arg(g_set_zoom_color_w, g_set_zoom_color)
1642 Xen_wrap_no_args(g_position_color_w, g_position_color)
1643 Xen_wrap_1_arg(g_set_position_color_w, g_set_position_color)
1644 Xen_wrap_no_args(g_mark_color_w, g_mark_color)
1645 Xen_wrap_1_arg(g_set_mark_color_w, g_set_mark_color)
1646 Xen_wrap_no_args(g_listener_color_w, g_listener_color)
1647 Xen_wrap_1_arg(g_set_listener_color_w, g_set_listener_color)
1648 Xen_wrap_no_args(g_listener_text_color_w, g_listener_text_color)
1649 Xen_wrap_1_arg(g_set_listener_text_color_w, g_set_listener_text_color)
1650 Xen_wrap_no_args(g_enved_waveform_color_w, g_enved_waveform_color)
1651 Xen_wrap_1_arg(g_set_enved_waveform_color_w, g_set_enved_waveform_color)
1652 Xen_wrap_no_args(g_filter_control_waveform_color_w, g_filter_control_waveform_color)
1653 Xen_wrap_1_arg(g_set_filter_control_waveform_color_w, g_set_filter_control_waveform_color)
1654 Xen_wrap_no_args(g_highlight_color_w, g_highlight_color)
1655 Xen_wrap_1_arg(g_set_highlight_color_w, g_set_highlight_color)
1656 Xen_wrap_no_args(g_cursor_color_w, g_cursor_color)
1657 Xen_wrap_1_arg(g_set_cursor_color_w, g_set_cursor_color)
1658 Xen_wrap_no_args(g_text_focus_color_w, g_text_focus_color)
1659 Xen_wrap_1_arg(g_set_text_focus_color_w, g_set_text_focus_color)
1660 Xen_wrap_no_args(g_sash_color_w, g_sash_color)
1661 Xen_wrap_1_arg(g_set_sash_color_w, g_set_sash_color)
1662 Xen_wrap_no_args(g_data_color_w, g_data_color)
1663 Xen_wrap_1_arg(g_set_data_color_w, g_set_data_color)
1664 Xen_wrap_no_args(g_graph_color_w, g_graph_color)
1665 Xen_wrap_1_arg(g_set_graph_color_w, g_set_graph_color)
1666 Xen_wrap_no_args(g_selected_graph_color_w, g_selected_graph_color)
1667 Xen_wrap_1_arg(g_set_selected_graph_color_w, g_set_selected_graph_color)
1668 Xen_wrap_no_args(g_selected_data_color_w, g_selected_data_color)
1669 Xen_wrap_1_arg(g_set_selected_data_color_w, g_set_selected_data_color)
1670 Xen_wrap_no_args(g_axis_color_w, g_axis_color)
1671 Xen_wrap_1_arg(g_set_axis_color_w, g_set_axis_color)
1672 Xen_wrap_no_args(g_basic_color_w, g_basic_color)
1673 Xen_wrap_1_arg(g_set_basic_color_w, g_set_basic_color)
1674 Xen_wrap_1_arg(g_is_color_w, g_is_color)
1675 Xen_wrap_4_optional_args(g_make_color_w, g_make_color)
1676 Xen_wrap_1_arg(g_color_to_list_w, g_color_to_list)
1677 Xen_wrap_1_optional_arg(g_mix_color_w, g_mix_color)
1678 Xen_wrap_2_args(g_combined_data_color_w, g_combined_data_color)
1679
1680 #if HAVE_SCHEME
1681 #define g_set_current_font_w g_set_current_font_reversed
1682 #define g_set_foreground_color_w g_set_foreground_color_reversed
1683 #define g_set_mix_color_w g_set_mix_color_reversed
1684 #define g_set_combined_data_color_w g_set_combined_data_color_reversed
1685
1686 static s7_pointer acc_data_color(s7_scheme *sc, s7_pointer args) {return(g_set_data_color(s7_cadr(args)));}
acc_selected_data_color(s7_scheme * sc,s7_pointer args)1687 static s7_pointer acc_selected_data_color(s7_scheme *sc, s7_pointer args) {return(g_set_selected_data_color(s7_cadr(args)));}
acc_mark_color(s7_scheme * sc,s7_pointer args)1688 static s7_pointer acc_mark_color(s7_scheme *sc, s7_pointer args) {return(g_set_mark_color(s7_cadr(args)));}
acc_graph_color(s7_scheme * sc,s7_pointer args)1689 static s7_pointer acc_graph_color(s7_scheme *sc, s7_pointer args) {return(g_set_graph_color(s7_cadr(args)));}
acc_selected_graph_color(s7_scheme * sc,s7_pointer args)1690 static s7_pointer acc_selected_graph_color(s7_scheme *sc, s7_pointer args) {return(g_set_selected_graph_color(s7_cadr(args)));}
acc_listener_color(s7_scheme * sc,s7_pointer args)1691 static s7_pointer acc_listener_color(s7_scheme *sc, s7_pointer args) {return(g_set_listener_color(s7_cadr(args)));}
acc_listener_text_color(s7_scheme * sc,s7_pointer args)1692 static s7_pointer acc_listener_text_color(s7_scheme *sc, s7_pointer args) {return(g_set_listener_text_color(s7_cadr(args)));}
acc_basic_color(s7_scheme * sc,s7_pointer args)1693 static s7_pointer acc_basic_color(s7_scheme *sc, s7_pointer args) {return(g_set_basic_color(s7_cadr(args)));}
acc_zoom_color(s7_scheme * sc,s7_pointer args)1694 static s7_pointer acc_zoom_color(s7_scheme *sc, s7_pointer args) {return(g_set_zoom_color(s7_cadr(args)));}
acc_selection_color(s7_scheme * sc,s7_pointer args)1695 static s7_pointer acc_selection_color(s7_scheme *sc, s7_pointer args) {return(g_set_selection_color(s7_cadr(args)));}
acc_position_color(s7_scheme * sc,s7_pointer args)1696 static s7_pointer acc_position_color(s7_scheme *sc, s7_pointer args) {return(g_set_position_color(s7_cadr(args)));}
acc_highlight_color(s7_scheme * sc,s7_pointer args)1697 static s7_pointer acc_highlight_color(s7_scheme *sc, s7_pointer args) {return(g_set_highlight_color(s7_cadr(args)));}
acc_enved_waveform_color(s7_scheme * sc,s7_pointer args)1698 static s7_pointer acc_enved_waveform_color(s7_scheme *sc, s7_pointer args) {return(g_set_enved_waveform_color(s7_cadr(args)));}
acc_cursor_color(s7_scheme * sc,s7_pointer args)1699 static s7_pointer acc_cursor_color(s7_scheme *sc, s7_pointer args) {return(g_set_cursor_color(s7_cadr(args)));}
acc_filter_control_waveform_color(s7_scheme * sc,s7_pointer args)1700 static s7_pointer acc_filter_control_waveform_color(s7_scheme *sc, s7_pointer args) {return(g_set_filter_control_waveform_color(s7_cadr(args)));}
acc_sash_color(s7_scheme * sc,s7_pointer args)1701 static s7_pointer acc_sash_color(s7_scheme *sc, s7_pointer args) {return(g_set_sash_color(s7_cadr(args)));}
acc_axis_color(s7_scheme * sc,s7_pointer args)1702 static s7_pointer acc_axis_color(s7_scheme *sc, s7_pointer args) {return(g_set_axis_color(s7_cadr(args)));}
acc_mix_color(s7_scheme * sc,s7_pointer args)1703 static s7_pointer acc_mix_color(s7_scheme *sc, s7_pointer args) {return(g_set_mix_color(s7_cadr(args), s7_undefined(s7)));}
acc_text_focus_color(s7_scheme * sc,s7_pointer args)1704 static s7_pointer acc_text_focus_color(s7_scheme *sc, s7_pointer args) {return(g_set_text_focus_color(s7_cadr(args)));}
1705
1706 #else
1707 Xen_wrap_4_optional_args(g_set_current_font_w, g_set_current_font)
1708 Xen_wrap_4_optional_args(g_set_foreground_color_w, g_set_foreground_color)
1709 Xen_wrap_2_optional_args(g_set_mix_color_w, g_set_mix_color)
1710 Xen_wrap_3_args(g_set_combined_data_color_w, g_set_combined_data_color)
1711 #endif
1712
g_init_draw(void)1713 void g_init_draw(void)
1714 {
1715 #if HAVE_SCHEME
1716 s7_pointer i, b, p, t, r, mx, s, v, pcl_p, pcl_t, bi;
1717 i = s7_make_symbol(s7, "integer?");
1718 b = s7_make_symbol(s7, "boolean?");
1719 p = s7_make_symbol(s7, "pair?");
1720 r = s7_make_symbol(s7, "real?");
1721 s = s7_make_symbol(s7, "string?");
1722 v = s7_make_symbol(s7, "vector?");
1723 mx = s7_make_symbol(s7, "mix?");
1724 t = s7_t(s7);
1725 pcl_p = s7_make_circular_signature(s7, 0, 1, p);
1726 pcl_t = s7_make_circular_signature(s7, 0, 1, t);
1727 bi = s7_make_signature(s7, 2, i, b);
1728 #endif
1729
1730 dialog_widgets = Xen_undefined;
1731
1732 Xen_define_constant(S_copy_context, CHAN_GC, "graphics context to draw a line");
1733 Xen_define_constant(S_cursor_context, CHAN_CGC, "graphics context for the cursor");
1734 Xen_define_constant(S_selection_context, CHAN_SELGC, "graphics context to draw in the selection color");
1735 Xen_define_constant(S_mark_context, CHAN_MGC, "graphics context for a mark");
1736
1737 Xen_define_typed_procedure(S_draw_line, g_draw_line_w, 4, 4, 0, H_draw_line, s7_make_signature(s7, 9, b, i, i, i, i, t, t, i, p));
1738 Xen_define_typed_procedure(S_draw_dot, g_draw_dot_w, 2, 5, 0, H_draw_dot, s7_make_signature(s7, 8, b, i, i, i, t, t, i, p));
1739 Xen_define_typed_procedure(S_draw_lines, g_draw_lines_w, 1, 4, 0, H_draw_lines, s7_make_signature(s7, 6, v, v, t, t, i, p));
1740 Xen_define_typed_procedure(S_draw_dots, g_draw_dots_w, 1, 5, 0, H_draw_dots, s7_make_signature(s7, 7, v, v, i, t, t, i, p));
1741 Xen_define_typed_procedure(S_draw_string, g_draw_string_w, 3, 4, 0, H_draw_string, s7_make_signature(s7, 8, s, s, i, i, t, t, i, p));
1742 Xen_define_typed_procedure(S_fill_rectangle, g_fill_rectangle_w, 4, 5, 0, H_fill_rectangle, s7_make_signature(s7, 10, b, i, i, i, i, t, t, i, b, p));
1743 Xen_define_typed_procedure(S_fill_polygon, g_fill_polygon_w, 1, 4, 0, H_fill_polygon, s7_make_signature(s7, 6, v, v, t, t, i, p));
1744 Xen_define_typed_procedure(S_make_graph_data, g_make_graph_data_w, 0, 5, 0, H_make_graph_data, s7_make_signature(s7, 6, t, t, t, t, i, i));
1745 Xen_define_typed_procedure(S_graph_data, g_graph_data_w, 1, 7, 0, H_graph_data, s7_make_signature(s7, 9, t, t, t, t, t, bi, bi, bi, p));
1746
1747 Xen_define_typed_procedure(S_main_widgets, g_main_widgets_w, 0, 0, 0, H_main_widgets, pcl_p);
1748 Xen_define_typed_procedure(S_dialog_widgets, g_dialog_widgets_w, 0, 0, 0, H_dialog_widgets, pcl_p);
1749 Xen_define_typed_procedure(S_hide_widget, g_hide_widget_w, 1, 0, 0, H_hide_widget, pcl_t);
1750 Xen_define_typed_procedure(S_show_widget, g_show_widget_w, 1, 0, 0, H_show_widget, pcl_t);
1751 Xen_define_typed_procedure(S_focus_widget, g_focus_widget_w, 1, 0, 0, H_focus_widget, pcl_t);
1752
1753 Xen_define_typed_dilambda(S_foreground_color, g_foreground_color_w, H_foreground_color,
1754 S_set S_foreground_color, g_set_foreground_color_w, 0, 3, 1, 3,
1755 s7_make_signature(s7, 4, p, t, t, i), s7_make_signature(s7, 5, p, t, t, i, p));
1756 Xen_define_typed_dilambda(S_current_font, g_current_font_w, H_current_font,
1757 S_set S_current_font, g_set_current_font_w, 0, 3, 1, 3,
1758 s7_make_signature(s7, 4, p, t, t, i), s7_make_signature(s7, 5, p, t, t, i, p));
1759 Xen_define_typed_dilambda(S_widget_size, g_widget_size_w, H_widget_size,
1760 S_set S_widget_size, g_set_widget_size_w, 1, 0, 2, 0,
1761 s7_make_signature(s7, 2, p, t), s7_make_signature(s7, 3, p, t, p));
1762 Xen_define_typed_dilambda(S_widget_position, g_widget_position_w, H_widget_position,
1763 S_set S_widget_position, g_set_widget_position_w, 1, 0, 2, 0,
1764 s7_make_signature(s7, 2, p, t), s7_make_signature(s7, 3, p, t, p));
1765 Xen_define_typed_dilambda(S_widget_text, g_widget_text_w, H_widget_text,
1766 S_set S_widget_text, g_set_widget_text_w, 1, 0, 2, 0,
1767 s7_make_signature(s7, 2, s, t), s7_make_signature(s7, 3, s, t, s));
1768 Xen_define_typed_dilambda(S_mix_color, g_mix_color_w, H_mix_color,
1769 S_set S_mix_color, g_set_mix_color_w, 0, 1, 1, 1,
1770 s7_make_signature(s7, 2, p, mx), s7_make_signature(s7, 3, p, mx, p));
1771 Xen_define_typed_dilambda(S_combined_data_color, g_combined_data_color_w, H_combined_data_color,
1772 S_set S_combined_data_color, g_set_combined_data_color_w, 2, 0, 3, 0,
1773 s7_make_signature(s7, 3, p, t, t), s7_make_signature(s7, 4, p, t, t, p));
1774
1775 Xen_define_typed_dilambda(S_selection_color, g_selection_color_w, H_selection_color,
1776 S_set S_selection_color, g_set_selection_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1777 Xen_define_typed_dilambda(S_zoom_color, g_zoom_color_w, H_zoom_color,
1778 S_set S_zoom_color, g_set_zoom_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1779 Xen_define_typed_dilambda(S_position_color, g_position_color_w, H_position_color,
1780 S_set S_position_color, g_set_position_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1781 Xen_define_typed_dilambda(S_mark_color, g_mark_color_w, H_mark_color,
1782 S_set S_mark_color, g_set_mark_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1783 Xen_define_typed_dilambda(S_listener_color, g_listener_color_w, H_listener_color,
1784 S_set S_listener_color, g_set_listener_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1785 Xen_define_typed_dilambda(S_listener_text_color, g_listener_text_color_w, H_listener_text_color,
1786 S_set S_listener_text_color, g_set_listener_text_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1787 Xen_define_typed_dilambda(S_enved_waveform_color, g_enved_waveform_color_w, H_enved_waveform_color,
1788 S_set S_enved_waveform_color, g_set_enved_waveform_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1789 Xen_define_typed_dilambda(S_filter_control_waveform_color, g_filter_control_waveform_color_w, H_filter_control_waveform_color,
1790 S_set S_filter_control_waveform_color, g_set_filter_control_waveform_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1791 Xen_define_typed_dilambda(S_highlight_color, g_highlight_color_w, H_highlight_color,
1792 S_set S_highlight_color, g_set_highlight_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1793 Xen_define_typed_dilambda(S_cursor_color, g_cursor_color_w, H_cursor_color,
1794 S_set S_cursor_color, g_set_cursor_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1795 Xen_define_typed_dilambda(S_text_focus_color, g_text_focus_color_w, H_text_focus_color,
1796 S_set S_text_focus_color, g_set_text_focus_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1797 Xen_define_typed_dilambda(S_sash_color, g_sash_color_w, H_sash_color,
1798 S_set S_sash_color, g_set_sash_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1799 Xen_define_typed_dilambda(S_data_color, g_data_color_w, H_data_color,
1800 S_set S_data_color, g_set_data_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1801 Xen_define_typed_dilambda(S_graph_color, g_graph_color_w, H_graph_color,
1802 S_set S_graph_color, g_set_graph_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1803 Xen_define_typed_dilambda(S_selected_graph_color, g_selected_graph_color_w, H_selected_graph_color,
1804 S_set S_selected_graph_color, g_set_selected_graph_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1805 Xen_define_typed_dilambda(S_selected_data_color, g_selected_data_color_w, H_selected_data_color,
1806 S_set S_selected_data_color, g_set_selected_data_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1807 Xen_define_typed_dilambda(S_axis_color, g_axis_color_w, H_axis_color,
1808 S_set S_axis_color, g_set_axis_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1809 Xen_define_typed_dilambda(S_basic_color, g_basic_color_w, H_basic_color,
1810 S_set S_basic_color, g_set_basic_color_w, 0, 0, 1, 0, pcl_p, pcl_p);
1811
1812 Xen_define_typed_procedure(S_is_color, g_is_color_w, 1, 0, 0, H_is_color, s7_make_signature(s7, 2, b, p));
1813 Xen_define_typed_procedure(S_make_color, g_make_color_w, 3, 1, 0, H_make_color, s7_make_circular_signature(s7, 1, 2, p, r));
1814 Xen_define_typed_procedure(S_color_to_list, g_color_to_list_w, 1, 0, 0, H_color_to_list, s7_make_signature(s7, 2, p, p));
1815
1816 Xen_define_typed_procedure(S_make_bezier, g_make_bezier_w, 0, 0, 1, H_make_bezier, s7_make_circular_signature(s7, 1, 2, v, r));
1817 Xen_define_typed_procedure(S_snd_gcs, g_snd_gcs_w, 0, 0, 0, H_snd_gcs, s7_make_signature(s7, 1, p));
1818 Xen_define_typed_procedure(S_snd_color, g_snd_color_w, 1, 0, 0, H_snd_color, s7_make_signature(s7, 2, p, i));
1819 Xen_define_typed_procedure(S_snd_font, g_snd_font_w, 1, 0, 0, H_snd_font, s7_make_signature(s7, 2, p, i));
1820
1821 #define H_new_widget_hook S_new_widget_hook " (widget): called each time a dialog or \
1822 a new set of channel or sound widgets is created."
1823
1824 new_widget_hook = Xen_define_hook(S_new_widget_hook, "(make-hook 'widget)", 1, H_new_widget_hook);
1825
1826 #if HAVE_SCHEME
1827 s7_set_setter(s7, ss->data_color_symbol, s7_make_function(s7, "[acc-" S_data_color "]", acc_data_color, 2, 0, false, "accessor"));
1828 s7_set_setter(s7, ss->highlight_color_symbol, s7_make_function(s7, "[acc-" S_highlight_color "]", acc_highlight_color, 2, 0, false, "accessor"));
1829 s7_set_setter(s7, ss->axis_color_symbol, s7_make_function(s7, "[acc-" S_axis_color "]", acc_axis_color, 2, 0, false, "accessor"));
1830 s7_set_setter(s7, ss->sash_color_symbol, s7_make_function(s7, "[acc-" S_sash_color "]", acc_sash_color, 2, 0, false, "accessor"));
1831 s7_set_setter(s7, ss->filter_control_waveform_color_symbol, s7_make_function(s7, "[acc-" S_filter_control_waveform_color "]", acc_filter_control_waveform_color, 2, 0, false, "accessor"));
1832 s7_set_setter(s7, ss->mix_color_symbol, s7_make_function(s7, "[acc-" S_mix_color "]", acc_mix_color, 2, 0, false, "accessor"));
1833 s7_set_setter(s7, ss->selected_data_color_symbol, s7_make_function(s7, "[acc-" S_selected_data_color "]", acc_selected_data_color, 2, 0, false, "accessor"));
1834 s7_set_setter(s7, ss->mark_color_symbol, s7_make_function(s7, "[acc-" S_mark_color "]", acc_mark_color, 2, 0, false, "accessor"));
1835 s7_set_setter(s7, ss->graph_color_symbol, s7_make_function(s7, "[acc-" S_graph_color "]", acc_graph_color, 2, 0, false, "accessor"));
1836 s7_set_setter(s7, ss->selected_graph_color_symbol, s7_make_function(s7, "[acc-" S_selected_graph_color "]", acc_selected_graph_color, 2, 0, false, "accessor"));
1837 s7_set_setter(s7, ss->listener_color_symbol, s7_make_function(s7, "[acc-" S_listener_color "]", acc_listener_color, 2, 0, false, "accessor"));
1838 s7_set_setter(s7, ss->listener_text_color_symbol, s7_make_function(s7, "[acc-" S_listener_text_color "]", acc_listener_text_color, 2, 0, false, "accessor"));
1839 s7_set_setter(s7, ss->basic_color_symbol, s7_make_function(s7, "[acc-" S_basic_color "]", acc_basic_color, 2, 0, false, "accessor"));
1840 s7_set_setter(s7, ss->selection_color_symbol, s7_make_function(s7, "[acc-" S_selection_color "]", acc_selection_color, 2, 0, false, "accessor"));
1841 s7_set_setter(s7, ss->zoom_color_symbol, s7_make_function(s7, "[acc-" S_zoom_color "]", acc_zoom_color, 2, 0, false, "accessor"));
1842 s7_set_setter(s7, ss->position_color_symbol, s7_make_function(s7, "[acc-" S_position_color "]", acc_position_color, 2, 0, false, "accessor"));
1843 s7_set_setter(s7, ss->enved_waveform_color_symbol, s7_make_function(s7, "[acc-" S_enved_waveform_color "]", acc_enved_waveform_color, 2, 0, false, "accessor"));
1844 s7_set_setter(s7, ss->cursor_color_symbol, s7_make_function(s7, "[acc-" S_cursor_color "]", acc_cursor_color, 2, 0, false, "accessor"));
1845 s7_set_setter(s7, ss->text_focus_color_symbol, s7_make_function(s7, "[acc-" S_text_focus_color "]", acc_text_focus_color, 2, 0, false, "accessor"));
1846
1847 s7_set_documentation(s7, ss->axis_color_symbol, "*axis-color*: color of axis (defaults to current data color)");
1848 s7_set_documentation(s7, ss->basic_color_symbol, "*basic-color*: Snd's basic color");
1849 s7_set_documentation(s7, ss->cursor_color_symbol, "*cursor-color*: cursor color");
1850 s7_set_documentation(s7, ss->data_color_symbol, "*data-color*: color used to draw unselected data");
1851 s7_set_documentation(s7, ss->enved_waveform_color_symbol, "*enved-waveform-color*: color of the envelope editor wave display");
1852 s7_set_documentation(s7, ss->filter_control_waveform_color_symbol, "*filter-control-waveform-color*: color of the filter waveform");
1853 s7_set_documentation(s7, ss->graph_color_symbol, "*graph-color*: background color used for unselected data");
1854 s7_set_documentation(s7, ss->highlight_color_symbol, "*highlight-color*: color of highlighted text or buttons");
1855 s7_set_documentation(s7, ss->listener_color_symbol, "*listener-color*: background color of the lisp listener");
1856 s7_set_documentation(s7, ss->listener_text_color_symbol, "*listener-text-color*: text color in the lisp listener");
1857 s7_set_documentation(s7, ss->mark_color_symbol, "*mark-color*: mark color");
1858 s7_set_documentation(s7, ss->mix_color_symbol, "*mix-color*: color of mix tags");
1859 s7_set_documentation(s7, ss->position_color_symbol, "*position-color*: color of position sliders");
1860 s7_set_documentation(s7, ss->sash_color_symbol, "*sash-color*: color used to draw paned window sashes");
1861 s7_set_documentation(s7, ss->selected_data_color_symbol, "*selected-data-color*: color used for selected data");
1862 s7_set_documentation(s7, ss->selected_graph_color_symbol, "*selected-graph-color*: background color of selected data");
1863 s7_set_documentation(s7, ss->selection_color_symbol, "*selection-color*: selection color");
1864 s7_set_documentation(s7, ss->text_focus_color_symbol, "*text-focus-color*: color used to show a text field has focus");
1865 s7_set_documentation(s7, ss->zoom_color_symbol, "*zoom-color*: color of zoom sliders");
1866 #endif
1867 }
1868
1869 #else
1870 /* no gui -- extension lang tie-ins are in snd-nogui.c */
set_grf_points(int xi,int j,int ymin,int ymax)1871 void set_grf_points(int xi, int j, int ymin, int ymax) {}
set_grf_point(int xi,int j,int yi)1872 void set_grf_point(int xi, int j, int yi) {}
draw_grf_points(int dot_size,graphics_context * ax,int j,axis_info * ap,mus_float_t y0,graph_style_t graph_style)1873 void draw_grf_points(int dot_size, graphics_context *ax, int j, axis_info *ap, mus_float_t y0, graph_style_t graph_style) {}
draw_both_grf_points(int dot_size,graphics_context * ax,int j,graph_style_t graph_style)1874 void draw_both_grf_points(int dot_size, graphics_context *ax, int j, graph_style_t graph_style) {}
draw_cursor(chan_info * cp)1875 void draw_cursor(chan_info *cp) {}
get_grf_points(void)1876 point_t *get_grf_points(void) {return(NULL);}
get_grf_points1(void)1877 point_t *get_grf_points1(void) {return(NULL);}
foreground_color_ok(Xen color,graphics_context * ax)1878 bool foreground_color_ok(Xen color, graphics_context *ax) {return(true);}
1879 #endif
1880