diff options
| -rw-r--r-- | desiredata/src/desire.c | 313 | ||||
| -rw-r--r-- | desiredata/src/desire.h | 5 |
2 files changed, 159 insertions, 159 deletions
diff --git a/desiredata/src/desire.c b/desiredata/src/desire.c index ccf0614e..1f796375 100644 --- a/desiredata/src/desire.c +++ b/desiredata/src/desire.c @@ -1218,10 +1218,10 @@ scalars (g_scalar.c); their graphical behavior is defined accordingly. */ t_class *array_class; -static t_array *array_new(t_symbol *templatesym, t_gpointer *parent) { +static t_array *array_new(t_symbol *tsym, t_gpointer *parent) { t_array *x = (t_array *)pd_new(array_class); - t_template *t = template_findbyname(templatesym); - x->templatesym = templatesym; + t_template *t = template_findbyname(tsym); + x->tsym = tsym; x->n = 1; x->elemsize = sizeof(t_word) * t->n; /* aligned allocation */ @@ -1234,7 +1234,7 @@ static t_array *array_new(t_symbol *templatesym, t_gpointer *parent) { } void array_resize(t_array *x, int n) { - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); if (n < 1) n = 1; int oldn = x->n; int elemsize = sizeof(t_word) * t->n; @@ -1258,7 +1258,7 @@ static void array_resize_and_redraw(t_array *array, int n) { void word_free(t_word *wp, t_template *t); static void array_free(t_array *x) { - t_template *scalartemplate = template_findbyname(x->templatesym); + t_template *scalartemplate = template_findbyname(x->tsym); for (int i=0; i < x->n; i++) word_free((t_word *)(x->vec + x->elemsize*i), scalartemplate); freealignedbytes(x->vec, x->elemsize * x->n); } @@ -1300,10 +1300,10 @@ arrays (the scalar will be of type "_float_array"). Currently this is always called by graph_array() below; but when we make a more general way to save and create arrays this might get called more directly. */ -static t_garray *graph_scalar(t_canvas *gl, t_symbol *s, t_symbol *templatesym, int saveit) { - if (!template_findbyname(templatesym)) return 0; +static t_garray *graph_scalar(t_canvas *gl, t_symbol *s, t_symbol *tsym, int saveit) { + if (!template_findbyname(tsym)) return 0; t_garray *x = (t_garray *)pd_new(garray_class); - x->scalar = scalar_new(gl, templatesym); + x->scalar = scalar_new(gl, tsym); x->realname = s; x->realname = canvas_realizedollar(gl, s); pd_bind(x,x->realname); @@ -1344,7 +1344,7 @@ static t_array *garray_getarray_floatonly(t_garray *x, int *yonsetp, int *elemsi t_array *a = garray_getarray(x); int yonset, type; t_symbol *arraytype; - t_template *t = template_findbyname(a->templatesym); + t_template *t = template_findbyname(a->tsym); if (!template_find_field(t,&s_y,&yonset,&type,&arraytype) || type != DT_FLOAT) return 0; *yonsetp = yonset; @@ -1380,22 +1380,22 @@ by a more coherent (and general) invocation. */ t_garray *graph_array(t_canvas *gl, t_symbol *s, t_symbol *templateargsym, t_floatarg fsize, t_floatarg fflags) { int n = (int)fsize, zonset, ztype, saveit; t_symbol *zarraytype; - t_symbol *templatesym = gensym("pd-_float_array"); + t_symbol *tsym = gensym("pd-_float_array"); int flags = (int)fflags; int filestyle = (flags & 6)>>1; int style = filestyle == 0 ? PLOTSTYLE_POLY : filestyle == 1 ? PLOTSTYLE_POINTS : filestyle; if (templateargsym != &s_float) {error("%s: only 'float' type understood", templateargsym->name); return 0;} - t_template *t = template_findbyname(templatesym); - TEMPLATE_CHECK(templatesym,0) + t_template *t = template_findbyname(tsym); + TEMPLATE_CHECK(tsym,0) if (!template_find_field(t, gensym("z"), &zonset, &ztype, &zarraytype)) { - error("template %s has no 'z' field", templatesym->name); + error("template %s has no 'z' field", tsym->name); return 0; } - if (ztype != DT_ARRAY) {error("template %s, 'z' field is not an array", templatesym->name); return 0;} + if (ztype != DT_ARRAY) {error("template %s, 'z' field is not an array", tsym->name); return 0;} t_template *ztemplate = template_findbyname(zarraytype); if (!ztemplate) {error("no template of type %s", zarraytype->name); return 0;} saveit = (flags & 1) != 0; - t_garray *x = graph_scalar(gl, s, templatesym, saveit); + t_garray *x = graph_scalar(gl, s, tsym, saveit); x->hidename = (flags>>3)&1; if (n <= 0) n = 100; array_resize(x->scalar->v[zonset].w_array, n); @@ -1588,21 +1588,21 @@ static void array_motion(void *z, t_floatarg dx, t_floatarg dy) { int scalar_doclick(t_word *data, t_template *t, t_scalar *sc, t_array *ap, t_canvas *owner, float xloc, float yloc, int xpix, int ypix, int shift, int alt, int dbl, int doit); -static int array_getfields(t_symbol *elemtemplatesym, t_canvas **elemtemplatecanvasp, +static int array_getfields(t_symbol *elemtsym, t_canvas **elemtemplatecanvasp, t_template **elemtemplatep, int *elemsizep, t_slot *xslot, t_slot *yslot, t_slot *wslot, int *xonsetp, int *yonsetp, int *wonsetp); /* try clicking on an element of the array as a scalar (if clicking on the trace of the array failed) */ static int array_doclick_element(t_array *array, t_canvas *canvas, t_scalar *sc, t_array *ap, -t_symbol *elemtemplatesym, float linewidth, float xloc, float xinc, float yloc, +t_symbol *elemtsym, float linewidth, float xloc, float xinc, float yloc, t_slot *xfield, t_slot *yfield, t_slot *wfield, int xpix, int ypix, int shift, int alt, int dbl, int doit) { t_canvas *elemtemplatecanvas; t_template *elemtemplate; int elemsize, yonset, wonset, xonset, incr; //float xsum=0; - if (elemtemplatesym == &s_float) return 0; - if (array_getfields(elemtemplatesym, &elemtemplatecanvas, + if (elemtsym == &s_float) return 0; + if (array_getfields(elemtsym, &elemtemplatecanvas, &elemtemplate, &elemsize, xfield, yfield, wfield, &xonset, &yonset, &wonset)) return 0; /* if it has more than 2000 points, just check 300 of them. */ @@ -1629,12 +1629,12 @@ static float canvas_dpixtody(t_canvas*x,float dypix){return dypix*(canvas_pixels /* LATER move this and others back into plot parentwidget code, so they can be static (look in g_canvas.h for candidates). */ int array_doclick(t_array *array, t_canvas *canvas, t_scalar *sc, t_array *ap, -t_symbol *elemtemplatesym, float linewidth, float xloc, float xinc, float yloc, float scalarvis, +t_symbol *elemtsym, float linewidth, float xloc, float xinc, float yloc, float scalarvis, t_slot *xfield, t_slot *yfield, t_slot *wfield, int xpix, int ypix, int shift, int alt, int dbl, int doit) { t_canvas *elemtemplatecanvas; t_template *elemtemplate; int elemsize, yonset, wonset, xonset; - if (!array_getfields(elemtemplatesym, &elemtemplatecanvas, &elemtemplate, &elemsize, + if (!array_getfields(elemtsym, &elemtemplatecanvas, &elemtemplate, &elemsize, xfield, yfield, wfield, &xonset, &yonset, &wonset)) { float best = 100; /* if it has more than 2000 points, just check 1000 of them. */ @@ -1651,7 +1651,7 @@ t_slot *xfield, t_slot *yfield, t_slot *wfield, int xpix, int ypix, int shift, i dy = fabs(pypix-pwpix-ypix); if (dx+dy < best) best = dx+dy; } } if (best > 8) { - if (scalarvis != 0) return array_doclick_element(array, canvas, sc, ap, elemtemplatesym, + if (scalarvis != 0) return array_doclick_element(array, canvas, sc, ap, elemtsym, linewidth, xloc, xinc, yloc, xfield, yfield, wfield, xpix, ypix, shift, alt, dbl, doit); return 0; } @@ -1791,7 +1791,7 @@ static void garray_dofo(t_garray *x, int npoints, float dcval, int nsin, t_float TEMPLATE_FLOATY(array,) if (npoints == 0) npoints = 512; /* dunno what a good default would be... */ if (npoints != (1 << ilog2(npoints))) - post("%s: rounnding to %d points", array->templatesym->name, (npoints = (1<<ilog2(npoints)))); + post("%s: rounnding to %d points", array->tsym->name, (npoints = (1<<ilog2(npoints)))); garray_resize(x, npoints + 3); double phaseincr = 2. * 3.14159 / npoints; for (i=0, phase = -phaseincr; i < array->n; i++, phase += phaseincr) { @@ -1935,7 +1935,7 @@ void garray_resize(t_garray *x, t_floatarg f) { static void garray_print(t_garray *x) { t_array *array = garray_getarray(x); - post("garray %s: template %s, length %d", x->realname->name, array->templatesym->name, array->n); + post("garray %s: template %s, length %d", x->realname->name, array->tsym->name, array->n); } static void g_array_setup() { @@ -2311,10 +2311,10 @@ static void canvas_readerror(int natoms, t_atom *vec, int message, int nline, co /* fill in the contents of the scalar into the vector w. */ static void canvas_readatoms(t_canvas *x, int natoms, t_atom *vec, -int *p_nextmsg, t_symbol *templatesym, t_word *w, int argc, t_atom *argv) { - t_template *t = template_findbyname(templatesym); +int *p_nextmsg, t_symbol *tsym, t_word *w, int argc, t_atom *argv) { + t_template *t = template_findbyname(tsym); if (!t) { - error("%s: no such template", templatesym->name); + error("%s: no such template", tsym->name); *p_nextmsg = natoms; return; } @@ -2324,9 +2324,9 @@ int *p_nextmsg, t_symbol *templatesym, t_word *w, int argc, t_atom *argv) { if (t->vec[i].type == DT_ARRAY) { t_array *a = w[i].w_array; int elemsize = a->elemsize, nitems = 0; - t_symbol *arraytemplatesym = t->vec[i].arraytemplate; - t_template *arraytemplate = template_findbyname(arraytemplatesym); - if (!arraytemplate) error("%s: no such template", arraytemplatesym->name); + t_symbol *arraytsym = t->vec[i].arraytemplate; + t_template *arraytemplate = template_findbyname(arraytsym); + if (!arraytemplate) error("%s: no such template", arraytsym->name); else while (1) { int message; t_word *element; @@ -2335,7 +2335,7 @@ int *p_nextmsg, t_symbol *templatesym, t_word *w, int argc, t_atom *argv) { if (!nline) break; array_resize(a, nitems + 1); element = (t_word *)&a->vec[nitems*elemsize]; - canvas_readatoms(x, natoms, vec, p_nextmsg, arraytemplatesym, element, nline, vec + message); + canvas_readatoms(x, natoms, vec, p_nextmsg, arraytsym, element, nline, vec + message); nitems++; } } else if (t->vec[i].type == DT_CANVAS) { @@ -2382,9 +2382,9 @@ static void canvas_readfrombinbuf(t_canvas *x, t_binbuf *b, const char *filename } /* read in templates and check for consistency */ while (1) { - t_template *newtemplate, *existtemplate; - t_atom *templateargs = (t_atom *)getbytes(0); - int ntemplateargs = 0; + t_template *newt, *existt; + t_atom *targs = (t_atom *)getbytes(0); + int ntargs = 0; nline = canvas_scanbinbuf(natoms, vec, &message, &nextmsg); if (nline < 2) break; else if (nline > 2) canvas_readerror(natoms, vec, message, nline, "extra items ignored"); @@ -2393,30 +2393,27 @@ static void canvas_readfrombinbuf(t_canvas *x, t_binbuf *b, const char *filename canvas_readerror(natoms, vec, message, nline, "bad template header"); continue; } - t_symbol *templatesym = canvas_makebindsym(vec[message + 1].a_symbol); + t_symbol *tsym = canvas_makebindsym(vec[message + 1].a_symbol); while (1) { nline = canvas_scanbinbuf(natoms, vec, &message, &nextmsg); - if (nline != 2 && nline != 3) break; - int newnargs = ntemplateargs + nline; - templateargs = (t_atom *)realloc(templateargs, sizeof(*templateargs) * newnargs); - templateargs[ntemplateargs] = vec[message]; - templateargs[ntemplateargs + 1] = vec[message + 1]; - if (nline == 3) templateargs[ntemplateargs + 2] = vec[message + 2]; - ntemplateargs = newnargs; + if (nline!=2 && nline!=3) break; + int newnargs = ntargs + nline; + targs = (t_atom *)realloc(targs, sizeof(*targs) * newnargs); + targs[ntargs] = vec[message]; + targs[ntargs+1] = vec[message+1]; + if (nline==3) targs[ntargs+2] = vec[message+2]; + ntargs = newnargs; } - newtemplate = template_new(templatesym, ntemplateargs, templateargs); - free(templateargs); - if (!(existtemplate = template_findbyname(templatesym))) { - error("%s: template not found in current patch", templatesym->name); - template_free(newtemplate); + newt = template_new(tsym, ntargs, targs); + free(targs); + existt = template_findbyname(tsym); + if (!existt) {error("%s: template not found in current patch", tsym->name); template_free(newt); return;} + if (!template_match(existt, newt)) { + error("%s: template doesn't match current one", tsym->name); + template_free(newt); return; } - if (!template_match(existtemplate, newtemplate)) { - error("%s: template doesn't match current one", templatesym->name); - template_free(newtemplate); - return; - } - template_free(newtemplate); + template_free(newt); } while (nextmsg < natoms) canvas_readscalar(x, natoms, vec, &nextmsg, selectem); } @@ -2455,25 +2452,25 @@ void canvas_dataproperties(t_canvas *x, t_scalar *sc, t_binbuf *b) { canvas_readfrombinbuf(x, b, "properties dialog", 0); } -static void canvas_doaddtemplate(t_symbol *templatesym, int *p_ntemplates, t_symbol ***p_templatevec) { +static void canvas_doaddtemplate(t_symbol *tsym, int *p_ntemplates, t_symbol ***p_templatevec) { int n = *p_ntemplates; t_symbol **templatevec = *p_templatevec; - for (int i=0; i < n; i++) if (templatevec[i] == templatesym) return; + for (int i=0; i < n; i++) if (templatevec[i] == tsym) return; templatevec = (t_symbol **)realloc(templatevec, (n+1)*sizeof(*templatevec)); - templatevec[n] = templatesym; + templatevec[n] = tsym; *p_templatevec = templatevec; *p_ntemplates = n+1; } static void canvas_writelist(t_gobj *y, t_binbuf *b); -static void canvas_writescalar(t_symbol *templatesym, t_word *w, t_binbuf *b, int amarrayelement) { - t_template *t = template_findbyname(templatesym); +static void canvas_writescalar(t_symbol *tsym, t_word *w, t_binbuf *b, int amarrayelement) { + t_template *t = template_findbyname(tsym); t_atom *a = (t_atom *)getbytes(0); int n = t->n, natom = 0; if (!amarrayelement) { t_atom templatename; - SETSYMBOL(&templatename, gensym(templatesym->name + 3)); + SETSYMBOL(&templatename, gensym(tsym->name + 3)); binbuf_add(b, 1, &templatename); } if (!t) bug("canvas_writescalar"); @@ -2497,9 +2494,9 @@ static void canvas_writescalar(t_symbol *templatesym, t_word *w, t_binbuf *b, in if (t->vec[i].type == DT_ARRAY) { t_array *a = w[i].w_array; int elemsize = a->elemsize, nitems = a->n; - t_symbol *arraytemplatesym = t->vec[i].arraytemplate; + t_symbol *arraytsym = t->vec[i].arraytemplate; for (int j = 0; j < nitems; j++) - canvas_writescalar(arraytemplatesym, (t_word *)&a->vec[elemsize*j], b, 1); + canvas_writescalar(arraytsym, (t_word *)&a->vec[elemsize*j], b, 1); binbuf_addsemi(b); } else if (t->vec[i].type == DT_CANVAS) { canvas_writelist(w->w_canvas->boxes->first(), b); @@ -2517,19 +2514,19 @@ static void canvas_writelist(t_gobj *y, t_binbuf *b) { static void canvas_addtemplatesforlist(t_gobj *y, int *p_ntemplates, t_symbol ***p_templatevec); -static void canvas_addtemplatesforscalar(t_symbol *templatesym, t_word *w, int *p_ntemplates, t_symbol ***p_templatevec) { - t_template *t = template_findbyname(templatesym); - canvas_doaddtemplate(templatesym, p_ntemplates, p_templatevec); +static void canvas_addtemplatesforscalar(t_symbol *tsym, t_word *w, int *p_ntemplates, t_symbol ***p_templatevec) { + t_template *t = template_findbyname(tsym); + canvas_doaddtemplate(tsym, p_ntemplates, p_templatevec); if (!t) {bug("canvas_addtemplatesforscalar"); return;} t_dataslot *ds = t->vec; for (int i=t->n; i--; ds++, w++) { if (ds->type == DT_ARRAY) { t_array *a = w->w_array; int elemsize = a->elemsize, nitems = a->n; - t_symbol *arraytemplatesym = ds->arraytemplate; - canvas_doaddtemplate(arraytemplatesym, p_ntemplates, p_templatevec); + t_symbol *arraytsym = ds->arraytemplate; + canvas_doaddtemplate(arraytsym, p_ntemplates, p_templatevec); for (int j=0; j<nitems; j++) - canvas_addtemplatesforscalar(arraytemplatesym, (t_word *)&a->vec[elemsize*j], p_ntemplates, p_templatevec); + canvas_addtemplatesforscalar(arraytsym, (t_word *)&a->vec[elemsize*j], p_ntemplates, p_templatevec); } else if (ds->type == DT_CANVAS) canvas_addtemplatesforlist(w->w_canvas->boxes->first(), p_ntemplates, p_templatevec); } @@ -3210,14 +3207,14 @@ static t_scalar *gpointer_getscalar(t_gpointer *gp) { /* make a new scalar and add to the canvas. We create a "gp" here which will be used for array items to point back here. This gp doesn't do reference counting or "validation" updates though; the parent won't go away without the contained arrays going away too. The "gp" is copied out by value in the word_init() routine so we can throw our copy away. */ -t_scalar *scalar_new(t_canvas *owner, t_symbol *templatesym) { +t_scalar *scalar_new(t_canvas *owner, t_symbol *tsym) { t_gpointer gp; gpointer_init(&gp); - t_template *t = template_findbyname(templatesym); - TEMPLATE_CHECK(templatesym,0) + t_template *t = template_findbyname(tsym); + TEMPLATE_CHECK(tsym,0) t_scalar *x = (t_scalar *)getbytes(sizeof(t_scalar) + (t->n - 1) * sizeof(*x->v)); x->_class = scalar_class; - x->t = templatesym; + x->t = tsym; gpointer_setcanvas(&gp, owner, x); word_init(x->v, t, &gp); return x; @@ -3226,8 +3223,8 @@ t_scalar *scalar_new(t_canvas *owner, t_symbol *templatesym) { /* Pd method to create a new scalar, add it to a canvas, and initialize it from the message arguments. */ int canvas_readscalar(t_canvas *x, int natoms, t_atom *vec, int *p_nextmsg, int selectit); static void canvas_scalar(t_canvas *canvas, t_symbol *classname, t_int argc, t_atom *argv) { - t_symbol *templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); - if (!template_findbyname(templatesym)) {error("%s: no such template", atom_getsymbolarg(0, argc, argv)->name); return;} + t_symbol *tsym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); + if (!template_findbyname(tsym)) {error("%s: no such template", atom_getsymbolarg(0, argc, argv)->name); return;} int nextmsg; t_binbuf *b = binbuf_new(); binbuf_restore(b, argc, argv); @@ -3244,11 +3241,11 @@ static void scalar_getbasexy(t_scalar *x, float *basex, float *basey) { /* static void scalar_displace(t_gobj *z, t_canvas *canvas, int dx, int dy) { t_scalar *x = (t_scalar *)z; - t_symbol *templatesym = x->t; - t_template *t = template_findbyname(templatesym); + t_symbol *tsym = x->t; + t_template *t = template_findbyname(tsym); t_symbol *zz; int xonset, yonset, xtype, ytype, gotx, goty; - TEMPLATE_CHECK(templatesym,) + TEMPLATE_CHECK(tsym,) gotx = template_find_field(t,&s_x,&xonset,&xtype,&zz); if (gotx && (xtype != DT_FLOAT)) gotx = 0; goty = template_find_field(t,&s_y,&yonset,&ytype,&zz); @@ -3308,7 +3305,7 @@ static int scalar_click(t_gobj *z, t_canvas *owner, int xpix, int ypix, int shif return scalar_doclick(x->v, t, x, 0, owner, 0, 0, xpix, ypix, shift, alt, dbl, doit); } -void canvas_writescalar(t_symbol *templatesym, t_word *w, t_binbuf *b, int amarrayelement); +void canvas_writescalar(t_symbol *tsym, t_word *w, t_binbuf *b, int amarrayelement); static void scalar_save(t_gobj *z, t_binbuf *b) { t_scalar *x = (t_scalar *)z; @@ -3381,7 +3378,7 @@ static int dataslot_matches(t_dataslot *ds1, t_dataslot *ds2, int nametoo) { /* -- templates, the active ingredient in gtemplates defined below. ------- */ -static t_template *template_new(t_symbol *templatesym, int argc, t_atom *argv) { +static t_template *template_new(t_symbol *tsym, int argc, t_atom *argv) { t_template *x = (t_template *)pd_new(template_class); x->n = 0; x->vec = (t_dataslot *)getbytes(0); @@ -3410,8 +3407,8 @@ static t_template *template_new(t_symbol *templatesym, int argc, t_atom *argv) { bad: argc -= 2; argv += 2; } - x->sym = templatesym; - if (templatesym->name) pd_bind(x,x->sym); + x->sym = tsym; + if (tsym->name) pd_bind(x,x->sym); return x; } @@ -3527,7 +3524,7 @@ static t_scalar *template_conformscalar(t_template *tfrom, t_template *tto, int /* conform an array, recursively conforming sublists and arrays */ static void template_conformarray(t_template *tfrom, t_template *tto, int *conformaction, t_array *a) { t_template *scalartemplate = 0; - if (a->templatesym == tfrom->sym) { + if (a->tsym == tfrom->sym) { /* the array elements must all be conformed */ int oldelemsize = sizeof(t_word) * tfrom->n; int newelemsize = sizeof(t_word) * tto->n; @@ -3543,7 +3540,7 @@ static void template_conformarray(t_template *tfrom, t_template *tto, int *confo scalartemplate = tto; a->vec = newarray; free(oldarray); - } else scalartemplate = template_findbyname(a->templatesym); + } else scalartemplate = template_findbyname(a->tsym); /* convert all arrays and sublist fields in each element of the array */ for (int i=0; i<a->n; i++) { t_word *wp = (t_word *)(a->vec + sizeof(t_word) * a->n * i); @@ -3638,8 +3635,8 @@ static void template_notifyforscalar(t_template *t, t_canvas *owner, t_scalar *s in trouble. LATER we'll figure out how to conform the new patch's objects to the pre-existing struct. */ static void *template_usetemplate(void *dummy, t_symbol *s, int argc, t_atom *argv) { - t_symbol *templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); - t_template *x = (t_template *)pd_findbyclass(templatesym, template_class); + t_symbol *tsym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); + t_template *x = (t_template *)pd_findbyclass(tsym, template_class); if (!argc) return 0; argc--; argv++; if (x) { @@ -3647,16 +3644,16 @@ static void *template_usetemplate(void *dummy, t_symbol *s, int argc, t_atom *ar /* If the new template is the same as the old one, there's nothing to do. */ if (!template_match(x, y)) { /* Are there "struct" objects upholding this template? */ if (x->list) { - error("%s: template mismatch", templatesym->name); + error("%s: template mismatch", tsym->name); } else { template_conform(x, y); pd_free(x); - t_template *y2 = template_new(templatesym, argc, argv); + t_template *y2 = template_new(tsym, argc, argv); y2->list = 0; } } pd_free(y); - } else template_new(templatesym, argc, argv); + } else template_new(tsym, argc, argv); return 0; } @@ -4118,13 +4115,13 @@ void plot_float(t_plot *x, t_floatarg f) { /* get everything we'll need from the owner template of the array being plotted. Not used for garrays, but see below */ static int plot_readownertemplate(t_plot *x, t_word *data, t_template *ownertemplate, -t_symbol **elemtemplatesymp, t_array **arrayp, float *linewidthp, float *xlocp, float *xincp, float *ylocp, +t_symbol **elemtsymp, t_array **arrayp, float *linewidthp, float *xlocp, float *xincp, float *ylocp, float *stylep, float *visp, float *scalarvisp) { int arrayonset, type; - t_symbol *elemtemplatesym; + t_symbol *elemtsym; t_array *array; if (x->data.type != A_ARRAY || !x->data.var) {error("needs an array field"); return -1;} - if (!template_find_field(ownertemplate, x->data.varsym, &arrayonset, &type, &elemtemplatesym)) { + if (!template_find_field(ownertemplate, x->data.varsym, &arrayonset, &type, &elemtsym)) { error("%s: no such field", x->data.varsym->name); return -1; } @@ -4137,14 +4134,14 @@ float *stylep, float *visp, float *scalarvisp) { *stylep = slot_getfloat(&x->style, ownertemplate, data, 1); *visp = slot_getfloat(&x->vis, ownertemplate, data, 1); *scalarvisp = slot_getfloat(&x->scalarvis, ownertemplate, data, 1); - *elemtemplatesymp = elemtemplatesym; + *elemtsymp = elemtsym; *arrayp = array; return 0; } /* get everything else you could possibly need about a plot, either for plot's own purposes or for plotting a "garray" */ -static int array_getfields(t_symbol *elemtemplatesym, t_canvas **elemtemplatecanvasp, +static int array_getfields(t_symbol *elemtsym, t_canvas **elemtemplatecanvasp, t_template **elemtemplatep, int *elemsizep, t_slot *xslot, t_slot *yslot, t_slot *wslot, int *xonsetp, int *yonsetp, int *wonsetp) { int type; @@ -4152,10 +4149,10 @@ int *xonsetp, int *yonsetp, int *wonsetp) { t_canvas *elemtemplatecanvas = 0; /* the "float" template is special in not having to have a canvas; template_findbyname is hardwired to return a predefined template. */ - t_template *elemtemplate = template_findbyname(elemtemplatesym); - if (!elemtemplate) {error("%s: no such template", elemtemplatesym->name); return -1;} - if (!(elemtemplatesym==&s_float || (elemtemplatecanvas = template_findcanvas(elemtemplate)))) { - error("%s: no canvas for this template", elemtemplatesym->name); + t_template *elemtemplate = template_findbyname(elemtsym); + if (!elemtemplate) {error("%s: no such template", elemtsym->name); return -1;} + if (!(elemtsym==&s_float || (elemtemplatecanvas = template_findcanvas(elemtemplate)))) { + error("%s: no canvas for this template", elemtsym->name); return -1; } *elemtemplatecanvasp = elemtemplatecanvas; @@ -4176,13 +4173,13 @@ static void plot_vis(t_gobj *z, t_canvas *canvas, t_word *data, t_template *t, f int elemsize, yonset, wonset, xonset; t_canvas *elemtemplatecanvas; t_template *elemtemplate; - t_symbol *elemtemplatesym; + t_symbol *elemtsym; float linewidth, xloc, xinc, yloc, style, xsum, yval, vis, scalarvis; t_array *array; - if (plot_readownertemplate(x, data, t, &elemtemplatesym, &array, &linewidth, &xloc, &xinc, &yloc, &style, &vis, &scalarvis)) return; + if (plot_readownertemplate(x, data, t, &elemtsym, &array, &linewidth, &xloc, &xinc, &yloc, &style, &vis, &scalarvis)) return; t_slot *xslot = &x->xpoints, *yslot = &x->ypoints, *wslot = &x->wpoints; if (!vis) return; - if (array_getfields(elemtemplatesym, &elemtemplatecanvas, &elemtemplate, &elemsize, + if (array_getfields(elemtsym, &elemtemplatecanvas, &elemtemplate, &elemsize, xslot, yslot, wslot, &xonset, &yonset, &wonset)) return; int nelem = array->n; char *elem = (char *)array->vec; @@ -4321,13 +4318,13 @@ static void plot_vis(t_gobj *z, t_canvas *canvas, t_word *data, t_template *t, f static int plot_click(t_gobj *z, t_canvas *canvas, t_word *data, t_template *t, t_scalar *sc, t_array *ap, float basex, float basey, int xpix, int ypix, int shift, int alt, int dbl, int doit) { t_plot *x = (t_plot *)z; - t_symbol *elemtemplatesym; + t_symbol *elemtsym; float linewidth, xloc, xinc, yloc, style, vis, scalarvis; t_array *array; - if (plot_readownertemplate(x, data, t, &elemtemplatesym, &array, &linewidth, &xloc, &xinc, + if (plot_readownertemplate(x, data, t, &elemtsym, &array, &linewidth, &xloc, &xinc, &yloc, &style, &vis, &scalarvis)) return 0; if (!vis) return 0; - return array_doclick(array, canvas, sc, ap, elemtemplatesym, linewidth, basex + xloc, xinc, + return array_doclick(array, canvas, sc, ap, elemtsym, linewidth, basex + xloc, xinc, basey + yloc, scalarvis, &x->xpoints, &x->ypoints, &x->wpoints, xpix, ypix, shift, alt, dbl, doit); } @@ -4511,8 +4508,8 @@ int gpointer_check(const t_gpointer *gp, int headok) { } /* get the template for the object pointer to. Assumes we've already checked freshness. Returns 0 if head of list. */ -static t_symbol *gpointer_gettemplatesym(const t_gpointer *gp) { - if (gp->o->_class == array_class) return gp->array->templatesym; +static t_symbol *gpointer_gettsym(const t_gpointer *gp) { + if (gp->o->_class == array_class) return gp->array->tsym; t_scalar *sc = gp->scalar; return sc ? sc->t : 0; } @@ -4622,9 +4619,9 @@ static void ptrobj_sendwindow(t_ptrobj *x, t_symbol *s, int argc, t_atom *argv) static void ptrobj_bang(t_ptrobj *x) { t_typedout *to = x->typedout; if (!gpointer_check(&x->gp, 1)) {error("bang: empty pointer"); return;} - t_symbol *templatesym = gpointer_gettemplatesym(&x->gp); + t_symbol *tsym = gpointer_gettsym(&x->gp); for (int n=x->ntypedout; n--; to++) - if (to->type == templatesym) {outlet_pointer(to->outlet, &x->gp); return;} + if (to->type == tsym) {outlet_pointer(to->outlet, &x->gp); return;} outlet_pointer(x->otherout, &x->gp); } @@ -4654,13 +4651,13 @@ struct t_getvariable { t_outlet *outlet; }; struct t_get : t_object { - t_symbol *templatesym; + t_symbol *tsym; int nout; t_getvariable *variables; }; static void *get_new(t_symbol *why, int argc, t_atom *argv) { t_get *x = (t_get *)pd_new(get_class); - x->templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); + x->tsym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); if (argc) argc--, argv++; t_getvariable *sp = x->variables = (t_getvariable *)getbytes(argc * sizeof (*x->variables)); x->nout = argc; @@ -4676,9 +4673,9 @@ static void *get_new(t_symbol *why, int argc, t_atom *argv) { static void get_pointer(t_get *x, t_gpointer *gp) { int nitems = x->nout; - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); t_getvariable *vp; - TEMPLATE_CHECK(x->templatesym,) + TEMPLATE_CHECK(x->tsym,) if (!gpointer_check(gp, 0)) {error("stale or empty pointer"); return;} t_word *vec = gpointer_word(gp); vp = x->variables + nitems-1; @@ -4706,7 +4703,7 @@ struct t_setvariable { struct t_set : t_object { t_gpointer gp; - t_symbol *templatesym; + t_symbol *tsym; int nin; int issymbol; t_setvariable *variables; @@ -4720,7 +4717,7 @@ static void *set_new(t_symbol *why, int argc, t_atom *argv) { argv++; } else x->issymbol = 0; - x->templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); + x->tsym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); if (argc) argc--, argv++; t_setvariable *sp = x->variables = (t_setvariable *)getbytes(argc * sizeof (*x->variables)); x->nin = argc; @@ -4742,12 +4739,12 @@ static void *set_new(t_symbol *why, int argc, t_atom *argv) { static void set_bang(t_set *x) { int nitems = x->nin; - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); t_gpointer *gp = &x->gp; - TEMPLATE_CHECK(x->templatesym,) + TEMPLATE_CHECK(x->tsym,) if (!gpointer_check(gp, 0)) {error("empty pointer"); return;} - if (gpointer_gettemplatesym(gp) != x->templatesym) { - error("%s: got wrong template (%s)",x->templatesym->name,gpointer_gettemplatesym(gp)->name); + if (gpointer_gettsym(gp) != x->tsym) { + error("%s: got wrong template (%s)",x->tsym->name,gpointer_gettsym(gp)->name); return; } if (!nitems) return; @@ -4777,15 +4774,15 @@ static void set_free(t_set *x) { static t_class *elem_class; struct t_elem : t_object { - t_symbol *templatesym; + t_symbol *tsym; t_symbol *fieldsym; t_gpointer gp; t_gpointer gparent; }; -static void *elem_new(t_symbol *templatesym, t_symbol *fieldsym) { +static void *elem_new(t_symbol *tsym, t_symbol *fieldsym) { t_elem *x = (t_elem *)pd_new(elem_class); - x->templatesym = canvas_makebindsym(templatesym); + x->tsym = canvas_makebindsym(tsym); x->fieldsym = fieldsym; gpointer_init(&x->gp); gpointer_init(&x->gparent); @@ -4796,26 +4793,26 @@ static void *elem_new(t_symbol *templatesym, t_symbol *fieldsym) { static void elem_float(t_elem *x, t_float f) { int indx = (int)f, nitems, onset; - t_symbol *fieldsym = x->fieldsym, *elemtemplatesym; - t_template *t = template_findbyname(x->templatesym); + t_symbol *fieldsym = x->fieldsym, *elemtsym; + t_template *t = template_findbyname(x->tsym); t_template *elemtemplate; t_gpointer *gparent = &x->gparent; t_array *array; int elemsize, type; if (!gpointer_check(gparent, 0)) {error("empty pointer"); return;} - if (gpointer_gettemplatesym(gparent) != x->templatesym) { - error("%s: got wrong template (%s)", x->templatesym->name, gpointer_gettemplatesym(gparent)->name); + if (gpointer_gettsym(gparent) != x->tsym) { + error("%s: got wrong template (%s)", x->tsym->name, gpointer_gettsym(gparent)->name); return; } t_word *w = gpointer_word(gparent); - TEMPLATE_CHECK(x->templatesym,) - if (!template_find_field(t, fieldsym, &onset, &type, &elemtemplatesym)) { + TEMPLATE_CHECK(x->tsym,) + if (!template_find_field(t, fieldsym, &onset, &type, &elemtsym)) { error("couldn't find array field %s", fieldsym->name); return; } if (type != DT_ARRAY) {error("element: field %s not of type array", fieldsym->name); return;} - if (!(elemtemplate = template_findbyname(elemtemplatesym))) { - error("couldn't find field template %s", elemtemplatesym->name); + if (!(elemtemplate = template_findbyname(elemtsym))) { + error("couldn't find field template %s", elemtsym->name); return; } elemsize = elemtemplate->n * sizeof(t_word); @@ -4837,13 +4834,13 @@ static void elem_free(t_elem *x, t_gpointer *gp) { static t_class *getsize_class; struct t_getsize : t_object { - t_symbol *templatesym; + t_symbol *tsym; t_symbol *fieldsym; }; -static void *getsize_new(t_symbol *templatesym, t_symbol *fieldsym) { +static void *getsize_new(t_symbol *tsym, t_symbol *fieldsym) { t_getsize *x = (t_getsize *)pd_new(getsize_class); - x->templatesym = canvas_makebindsym(templatesym); + x->tsym = canvas_makebindsym(tsym); x->fieldsym = fieldsym; outlet_new(x,&s_float); return x; @@ -4851,17 +4848,17 @@ static void *getsize_new(t_symbol *templatesym, t_symbol *fieldsym) { static void getsize_pointer(t_getsize *x, t_gpointer *gp) { int onset, type; - t_symbol *fieldsym = x->fieldsym, *elemtemplatesym; - t_template *t = template_findbyname(x->templatesym); - TEMPLATE_CHECK(x->templatesym,) - if (!template_find_field(t, fieldsym, &onset, &type, &elemtemplatesym)) { + t_symbol *fieldsym = x->fieldsym, *elemtsym; + t_template *t = template_findbyname(x->tsym); + TEMPLATE_CHECK(x->tsym,) + if (!template_find_field(t, fieldsym, &onset, &type, &elemtsym)) { error("couldn't find array field %s", fieldsym->name); return; } if (type != DT_ARRAY) {error("field %s not of type array", fieldsym->name); return;} if (!gpointer_check(gp, 0)) {error("stale or empty pointer"); return;} - if (gpointer_gettemplatesym(gp) != x->templatesym) { - error("%s: got wrong template (%s)", x->templatesym->name, gpointer_gettemplatesym(gp)->name); + if (gpointer_gettsym(gp) != x->tsym) { + error("%s: got wrong template (%s)", x->tsym->name, gpointer_gettsym(gp)->name); return; } t_word *w = gpointer_word(gp); @@ -4874,14 +4871,14 @@ static void getsize_pointer(t_getsize *x, t_gpointer *gp) { static t_class *setsize_class; struct t_setsize : t_object { - t_symbol *templatesym; + t_symbol *tsym; t_symbol *fieldsym; t_gpointer gp; }; -static void *setsize_new(t_symbol *templatesym, t_symbol *fieldsym, t_floatarg newsize) { +static void *setsize_new(t_symbol *tsym, t_symbol *fieldsym, t_floatarg newsize) { t_setsize *x = (t_setsize *)pd_new(setsize_class); - x->templatesym = canvas_makebindsym(templatesym); + x->tsym = canvas_makebindsym(tsym); x->fieldsym = fieldsym; gpointer_init(&x->gp); pointerinlet_new(x,&x->gp); @@ -4890,25 +4887,25 @@ static void *setsize_new(t_symbol *templatesym, t_symbol *fieldsym, t_floatarg n static void setsize_float(t_setsize *x, t_float f) { int onset, type; - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); int newsize = (int)f; t_gpointer *gp = &x->gp; if (!gpointer_check(&x->gp, 0)) {error("empty pointer"); return;} - if (gpointer_gettemplatesym(&x->gp) != x->templatesym) { - error("%s: got wrong template (%s)", x->templatesym->name, gpointer_gettemplatesym(&x->gp)->name); + if (gpointer_gettsym(&x->gp) != x->tsym) { + error("%s: got wrong template (%s)", x->tsym->name, gpointer_gettsym(&x->gp)->name); return; } t_word *w = gpointer_word(gp); - TEMPLATE_CHECK(x->templatesym,) - t_symbol *elemtemplatesym; - if (!template_find_field(t, x->fieldsym, &onset, &type, &elemtemplatesym)) { + TEMPLATE_CHECK(x->tsym,) + t_symbol *elemtsym; + if (!template_find_field(t, x->fieldsym, &onset, &type, &elemtsym)) { error("couldn't find array field %s", x->fieldsym->name); return; } if (type != DT_ARRAY) {error("field %s not of type array", x->fieldsym->name); return;} - t_template *elemtemplate = template_findbyname(elemtemplatesym); + t_template *elemtemplate = template_findbyname(elemtsym); if (!elemtemplate) { - error("couldn't find field template %s", elemtemplatesym->name); + error("couldn't find field template %s", elemtsym->name); return; } int elemsize = elemtemplate->n * sizeof(t_word); @@ -4947,14 +4944,14 @@ struct t_appendvariable { struct t_append : t_object { t_gpointer gp; - t_symbol *templatesym; + t_symbol *tsym; int nin; t_appendvariable *variables; }; static void *append_new(t_symbol *why, int argc, t_atom *argv) { t_append *x = (t_append *)pd_new(append_class); - x->templatesym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); + x->tsym = canvas_makebindsym(atom_getsymbolarg(0, argc, argv)); if (argc) argc--, argv++; x->variables = (t_appendvariable *)getbytes(argc * sizeof (*x->variables)); x->nin = argc; @@ -4974,16 +4971,16 @@ static void *append_new(t_symbol *why, int argc, t_atom *argv) { static void append_float(t_append *x, t_float f) { int nitems = x->nin; - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); t_gpointer *gp = &x->gp; - TEMPLATE_CHECK(x->templatesym,) + TEMPLATE_CHECK(x->tsym,) if (!gp->o) {error("no current pointer"); return;} if (gp->o->_class == array_class) {error("lists only, not arrays"); return;} t_canvas *canvas = gp->canvas; if (!nitems) return; x->variables[0].f = f; - t_scalar *sc = scalar_new(canvas,x->templatesym); - if (!sc) {error("%s: couldn't create scalar", x->templatesym->name); return;} + t_scalar *sc = scalar_new(canvas,x->tsym); + if (!sc) {error("%s: couldn't create scalar", x->tsym->name); return;} canvas->boxes->add(sc); gobj_changed(sc,0); gp->scalar = sc; @@ -5004,14 +5001,14 @@ static void append_free(t_append *x) { static t_class *sublist_class; struct t_sublist : t_object { - t_symbol *templatesym; + t_symbol *tsym; t_symbol *fieldsym; t_gpointer gp; }; -static void *sublist_new(t_symbol *templatesym, t_symbol *fieldsym) { +static void *sublist_new(t_symbol *tsym, t_symbol *fieldsym) { t_sublist *x = (t_sublist *)pd_new(sublist_class); - x->templatesym = canvas_makebindsym(templatesym); + x->tsym = canvas_makebindsym(tsym); x->fieldsym = fieldsym; gpointer_init(&x->gp); outlet_new(x,&s_pointer); @@ -5020,9 +5017,9 @@ static void *sublist_new(t_symbol *templatesym, t_symbol *fieldsym) { static void sublist_pointer(t_sublist *x, t_gpointer *gp) { t_symbol *dummy; - t_template *t = template_findbyname(x->templatesym); + t_template *t = template_findbyname(x->tsym); int onset, type; - TEMPLATE_CHECK(x->templatesym,) + TEMPLATE_CHECK(x->tsym,) if (!gpointer_check(gp, 0)) {error("stale or empty pointer"); return;} if (!template_find_field(t, x->fieldsym, &onset, &type, &dummy)) { error("couldn't find field %s", x->fieldsym->name); diff --git a/desiredata/src/desire.h b/desiredata/src/desire.h index 4097fdc8..0833d61e 100644 --- a/desiredata/src/desire.h +++ b/desiredata/src/desire.h @@ -227,7 +227,10 @@ struct _array { int n; /* number of elements */ int elemsize; /* size in bytes; LATER get this from template */ char *vec; /* array of elements */ - t_symbol *templatesym; /* template for elements */ + union { + t_symbol *tsym; /* template for elements */ + t_symbol *templatesym; /* alias */ + }; t_gpointer gp; /* pointer to scalar or array element we're in */ }; |