/* redraw all the items in a glist. We construe this to mean
redrawing in its own window and on parent, as needed in each case.
This is too conservative -- for instance, when you draw an "open"
rectangle on the parent, you shouldn't have to redraw the window! */
void glist_redraw(t_glist *x)
{
if (glist_isvisible(x))
{
/* LATER fix the graph_vis() code to handle both cases */
if (glist_istoplevel(x))
{
t_gobj *g;
t_linetraverser t;
t_outconnect *oc;
for (g = x->gl_list; g; g = g->g_next)
{
gobj_vis(g, x, 0);
gobj_vis(g, x, 1);
}
/* redraw all the lines */
linetraverser_start(&t, x);
while (oc = linetraverser_next(&t))
sys_vgui(".x%lx.c coords l%lx %d %d %d %d\n",
glist_getcanvas(x), oc,
t.tr_lx1, t.tr_ly1, t.tr_lx2, t.tr_ly2);
canvas_drawredrect(x, 0);
if (x->gl_goprect)
{
canvas_drawredrect(x, 1);
}
}
if (x->gl_owner && glist_isvisible(x->gl_owner))
{
graph_vis(&x->gl_gobj, x->gl_owner, 0);
graph_vis(&x->gl_gobj, x->gl_owner, 1);
}
}
}
/* To be called in a 'dsp' method -- e.g. if there are no feeders, the caller
might use an optimized version of a 'perform' routine.
LATER think about replacing 'linetraverser' calls with something faster. */
int forky_hasfeeders(t_object *x, t_glist *glist, int inno, t_symbol *outsym)
{
t_linetraverser t;
linetraverser_start(&t, glist);
while (linetraverser_next(&t))
if (t.tr_ob2 == x && t.tr_inno == inno
#if FORKY_VERSION >= 36
&& (!outsym || outsym == outlet_getsymbol(t.tr_outlet))
#endif
)
return (1);
return (0);
}
static void canvas_deletelines_for_io(t_canvas *x, t_text *text, t_inlet *inp, t_outlet *outp)
{
t_linetraverser t;
t_outconnect *oc;
linetraverser_start(&t, x);
while((oc = linetraverser_next(&t)))
{
if ((t.tr_ob == text && t.tr_outlet == outp) || (t.tr_ob2 == text && t.tr_inlet == inp))
{
if(glist_isvisible(x))
{
sys_vgui(".x%lx.c delete l%lx\n", glist_getcanvas(x), oc);
}
obj_disconnect(t.tr_ob, t.tr_outno, t.tr_ob2, t.tr_inno);
}
}
}
static void gobj_stowconnections(t_glist *gl, t_gobj *ob, t_binbuf *bb)
{
t_linetraverser lt;
t_outconnect *oc;
binbuf_clear(bb);
linetraverser_start(<, gl);
while (oc = linetraverser_next(<))
{
if ((t_gobj *)lt.tr_ob == ob || (t_gobj *)lt.tr_ob2 == ob)
binbuf_addv(bb, "ssiiii;",
gensym("#X"), gensym("connect"),
gobj_getindex(gl, (t_gobj *)lt.tr_ob), lt.tr_outno,
gobj_getindex(gl, (t_gobj *)lt.tr_ob2), lt.tr_inno);
}
#ifdef FRINGE_DEBUG
fprintf(stderr, "packed connections:\n");
binbuf_print(bb);
#endif
}
void eobj_dsp(void *x, t_signal **sp)
{
int i;
short* count;
t_int* temp;
t_float **tempout, *tempreal;
t_linetraverser t;
t_outconnect *oc;
t_eclass* c = eobj_getclass(x);
t_edsp* dsp = eobj_getdsp(x);
int nouts = obj_nsigoutlets((t_object *)x);
int nins = obj_nsiginlets((t_object *)x);
int samplesize;
if(c && c->c_widget.w_dsp && dsp && (nins || nouts) && sp && sp[0])
{
samplesize = sp[0]->s_n;
dsp->d_perform_method = NULL;
if(dsp->d_misc == E_NO_INPLACE)
{
if(dsp->d_sigs_out)
{
tempout = (t_float **)realloc(dsp->d_sigs_out, (size_t)nouts * sizeof(t_float *));
}
else
{
tempout = (t_float **)malloc((size_t)nouts * sizeof(t_float *));
}
if(!tempout)
{
if(dsp->d_sigs_out)
{
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
}
pd_error(dsp, "can't allocate memory for ni inpace processing.");
return;
}
dsp->d_sigs_out = tempout;
if(dsp->d_sigs_real)
{
tempreal = (t_float *)realloc(dsp->d_sigs_real, (size_t)(nouts * samplesize) * sizeof(t_float));
}
else
{
tempreal = (t_float *)malloc((size_t)(nouts * samplesize) * sizeof(t_float));
}
if(!tempreal)
{
if(dsp->d_sigs_real)
{
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
}
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
pd_error(dsp, "can't allocate memory for ni inpace processing.");
return;
}
dsp->d_sigs_real = tempreal;
for(i = 0; i < nouts; i++)
{
dsp->d_sigs_out[i] = dsp->d_sigs_real+i*samplesize;
}
}
if(dsp->d_vectors)
{
temp = (t_int *)realloc(dsp->d_vectors, (size_t)(nins + nouts + 7) * sizeof(t_int));
}
else
{
temp = (t_int *)malloc((size_t)(nins + nouts + 7) * sizeof(t_int));
}
if(!temp)
{
if(dsp->d_vectors)
{
free(dsp->d_vectors);
dsp->d_vectors = NULL;
}
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "can't allocate memory for dsp vector.");
return;
}
dsp->d_vectors = temp;
dsp->d_size = nins + nouts + 7;
count = (short*)malloc((size_t)(nins + nouts) * sizeof(short));
if(count)
{
for(i = 0; i < (nins + nouts); i++)
{
count[i] = 0;
}
linetraverser_start(&t, eobj_getcanvas(x));
while((oc = linetraverser_next(&t)))
{
if(t.tr_ob2 == x && obj_issignaloutlet(t.tr_ob, t.tr_outno))
{
count[t.tr_inno] = 1;
}
}
dsp->d_vectors[0] = (t_int)x;
dsp->d_vectors[1] = (t_int)dsp;
dsp->d_vectors[2] = (t_int)sp[0]->s_n;
dsp->d_vectors[3] = (t_int)dsp->d_flags;
dsp->d_vectors[4] = (t_int)dsp->d_user_param;
dsp->d_vectors[5] = (t_int)nins;
dsp->d_vectors[6] = (t_int)nouts;
for(i = 7; i < dsp->d_size; i++)
{
if(sp[i - 7] && sp[i - 7]->s_vec)
{
dsp->d_vectors[i] = (t_int)(sp[i - 7]->s_vec);
}
else
{
free(count);
free(dsp->d_vectors);
dsp->d_vectors = NULL;
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "one of the signal isn't allocated.");
return;
}
}
c->c_widget.w_dsp(x, x, count, sp[0]->s_sr, sp[0]->s_n, 0);
if(dsp->d_perform_method != NULL && dsp->d_misc == E_INPLACE)
{
dsp_addv(eobj_perform_inplace, (int)dsp->d_size, dsp->d_vectors);
}
else if(dsp->d_perform_method != NULL && dsp->d_misc == E_NO_INPLACE)
{
dsp_addv(eobj_perform_noinplace, (int)dsp->d_size, dsp->d_vectors);
}
free(count);
return;
}
else
{
free(dsp->d_vectors);
dsp->d_vectors = NULL;
free(dsp->d_sigs_real);
dsp->d_sigs_real = NULL;
free(dsp->d_sigs_out);
dsp->d_sigs_out = NULL;
dsp->d_size = 0;
pd_error(x, "can't allocate memory for dsp chain counter.");
}
}
}