Added breakpoint and breakpoints to tof externals

svn path=/trunk/externals/tof/; revision=9639

6 files changed, 2236 insertions, 0 deletions

diff --git a/src/Makefile b/src/Makefile
new file mode 100755
index 0000000..cf2829c
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,61 @@
+current:

+	echo make pd_linux, pd_win, or pd_darwin

+

+clean: ; rm -f *.pd_linux *.o

+

+# ----------------------- WINDOWS -----------------------

+

+pd_win: breakpoints.dll breakpoints~.dll destroysend.dll folderpanel.dll getdollarzero.dll

+

+.SUFFIXES: .dll

+

+WINCFLAGS = -Wall -W -Wshadow -Wstrict-prototypes -DPD -DNT -W3 -WX -Wno-unused -mms-bitfields -Wno-parentheses -Wno-switch -O6 -funroll-loops -fomit-frame-pointer

+

+WINPDPATH = /d/pd/bin

+

+WININCLUDE =  -I.. -I../include -I$(WINPDPATH)/src

+

+LDFLAGS = -shared

+

+.c.dll:

+	gcc -mms-bitfields $(WINCFLAGS) $(WININCLUDE) -o $*.o -c $*.c

+	gcc $(LDFLAGS) -o $*.dll $*.o $(WINPDPATH)/bin/pd.dll 	

+	strip --strip-unneeded $*.dll

+	rm -f $*.o

+	

+

+

+# ----------------------- LINUX i386 -----------------------

+

+pd_linux: breakpoints.pd_linux breakpoints~.pd_linux destroysend.pd_linux folderpanel.pd_linux getdollarzero.pd_linux

+

+.SUFFIXES: .pd_linux

+

+PDPATH = /home/tom/pd/cvs/pd

+

+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \

+    -Wall -W -Wshadow -Wstrict-prototypes  \

+    -Wno-unused -Wno-parentheses -Wno-switch

+

+LINUXINCLUDE =  -I$(PDPATH)/src

+

+.c.pd_linux:

+	cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c

+	ld -export_dynamic  -shared -o $*.pd_linux $*.o -lc -lm

+	strip --strip-unneeded $*.pd_linux

+	rm $*.o

+

+# ----------------------- Mac OSX -----------------------

+

+pd_darwin: breakpoints~.pd_darwin breakpoints.pd_darwin destroysend.pd_darwin folderpanel.pd_darwin getdollarzero.pd_darwin

+

+.SUFFIXES: .pd_darwin

+

+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \

+    -Wno-unused -Wno-parentheses -Wno-switch

+

+.c.pd_darwin:

+	cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c

+	cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o 

+	rm -f $*.o

+

diff --git a/src/breakpoints.c b/src/breakpoints.c
new file mode 100755
index 0000000..d98753d
--- /dev/null
+++ b/src/breakpoints.c
@@ -0,0 +1,449 @@
+/* (C) Guenter Geiger <geiger@epy.co.at> */

+

+#include <m_pd.h>

+

+//#define DEBUG

+/* ------------------------ breakpoints~ ----------------------------- */

+

+#define NONE    0

+#define ATTACK  1

+#define SUSTAIN -1 

+#define STATES  100

+

+

+

+#include "breakpoints~.h"

+

+#define BACKGROUNDWIDTH "1"

+#include "w_breakpoints.h"

+

+static t_class *breakpoints_class;

+

+

+#define OUT_LIST(x,nr,a) \

+     outlet_list(x->x_obj.ob_outlet,&s_list,nr,(t_atom*)&a);\

+     if (x->s_sym != &s_ && x->s_sym->s_thing) pd_list(x->s_sym->s_thing, &s_list, nr, (t_atom*)&a);

+

+

+char dumpy[2000];

+

+/* initialize envelope with argument vector */

+

+#include <stdio.h>

+

+/* 

+   breakpoints crashes frequently when reallocating memory ....

+   I really don't know why, it crashes during resizebytes,

+   which means it is unable to realloc() the memory ?????

+   the pointer seems to be ok, I don't know what else could

+   cause the problem. for the moment we prevent from reallocating

+   by setting the STATES variable to 100 */

+

+void breakpoints_resize(t_breakpoints* x,int ns)

+{

+     if (ns > x->args) {

+	  int newargs = ns*sizeof(t_float); 

+

+	  x->duration = resizebytes(x->duration,x->args*sizeof(t_float),newargs);

+	  x->finalvalues = resizebytes(x->finalvalues,x->args*sizeof(t_float),newargs);

+	  x->args = ns;  

+     }

+}

+

+

+

+void breakpoints_totaldur(t_breakpoints* x,t_float dur)

+{

+     int i;

+     float f = dur/x->duration[x->last_state];

+

+     if (dur < 10) {

+	post("breakpoints: duration too small %f",dur);

+        return;

+     }

+

+     for (i=1;i<=x->last_state;i++)

+	  x->duration[i]*=f;

+}

+

+

+static void breakpoints_dump(t_breakpoints* e)

+{

+     t_atom argv[50];

+     int argc= 0;

+     t_atom* a = argv;

+     int i;

+

+     SETFLOAT(a,e->finalvalues[0]);argc++;

+     for (i=1;i <= e->last_state;i++) {

+	  SETFLOAT(argv+argc,e->duration[i] - e->duration[i-1]);

+	  argc++;

+	  SETFLOAT(argv+argc,e->finalvalues[i]);

+	  argc++;

+     }

+     outlet_list(e->out2,&s_list,argc,(t_atom*)&argv);

+     if (e->d_sym != &s_) pd_list(e->d_sym->s_thing, &s_list, argc, argv);

+     //pd_float(x->s_sym->s_thing, val);

+     //EXTERN void pd_float(t_pd *x, t_float f);

+     //EXTERN void outlet_list(t_outlet *x, t_symbol *s, int argc, t_atom *argv);

+     //EXTERN void pd_list(t_pd *x, t_symbol *s, int argc, t_atom *argv);

+     /////////////////////////////////////////////////////

+}

+

+void breakpoints_init(t_breakpoints *x,int argc,t_atom* argv)

+{

+     t_float* dur;

+     t_float* val;

+     t_float tdur = 0;

+

+     if (!argc) return;

+

+     x->duration[0] = 0;

+

+     x->last_state = argc>>1;

+     breakpoints_resize(x,argc>>1);

+

+     dur = x->duration;

+     val = x->finalvalues;

+     

+     // get the first value

+     if (argc) {

+      *val = atom_getfloat(argv++);

+      *dur = 0.0;

+      x->max = *val;

+      x->min = *val;

+     }

+     dur++;val++;argc--;

+     // get the following

+     for (;argc > 0;argc--) {

+	  tdur += atom_getfloat(argv++);

+#ifdef DEBUG

+	  post("dur =%f",tdur);

+#endif

+	  *dur++ = tdur; 

+	  argc--;

+	  if (argc > 0) {

+	       *val = atom_getfloat(argv++); 

+	       if (*val > x->max ) x->max = *val;

+	       if (*val < x->min ) x->min = *val;

+	       *val++;

+	   } else {

+	       *val = 0; 

+	       if (*val > x->max ) x->max = *val;

+	       if (*val < x->min ) x->min = *val;

+	       *val++;

+	   }

+#ifdef DEBUG

+	  post("val =%f",*(val-1));

+#endif

+

+     }

+     

+     

+     

+     if ( x->max == x->min ) {

+        if ( x->max == 0 ) {

+          x->max = 1;

+        } else {

+          if (x->max > 0) {

+            x->min = 0;

+          } else {

+            x->max = 0;

+          }

+        }

+     }

+

+}

+

+

+

+

+

+void breakpoints_list(t_breakpoints *x,t_symbol* s, int argc,t_atom* argv)

+{

+     breakpoints_init(x,argc,argv);

+     if (glist_isvisible(x->w.glist)) {

+	  breakpoints_drawme(x, x->w.glist, 0);

+     }

+}

+

+void breakpoints_setresize(t_breakpoints *x, t_floatarg f)

+{

+     x->resizeable = f;

+}

+

+

+

+

+

+void breakpoints_float(t_breakpoints *x, t_floatarg f)

+{

+     int state = 0;

+     float val;

+     

+     

+

+     while (x->duration[state] < f && state <  x->last_state) state++;

+

+     if (state == 0 || f >= x->duration[x->last_state]) {

+        val = x->finalvalues[state];

+        outlet_float(x->x_obj.ob_outlet,val);

+        if (x->s_sym != &s_) pd_float(x->s_sym->s_thing, f);

+	  return;

+     }

+

+     val = x->finalvalues[state-1] + 

+		  (f - x->duration[state-1])*

+		  (x->finalvalues[state] - x->finalvalues[state-1])/ 

+		  (x->duration[state] - x->duration[state-1]);

+

+     //val *= (x->max - x->min);

+     outlet_float(x->x_obj.ob_outlet,val);

+     if (x->s_sym != &s_) pd_float(x->s_sym->s_thing, val);

+}

+

+

+

+void breakpoints_bang(t_breakpoints *x)

+{

+     t_atom   a[2];

+

+     SETFLOAT(a,x->finalvalues[NONE]);

+     SETFLOAT(a+1,0);

+

+     OUT_LIST(x,2,a);

+

+    // we don't force the first value anymore, so the first value

+       //is actually with what we have left off at the end ...

+       //this reduces clicks

+

+     x->x_state = ATTACK;

+     x->x_val = x->finalvalues[NONE];

+

+     SETFLOAT(a,x->finalvalues[x->x_state]);

+     SETFLOAT(a+1,x->duration[x->x_state]);

+

+     OUT_LIST(x,2,a);

+     clock_delay(x->x_clock,x->duration[x->x_state]);

+}

+

+/*

+

+void breakpoints_release(t_breakpoints* x) {

+     t_atom a[2];

+     float del = x->duration[x->x_state] - x->duration[x->x_state-1];

+     if (x->x_state <= x->sustain_state) {

+	x->x_state = x->sustain_state+1; // skip sustain state

+     	clock_delay(x->x_clock,del);

+        SETFLOAT(a,x->finalvalues[x->x_state]*(x->max-x->min));

+        SETFLOAT(a+1,del);

+        OUT_LIST(x,2,a);

+     }

+}

+

+static void breakpoints_sustain(t_breakpoints *x, t_floatarg f)

+{

+     if (f > 0 && f < x->last_state) 

+        x->sustain_state = f;

+     else

+		 pd_error(x,"sustain value not betweem 0 and %f, ignoring message", x->last_state);

+}

+

+*/

+

+

+static void breakpoints_tick(t_breakpoints* x)

+{

+     t_atom a[2];

+     x->x_state++;

+     if (x->x_state <= x->last_state && x->x_state != x->sustain_state) {

+	  float del = x->duration[x->x_state] - x->duration[x->x_state-1];

+	  clock_delay(x->x_clock,del);

+	  SETFLOAT(a,x->finalvalues[x->x_state]);

+	  SETFLOAT(a+1,del);

+	  OUT_LIST(x,2,a);

+     }

+//     else

+//	  clock_unset(x->x_clock);

+}

+

+

+

+/*

+static void breakpoints_freeze(t_breakpoints* x, t_floatarg f)

+{

+     x->x_freeze = f;

+}

+*/

+

+static void bindsym(t_pd* x,t_symbol* o,t_symbol* s)

+{

+     if (o != &s_) pd_unbind(x,o);

+     o = s;

+     pd_bind(x,s);

+}

+

+

+

+

+  

+

+

+

+

+static void *breakpoints_new(t_symbol *s,int argc,t_atom* argv)

+{

+     t_breakpoints *x = (t_breakpoints *)pd_new(breakpoints_class);

+     

+     

+     

+     x->x_f = 0;

+     x->args = STATES;

+     x->finalvalues = getbytes( x->args*sizeof(t_float));

+     x->duration = getbytes( x->args*sizeof(t_float));

+#ifdef DEBUG

+     post("finalvalues %x",x->finalvalues);

+#endif

+     /* widget */

+     

+     x->w.grabbed = 0;

+     x->resizing = 0;

+     x->resizeable = 0;

+     x->w.glist = (t_glist*) canvas_getcurrent();

+     

+     x->w.width = 200;

+     if (argc) x->w.width = atom_getfloat(argv++),argc--;

+     x->w.height = 140;

+     if (argc) x->w.height = atom_getfloat(argv++),argc--;

+     

+     t_float initialDuration = 100;

+     if (argc) initialDuration = atom_getfloat(argv++),argc--;

+

+     x->r_sym = &s_;

+     if (argc) {

+       t_symbol* n;

+

+       n = atom_getsymbol(argv++);

+       bindsym(&x->x_obj.ob_pd,x->r_sym,n);

+       x->r_sym = n;

+       argc--;

+     }

+     #ifdef DEBUG

+     post("recv %s",x->r_sym->s_name);

+#endif

+     x->s_sym = &s_;

+     if (argc) x->s_sym = atom_getsymbol(argv++),argc--;

+     #ifdef DEBUG

+     post("send %s",x->s_sym->s_name);

+     #endif

+     x->d_sym = &s_;

+     if (argc) x->d_sym = atom_getsymbol(argv++),argc--;

+     #ifdef DEBUG

+     post("send %s",x->d_sym->s_name);

+     #endif 

+      

+      x->c_sym = &s_;

+     if (argc) x->c_sym = atom_getsymbol(argv++),argc--;

+     #ifdef DEBUG

+     post("change %s",x->d_sym->s_name);

+     #endif 

+      

+     if (argc>2)

+	  breakpoints_init(x,argc,argv);

+     else {

+	  t_atom a[5];

+	  SETFLOAT(a,0);

+	  SETFLOAT(a+1,50);

+	  SETFLOAT(a+2,1);

+	  SETFLOAT(a+3,50);

+	  SETFLOAT(a+4,0);

+	  breakpoints_init(x,5,a);

+     }	 

+     

+     x->x_val = 0.0;

+     x->x_state = NONE;

+     x->sustain_state = SUSTAIN;

+     x->x_freeze = 0;

+     

+     

+    breakpoints_totaldur(x,initialDuration);

+     

+     

+     //outlet_new(&x->x_obj, gensym("signal"));

+     outlet_new(&x->x_obj, &s_float);

+     x->out2 = outlet_new(&x->x_obj, &s_float);

+     x->out3 = outlet_new(&x->x_obj, &s_bang);

+     

+     x->x_clock = clock_new(x, (t_method) breakpoints_tick);

+     return (x);

+}

+

+

+void breakpoints_motion(t_breakpoints *x, t_floatarg dx, t_floatarg dy);

+void breakpoints_click(t_breakpoints *x,

+    t_floatarg xpos, t_floatarg ypos, t_floatarg shift, t_floatarg ctrl,

+    t_floatarg alt);

+void breakpoints_key(t_breakpoints *x, t_floatarg f);

+

+t_widgetbehavior breakpoints_widgetbehavior;

+

+

+static void breakpoints_free(t_breakpoints *x) {

+       

+     

+     if (x->r_sym != &s_)  pd_unbind(&x->x_obj.ob_pd, x->r_sym);

+     

+}

+

+void breakpoints_setup(void)

+{

+    breakpoints_class = class_new(gensym("breakpoints"), (t_newmethod)breakpoints_new, (t_method)breakpoints_free,

+    	sizeof(t_breakpoints), 0,A_GIMME,0);

+

+   //CLASS_MAINSIGNALIN(breakpoints_class, t_breakpoints, x_f);

+    	/* here we tell Pd about the "dsp" method, which is called back

+	when DSP is turned on. */

+    //class_addmethod(breakpoints_class, (t_method)breakpointssig_dsp, gensym("dsp"), 0);

+

+

+    //class_addcreator((t_newmethod)breakpoints_new,gensym("breakpoints~"),A_GIMME,0);

+    

+    class_addfloat(breakpoints_class, breakpoints_float);

+

+    class_addbang(breakpoints_class,breakpoints_bang);

+    class_addlist(breakpoints_class,breakpoints_list);

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_sustain,gensym("sustain"),A_FLOAT,A_NULL);

+

+    class_addmethod(breakpoints_class, (t_method)breakpoints_motion, gensym("motion"),A_FLOAT, A_FLOAT, 0);

+    class_addmethod(breakpoints_class, (t_method)breakpoints_key, gensym("key"),

+    	A_FLOAT, 0);

+

+    class_addmethod(breakpoints_class,(t_method)breakpoints_totaldur,gensym("duration"),A_FLOAT,NULL);

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_freeze,gensym("freeze"),A_FLOAT,NULL);

+    class_addmethod(breakpoints_class,(t_method)breakpoints_setresize,gensym("resize"),A_FLOAT,A_NULL);

+

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_release,gensym("release"),A_NULL);

+    breakpoints_widgetbehavior.w_getrectfn =   breakpoints_getrect;

+    breakpoints_widgetbehavior.w_displacefn =    breakpoints_displace;

+    breakpoints_widgetbehavior.w_selectfn = breakpoints_select;

+    breakpoints_widgetbehavior.w_activatefn =   breakpoints_activate;

+    breakpoints_widgetbehavior.w_deletefn =   breakpoints_delete;

+    breakpoints_widgetbehavior.w_visfn =   breakpoints_vis;

+    breakpoints_widgetbehavior.w_clickfn = (t_clickfn) breakpoints_newclick;

+    //breakpoints_widgetbehavior.w_clickfn = NULL;

+#if PD_MINOR_VERSION < 37

+    breakpoints_widgetbehavior.w_propertiesfn = NULL;

+    //breakpoints_widgetbehavior.w_savefn =   breakpoints_save;

+    breakpoints_widgetbehavior.w_savefn =  NULL;

+#endif

+

+    class_setwidget(breakpoints_class,&breakpoints_widgetbehavior);

+#if PD_MINOR_VERSION >= 37

+    //class_setsavefn(breakpoints_class,&breakpoints_save);

+#endif

+    class_addmethod(breakpoints_class,(t_method)breakpoints_dump,gensym("dump"),A_NULL);

+

+

+}

+

+

diff --git a/src/breakpoints~.c b/src/breakpoints~.c
new file mode 100755
index 0000000..b7135b2
--- /dev/null
+++ b/src/breakpoints~.c
@@ -0,0 +1,479 @@
+/* (C) Guenter Geiger <geiger@epy.co.at> */

+

+#include <m_pd.h>

+

+//#define DEBUG

+/* ------------------------ breakpoints~ ----------------------------- */

+

+#define NONE    0

+#define ATTACK  1

+#define SUSTAIN -1 

+#define STATES  100

+

+

+

+#include "breakpoints~.h"

+

+#define BACKGROUNDWIDTH "2"

+#include "w_breakpoints.h"

+

+static t_class *breakpoints_class;

+

+

+#define OUT_LIST(x,nr,a) \

+     outlet_list(x->x_obj.ob_outlet,&s_list,nr,(t_atom*)&a);\

+     if (x->s_sym != &s_ && x->s_sym->s_thing) pd_list(x->s_sym->s_thing, &s_list, nr, (t_atom*)&a);

+

+

+char dumpy[2000];

+

+/* initialize envelope with argument vector */

+

+#include <stdio.h>

+

+/* 

+   breakpoints crashes frequently when reallocating memory ....

+   I really don't know why, it crashes during resizebytes,

+   which means it is unable to realloc() the memory ?????

+   the pointer seems to be ok, I don't know what else could

+   cause the problem. for the moment we prevent from reallocating

+   by setting the STATES variable to 100 */

+

+void breakpoints_resize(t_breakpoints* x,int ns)

+{

+     if (ns > x->args) {

+	  int newargs = ns*sizeof(t_float); 

+

+	  x->duration = resizebytes(x->duration,x->args*sizeof(t_float),newargs);

+	  x->finalvalues = resizebytes(x->finalvalues,x->args*sizeof(t_float),newargs);

+	  x->args = ns;  

+     }

+}

+

+ /* this is the actual performance routine which acts on the samples.

+    It's called with a single pointer "w" which is our location in the

+    DSP call list.  We return a new "w" which will point to the next item

+    after us.  Meanwhile, w[0] is just a pointer to dsp-perform itself

+    (no use to us), w[1] and w[2] are the input and output vector locations,

+    and w[3] is the number of points to calculate. */

+static t_int *breakpointssig_perform(t_int *w)

+{

+	

+	t_breakpoints *x = (t_breakpoints *)(w[1]);

+    t_float *in = (t_float *)(w[2]);

+    t_float *out = (t_float *)(w[3]);

+    int n = (int)(w[4]);

+    

+    int state; 

+    float f;

+    float val;

+    

+    while (n--)

+    {

+    	

+    	 // STUFF

+    state = 0;

+    f = *(in++);

+     

+     while (x->duration[state] < f && state <  x->last_state) state++;

+

+     if (state == 0 || f >= x->duration[x->last_state]) {

+          val = x->finalvalues[state];

+          

+	  } else {

+       val = x->finalvalues[state-1] + (f - x->duration[state-1]) *

+		  (x->finalvalues[state] - x->finalvalues[state-1]) / 

+		  (x->duration[state] - x->duration[state-1]);

+         

+     

+     

+ }

+     // STUFF END

+    	

+    	

+	*out++ = val;

+    }

+    return (w+5);

+}

+

+

+

+    /* called to start DSP.  Here we call Pd back to add our perform

+    routine to a linear callback list which Pd in turn calls to grind

+    out the samples. */

+static void breakpointssig_dsp(t_breakpoints *x, t_signal **sp)

+{

+    dsp_add(breakpointssig_perform, 4, x,sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);

+}

+

+void breakpoints_totaldur(t_breakpoints* x,t_float dur)

+{

+     int i;

+     float f = dur/x->duration[x->last_state];

+

+     if (dur < 10) {

+	post("breakpoints: duration too small %f",dur);

+        return;

+     }

+

+     for (i=1;i<=x->last_state;i++)

+	  x->duration[i]*=f;

+}

+

+

+static void breakpoints_dump(t_breakpoints* e)

+{

+     t_atom argv[50];

+     int argc= 0;

+     t_atom* a = argv;

+     int i;

+

+     SETFLOAT(a,e->finalvalues[0]);argc++;

+     for (i=1;i <= e->last_state;i++) {

+	  SETFLOAT(argv+argc,e->duration[i] - e->duration[i-1]);

+	  argc++;

+	  SETFLOAT(argv+argc,e->finalvalues[i]);

+	  argc++;

+     }

+     outlet_list(e->out2,&s_list,argc,(t_atom*)&argv);

+     if (e->d_sym != &s_) pd_list(e->d_sym->s_thing, &s_list, argc, argv);

+     //pd_float(x->s_sym->s_thing, val);

+     //EXTERN void pd_float(t_pd *x, t_float f);

+     //EXTERN void outlet_list(t_outlet *x, t_symbol *s, int argc, t_atom *argv);

+     //EXTERN void pd_list(t_pd *x, t_symbol *s, int argc, t_atom *argv);

+     /////////////////////////////////////////////////////

+}

+

+void breakpoints_init(t_breakpoints *x,int argc,t_atom* argv)

+{

+     t_float* dur;

+     t_float* val;

+     t_float tdur = 0;

+

+     if (!argc) return;

+

+     x->duration[0] = 0;

+

+     x->last_state = argc>>1;

+     breakpoints_resize(x,argc>>1);

+

+     dur = x->duration;

+     val = x->finalvalues;

+     

+     // get the first value

+     if (argc) {

+      *val = atom_getfloat(argv++);

+      *dur = 0.0;

+      x->max = *val;

+      x->min = *val;

+     }

+     dur++;val++;argc--;

+     // get the following

+     for (;argc > 0;argc--) {

+	  tdur += atom_getfloat(argv++);

+#ifdef DEBUG

+	  post("dur =%f",tdur);

+#endif

+	  *dur++ = tdur; 

+	  argc--;

+	  if (argc > 0) {

+	       *val = atom_getfloat(argv++); 

+	       if (*val > x->max ) x->max = *val;

+	       if (*val < x->min ) x->min = *val;

+	       *val++;

+	   } else {

+	       *val = 0; 

+	       if (*val > x->max ) x->max = *val;

+	       if (*val < x->min ) x->min = *val;

+	       *val++;

+	   }

+#ifdef DEBUG

+	  post("val =%f",*(val-1));

+#endif

+

+     }

+     

+         if ( x->max == x->min ) {

+        if ( x->max == 0 ) {

+          x->max = 1;

+        } else {

+          if (x->max > 0) {

+            x->min = 0;

+          } else {

+            x->max = 0;

+          }

+        }

+     }

+

+}

+

+

+

+

+

+void breakpoints_list(t_breakpoints *x,t_symbol* s, int argc,t_atom* argv)

+{

+     breakpoints_init(x,argc,argv);

+     if (glist_isvisible(x->w.glist)) {

+	  breakpoints_drawme(x, x->w.glist, 0);

+     }

+}

+

+void breakpoints_setresize(t_breakpoints *x, t_floatarg f)

+{

+     x->resizeable = f;

+}

+

+

+

+

+

+void breakpoints_float(t_breakpoints *x, t_floatarg f)

+{

+     int state = 0;

+     float val;

+     

+     

+

+     while (x->duration[state] < f && state <  x->last_state) state++;

+

+     if (state == 0 || f >= x->duration[x->last_state]) {

+          val = x->finalvalues[state]*(x->max-x->min);

+	  outlet_float(x->x_obj.ob_outlet,f);

+	  if (x->s_sym != &s_) pd_float(x->s_sym->s_thing, f);

+	  return;

+     }

+

+     val = x->finalvalues[state-1] + 

+		  (f - x->duration[state-1])*

+		  (x->finalvalues[state] - x->finalvalues[state-1])/ 

+		  (x->duration[state] - x->duration[state-1]);

+

+     val *= (x->max - x->min);

+     outlet_float(x->x_obj.ob_outlet,val);

+     if (x->s_sym != &s_) pd_float(x->s_sym->s_thing, val);

+}

+

+

+

+

+

+

+/*

+

+void breakpoints_release(t_breakpoints* x) {

+     t_atom a[2];

+     float del = x->duration[x->x_state] - x->duration[x->x_state-1];

+     if (x->x_state <= x->sustain_state) {

+	x->x_state = x->sustain_state+1; // skip sustain state

+     	clock_delay(x->x_clock,del);

+        SETFLOAT(a,x->finalvalues[x->x_state]*(x->max-x->min));

+        SETFLOAT(a+1,del);

+        OUT_LIST(x,2,a);

+     }

+}

+

+static void breakpoints_sustain(t_breakpoints *x, t_floatarg f)

+{

+     if (f > 0 && f < x->last_state) 

+        x->sustain_state = f;

+     else

+		 pd_error(x,"sustain value not betweem 0 and %f, ignoring message", x->last_state);

+}

+

+*/

+

+/*

+static void breakpoints_tick(t_breakpoints* x)

+{

+     t_atom a[2];

+     x->x_state++;

+     if (x->x_state <= x->last_state && x->x_state != x->sustain_state) {

+	  float del = x->duration[x->x_state] - x->duration[x->x_state-1];

+	  clock_delay(x->x_clock,del);

+	  SETFLOAT(a,x->finalvalues[x->x_state]*(x->max-x->min));

+	  SETFLOAT(a+1,del);

+	  OUT_LIST(x,2,a);

+     }

+//     else

+//	  clock_unset(x->x_clock);

+}

+

+*/

+

+/*

+static void breakpoints_freeze(t_breakpoints* x, t_floatarg f)

+{

+     x->x_freeze = f;

+}

+*/

+

+static void bindsym(t_pd* x,t_symbol* o,t_symbol* s)

+{

+     if (o != &s_) pd_unbind(x,o);

+     o = s;

+     pd_bind(x,s);

+}

+

+

+

+

+

+

+

+

+static void *breakpoints_new(t_symbol *s,int argc,t_atom* argv)

+{

+     t_breakpoints *x = (t_breakpoints *)pd_new(breakpoints_class);

+     

+     

+     

+     x->x_f = 0;

+     x->args = STATES;

+     x->finalvalues = getbytes( x->args*sizeof(t_float));

+     x->duration = getbytes( x->args*sizeof(t_float));

+#ifdef DEBUG

+     post("finalvalues %x",x->finalvalues);

+#endif

+     /* widget */

+     

+     x->w.grabbed = 0;

+     x->resizing = 0;

+     x->resizeable = 0;

+     x->w.glist = (t_glist*) canvas_getcurrent();

+     

+     x->w.width = 200;

+     if (argc) x->w.width = atom_getfloat(argv++),argc--;

+     x->w.height = 140;

+     if (argc) x->w.height = atom_getfloat(argv++),argc--;

+     

+     t_float initialDuration = 100;

+     if (argc) initialDuration = atom_getfloat(argv++),argc--;

+         

+     x->r_sym = &s_;

+     if (argc) {

+       t_symbol* n;

+

+       n = atom_getsymbol(argv++);

+       bindsym(&x->x_obj.ob_pd,x->r_sym,n);

+       x->r_sym = n;

+       argc--;

+     }

+     #ifdef DEBUG

+     post("recv %s",x->r_sym->s_name);

+     #endif

+     /*

+     x->s_sym = &s_;

+     if (argc) x->s_sym = atom_getsymbol(argv++),argc--;

+     #ifdef DEBUG

+     post("send %s",x->s_sym->s_name);

+     #endif

+     */

+     x->d_sym = &s_;

+     if (argc) x->d_sym = atom_getsymbol(argv++),argc--;

+     #ifdef DEBUG

+     post("dump %s",x->d_sym->s_name);

+     #endif 

+     

+     x->c_sym = &s_;

+     if (argc) x->c_sym = atom_getsymbol(argv++),argc--;

+     

+     if (argc>2)

+	  breakpoints_init(x,argc,argv);

+     else {

+	  t_atom a[5];

+	  SETFLOAT(a,0);

+	  SETFLOAT(a+1,50);

+	  SETFLOAT(a+2,1);

+	  SETFLOAT(a+3,50);

+	  SETFLOAT(a+4,0);

+	  breakpoints_init(x,5,a);

+     }	 

+     

+     x->x_val = 0.0;

+     x->x_state = NONE;

+     x->sustain_state = SUSTAIN;

+     x->x_freeze = 0;

+     

+     breakpoints_totaldur(x,initialDuration);

+     

+     outlet_new(&x->x_obj, gensym("signal"));

+     //outlet_new(&x->x_obj, &s_float);

+     x->out2 = outlet_new(&x->x_obj, &s_float);

+     x->out3 = outlet_new(&x->x_obj, &s_bang);

+     

+     //x->x_clock = clock_new(x, (t_method) breakpoints_tick);

+     return (x);

+}

+

+

+

+

+void breakpoints_motion(t_breakpoints *x, t_floatarg dx, t_floatarg dy);

+void breakpoints_click(t_breakpoints *x,

+    t_floatarg xpos, t_floatarg ypos, t_floatarg shift, t_floatarg ctrl,

+    t_floatarg alt);

+void breakpoints_key(t_breakpoints *x, t_floatarg f);

+

+t_widgetbehavior breakpoints_widgetbehavior;

+

+

+

+static void breakpoints_free(t_breakpoints *x) {

+       

+     

+     if (x->r_sym != &s_)  pd_unbind(&x->x_obj.ob_pd, x->r_sym);

+     

+}

+

+void breakpoints_tilde_setup(void)

+{

+    breakpoints_class = class_new(gensym("breakpoints~"), (t_newmethod)breakpoints_new, (t_method)breakpoints_free,

+    	sizeof(t_breakpoints), 0,A_GIMME,0);

+

+   CLASS_MAINSIGNALIN(breakpoints_class, t_breakpoints, x_f);

+    	/* here we tell Pd about the "dsp" method, which is called back

+	when DSP is turned on. */

+    class_addmethod(breakpoints_class, (t_method)breakpointssig_dsp, gensym("dsp"), 0);

+

+

+    //class_addcreator((t_newmethod)breakpoints_new,gensym("breakpoints~"),A_GIMME,0);

+    //class_addfloat(breakpoints_class, breakpoints_float);

+

+    //class_addbang(breakpoints_class,breakpoints_bang);

+    class_addlist(breakpoints_class,breakpoints_list);

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_sustain,gensym("sustain"),A_FLOAT,A_NULL);

+

+    class_addmethod(breakpoints_class, (t_method)breakpoints_motion, gensym("motion"),A_FLOAT, A_FLOAT, 0);

+    class_addmethod(breakpoints_class, (t_method)breakpoints_key, gensym("key"),

+    	A_FLOAT, 0);

+

+    class_addmethod(breakpoints_class,(t_method)breakpoints_totaldur,gensym("duration"),A_FLOAT,NULL);

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_freeze,gensym("freeze"),A_FLOAT,NULL);

+    class_addmethod(breakpoints_class,(t_method)breakpoints_setresize,gensym("resize"),A_FLOAT,A_NULL);

+

+    //class_addmethod(breakpoints_class,(t_method)breakpoints_release,gensym("release"),A_NULL);

+    breakpoints_widgetbehavior.w_getrectfn =   breakpoints_getrect;

+    breakpoints_widgetbehavior.w_displacefn =    breakpoints_displace;

+    breakpoints_widgetbehavior.w_selectfn = breakpoints_select;

+    breakpoints_widgetbehavior.w_activatefn =   breakpoints_activate;

+    breakpoints_widgetbehavior.w_deletefn =   breakpoints_delete;

+    breakpoints_widgetbehavior.w_visfn =   breakpoints_vis;

+    breakpoints_widgetbehavior.w_clickfn = (t_clickfn) breakpoints_newclick;

+    //breakpoints_widgetbehavior.w_clickfn = NULL;

+#if PD_MINOR_VERSION < 37

+    breakpoints_widgetbehavior.w_propertiesfn = NULL;

+    //breakpoints_widgetbehavior.w_savefn =   breakpoints_save;

+    breakpoints_widgetbehavior.w_savefn =  NULL;

+#endif

+

+    class_setwidget(breakpoints_class,&breakpoints_widgetbehavior);

+#if PD_MINOR_VERSION >= 37

+    //class_setsavefn(breakpoints_class,&breakpoints_save);

+#endif

+    class_addmethod(breakpoints_class,(t_method)breakpoints_dump,gensym("dump"),A_NULL);

+

+

+}

+

+

diff --git a/src/breakpoints~.h b/src/breakpoints~.h
new file mode 100755
index 0000000..27d6a6d
--- /dev/null
+++ b/src/breakpoints~.h
@@ -0,0 +1,63 @@
+#ifndef __GG_breakpoints_H__

+#define __GG_breakpoints_H__

+

+#include "g_canvas.h"

+

+typedef struct _wbreakpoints {

+     t_glist* glist;

+     int    width;

+     int    height;

+     int    numdoodles;

+     int    grabbed; /* for moving points */

+     int    shift; /* move 100th */

+     float    pointerx;

+     float    pointery;

+    

+     t_clock* numclock;

+} t_wbreakpoints;

+

+typedef struct _breakpoints

+{

+     t_object x_obj;

+

+     t_float x_val;

+     

+     int x_state;

+     int last_state;

+     int sustain_state;

+     int envchanged;

+

+     t_float* finalvalues;

+     t_float* duration;

+     t_float  totaldur;

+     t_int    args; /* get rid of that */

+     t_int resizing;

+     t_int resizeable;

+

+     t_symbol* r_sym; //receive symbol

+     t_symbol* s_sym; //send symbol

+     t_symbol* d_sym; //dump symbol

+     t_symbol* c_sym; //change symbol

+

+     t_float min;

+     t_float max;

+

+     t_clock* x_clock;

+     t_float x_freeze;

+

+      t_float x_f;    	/* place to hold inlet's value if it's set by message */

+

+

+     t_outlet* out2;

+     t_outlet* out3;

+     /* widget parameters */

+     t_wbreakpoints w;

+} t_breakpoints;

+

+

+t_widgetbehavior breakpoints_widgetbehavior;

+void breakpoints_drawme(t_breakpoints *x, t_glist *glist, int firsttime);

+int breakpoints_set_values(t_breakpoints * x);

+void breakpoints_resize(t_breakpoints* x,int ns);

+

+#endif

diff --git a/src/g_canvas.h b/src/g_canvas.h
new file mode 100755
index 0000000..712aebf
--- /dev/null
+++ b/src/g_canvas.h
@@ -0,0 +1,615 @@
+/* Copyright (c) 1997-1999 Miller Puckette.

+* For information on usage and redistribution, and for a DISCLAIMER OF ALL

+* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */

+

+/* this file defines the structure for "glists" and related structures and

+functions.  "Glists" and "canvases" and "graphs" used to be different

+structures until being unified in version 0.35.

+

+A glist occupies its own window if the "gl_havewindow" flag is set.  Its

+appearance on its "parent" or "owner" (if it has one) is as a graph if

+"gl_isgraph" is set, and otherwise as a text box.

+

+A glist is "root" if it has no owner, i.e., a document window.  In this

+case "gl_havewindow" is always set.

+

+We maintain a list of root windows, so that we can traverse the whole

+collection of everything in a Pd process.

+

+If a glist has a window it may still not be "mapped."  Miniaturized

+windows aren't mapped, for example, but a window is also not mapped

+immediately upon creation.  In either case gl_havewindow is true but

+gl_mapped is false.

+

+Closing a non-root window makes it invisible; closing a root destroys it.

+

+A glist that's just a text object on its parent is always "toplevel."  An

+embedded glist can switch back and forth to appear as a toplevel by double-

+clicking on it.  Single-clicking a text box makes the toplevel become visible

+and raises the window it's in.

+

+If a glist shows up as a graph on its parent, the graph is blanked while the

+glist has its own window, even if miniaturized.

+

+*/

+

+/* NOTE: this file describes Pd implementation details which may change

+in future releases.  The public (stable) API is in m_pd.h. */  

+

+#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)

+extern "C" {

+#endif

+

+/* --------------------- geometry ---------------------------- */

+#define IOWIDTH 7       /* width of an inlet/outlet in pixels */

+#define IOMIDDLE ((IOWIDTH-1)/2)

+#define GLIST_DEFGRAPHWIDTH 200

+#define GLIST_DEFGRAPHHEIGHT 140

+/* ----------------------- data ------------------------------- */

+

+typedef struct _updateheader

+{

+    struct _updateheader *upd_next;

+    unsigned int upd_array:1;       /* true if array, false if glist */

+    unsigned int upd_queued:1;      /* true if we're queued */

+} t_updateheader;

+

+    /* types to support glists grabbing mouse motion or keys from parent */

+typedef void (*t_glistmotionfn)(void *z, t_floatarg dx, t_floatarg dy);

+typedef void (*t_glistkeyfn)(void *z, t_floatarg key);

+

+EXTERN_STRUCT _rtext;

+#define t_rtext struct _rtext

+

+EXTERN_STRUCT _gtemplate;

+#define t_gtemplate struct _gtemplate

+

+EXTERN_STRUCT _guiconnect;

+#define t_guiconnect struct _guiconnect

+

+EXTERN_STRUCT _tscalar;

+#define t_tscalar struct _tscalar

+

+EXTERN_STRUCT _canvasenvironment;

+#define t_canvasenvironment struct _canvasenvironment 

+

+EXTERN_STRUCT _fielddesc;

+#define t_fielddesc struct _fielddesc

+

+typedef struct _selection

+{

+    t_gobj *sel_what;

+    struct _selection *sel_next;

+} t_selection;

+

+    /* this structure is instantiated whenever a glist becomes visible. */

+typedef struct _editor

+{

+    t_updateheader e_upd;           /* update header structure */

+    t_selection *e_updlist;         /* list of objects to update */

+    t_rtext *e_rtext;               /* text responder linked list */

+    t_selection *e_selection;       /* head of the selection list */

+    t_rtext *e_textedfor;           /* the rtext if any that we are editing */

+    t_gobj *e_grab;                 /* object being "dragged" */

+    t_glistmotionfn e_motionfn;     /* ... motion callback */

+    t_glistkeyfn e_keyfn;           /* ... keypress callback */

+    t_binbuf *e_connectbuf;         /* connections to deleted objects */

+    t_binbuf *e_deleted;            /* last stuff we deleted */

+    t_guiconnect *e_guiconnect;     /* GUI connection for filtering messages */

+    struct _glist *e_glist;         /* glist which owns this */

+    int e_xwas;                     /* xpos on last mousedown or motion event */

+    int e_ywas;                     /* ypos, similarly */

+    int e_selectline_index1;        /* indices for the selected line if any */

+    int e_selectline_outno;         /* (only valid if e_selectedline is set) */

+    int e_selectline_index2;

+    int e_selectline_inno;

+    t_outconnect *e_selectline_tag;

+    unsigned int e_onmotion: 3;     /* action to take on motion */

+    unsigned int e_lastmoved: 1;    /* one if mouse has moved since click */

+    unsigned int e_textdirty: 1;    /* one if e_textedfor has changed */

+    unsigned int e_selectedline: 1; /* one if a line is selected */

+} t_editor;

+

+#define MA_NONE    0    /* e_onmotion: do nothing on mouse motion */

+#define MA_MOVE    1    /* drag the selection around */

+#define MA_CONNECT 2    /* make a connection */

+#define MA_REGION  3    /* selection region */

+#define MA_PASSOUT 4    /* send on to e_grab */

+#define MA_DRAGTEXT 5   /* drag in text editor to alter selection */

+

+/* editor structure for "garrays".  We don't bother to delete and regenerate

+this structure when the "garray" becomes invisible or visible, although we

+could do so if the structure gets big (like the "editor" above.) */

+    

+typedef struct _arrayvis

+{

+    t_updateheader av_upd;          /* update header structure */

+    t_garray *av_garray;            /* owning structure */    

+} t_arrayvis;

+

+/* the t_tick structure describes where to draw x and y "ticks" for a glist */

+

+typedef struct _tick    /* where to put ticks on x or y axes */

+{

+    float k_point;      /* one point to draw a big tick at */

+    float k_inc;        /* x or y increment per little tick */

+    int k_lperb;        /* little ticks per big; 0 if no ticks to draw */

+} t_tick;

+

+/* the t_glist structure, which describes a list of elements that live on an

+area of a window.

+

+*/

+

+struct _glist

+{  

+    t_object gl_obj;            /* header in case we're a glist */

+    t_gobj *gl_list;            /* the actual data */

+    struct _gstub *gl_stub;     /* safe pointer handler */

+    int gl_valid;               /* incremented when pointers might be stale */

+    struct _glist *gl_owner;    /* parent glist, supercanvas, or 0 if none */

+    int gl_pixwidth;            /* width in pixels (on parent, if a graph) */

+    int gl_pixheight;

+    float gl_x1;                /* bounding rectangle in our own coordinates */

+    float gl_y1;

+    float gl_x2;

+    float gl_y2;

+    int gl_screenx1;            /* screen coordinates when toplevel */

+    int gl_screeny1;

+    int gl_screenx2;

+    int gl_screeny2;

+    int gl_xmargin;                /* origin for GOP rectangle */

+    int gl_ymargin;

+    t_tick gl_xtick;            /* ticks marking X values */    

+    int gl_nxlabels;            /* number of X coordinate labels */

+    t_symbol **gl_xlabel;           /* ... an array to hold them */

+    float gl_xlabely;               /* ... and their Y coordinates */

+    t_tick gl_ytick;            /* same as above for Y ticks and labels */

+    int gl_nylabels;

+    t_symbol **gl_ylabel;

+    float gl_ylabelx;

+    t_editor *gl_editor;        /* editor structure when visible */

+    t_symbol *gl_name;          /* symbol bound here */

+    int gl_font;                /* nominal font size in points, e.g., 10 */

+    struct _glist *gl_next;         /* link in list of toplevels */

+    t_canvasenvironment *gl_env;    /* root canvases and abstractions only */

+    unsigned int gl_havewindow:1;   /* true if we own a window */

+    unsigned int gl_mapped:1;       /* true if, moreover, it's "mapped" */

+    unsigned int gl_dirty:1;        /* (root canvas only:) patch has changed */

+    unsigned int gl_loading:1;      /* am now loading from file */

+    unsigned int gl_willvis:1;      /* make me visible after loading */ 

+    unsigned int gl_edit:1;         /* edit mode */

+    unsigned int gl_isdeleting:1;   /* we're inside glist_delete -- hack! */

+    unsigned int gl_goprect:1;      /* draw rectangle for graph-on-parent */

+    unsigned int gl_isgraph:1;      /* show as graph on parent */

+};

+

+#define gl_gobj gl_obj.te_g

+#define gl_pd gl_gobj.g_pd

+

+/* a data structure to describe a field in a pure datum */

+

+#define DT_FLOAT 0

+#define DT_SYMBOL 1

+#define DT_LIST 2

+#define DT_ARRAY 3

+

+typedef struct _dataslot

+{

+    int ds_type;

+    t_symbol *ds_name;

+    t_symbol *ds_arraytemplate;     /* filled in for arrays only */

+} t_dataslot;

+

+typedef struct _template

+{

+    t_pd t_pdobj;               /* header */

+    struct _gtemplate *t_list;  /* list of "struct"/gtemplate objects */

+    t_symbol *t_sym;            /* name */

+    int t_n;                    /* number of dataslots (fields) */

+    t_dataslot *t_vec;          /* array of dataslots */

+} t_template;

+

+struct _array

+{

+    int a_n;            /* number of elements */

+    int a_elemsize;     /* size in bytes; LATER get this from template */

+    char *a_vec;        /* array of elements */

+    t_symbol *a_templatesym;    /* template for elements */

+    int a_valid;        /* protection against stale pointers into array */

+    t_gpointer a_gp;    /* pointer to scalar or array element we're in */

+    t_gstub *a_stub;    /* stub for pointing into this array */

+};

+

+    /* structure for traversing all the connections in a glist */

+typedef struct _linetraverser

+{

+    t_canvas *tr_x;

+    t_object *tr_ob;

+    int tr_nout;

+    int tr_outno;

+    t_object *tr_ob2;

+    t_outlet *tr_outlet;

+    t_inlet *tr_inlet;

+    int tr_nin;

+    int tr_inno;

+    int tr_x11, tr_y11, tr_x12, tr_y12;

+    int tr_x21, tr_y21, tr_x22, tr_y22;

+    int tr_lx1, tr_ly1, tr_lx2, tr_ly2;

+    t_outconnect *tr_nextoc;

+    int tr_nextoutno;

+} t_linetraverser;

+

+/* function types used to define graphical behavior for gobjs, a bit like X

+widgets.  We don't use Pd methods because Pd's typechecking can't specify the

+types of pointer arguments.  Also it's more convenient this way, since

+every "patchable" object can just get the "text" behaviors. */

+

+        /* Call this to get a gobj's bounding rectangle in pixels */

+typedef void (*t_getrectfn)(t_gobj *x, struct _glist *glist,

+    int *x1, int *y1, int *x2, int *y2);

+        /* and this to displace a gobj: */

+typedef void (*t_displacefn)(t_gobj *x, struct _glist *glist, int dx, int dy);

+        /* change color to show selection: */

+typedef void (*t_selectfn)(t_gobj *x, struct _glist *glist, int state);

+        /* change appearance to show activation/deactivation: */

+typedef void (*t_activatefn)(t_gobj *x, struct _glist *glist, int state);

+        /* warn a gobj it's about to be deleted */

+typedef void (*t_deletefn)(t_gobj *x, struct _glist *glist);

+        /*  making visible or invisible */

+typedef void (*t_visfn)(t_gobj *x, struct _glist *glist, int flag);

+        /* field a mouse click (when not in "edit" mode) */

+typedef int (*t_clickfn)(t_gobj *x, struct _glist *glist,

+    int xpix, int ypix, int shift, int alt, int dbl, int doit);

+        /* ... and later, resizing; getting/setting font or color... */

+

+struct _widgetbehavior

+{

+    t_getrectfn w_getrectfn;

+    t_displacefn w_displacefn;

+    t_selectfn w_selectfn;

+    t_activatefn w_activatefn;

+    t_deletefn w_deletefn;

+    t_visfn w_visfn;

+    t_clickfn w_clickfn;

+};

+

+/* -------- behaviors for scalars defined by objects in template --------- */

+/* these are set by "drawing commands" in g_template.c which add appearance to

+scalars, which live in some other window.  If the scalar is just included

+in a canvas the "parent" is a misnomer.  There is also a text scalar object

+which really does draw the scalar on the parent window; see g_scalar.c. */

+

+/* note how the click function wants the whole scalar, not the "data", so

+doesn't work on array elements... LATER reconsider this */

+

+        /* bounding rectangle: */

+typedef void (*t_parentgetrectfn)(t_gobj *x, struct _glist *glist,

+    t_word *data, t_template *tmpl, float basex, float basey,

+    int *x1, int *y1, int *x2, int *y2);

+        /* displace it */

+typedef void (*t_parentdisplacefn)(t_gobj *x, struct _glist *glist, 

+    t_word *data, t_template *tmpl, float basex, float basey,

+    int dx, int dy);

+        /* change color to show selection */

+typedef void (*t_parentselectfn)(t_gobj *x, struct _glist *glist,

+    t_word *data, t_template *tmpl, float basex, float basey,

+    int state);

+        /* change appearance to show activation/deactivation: */

+typedef void (*t_parentactivatefn)(t_gobj *x, struct _glist *glist,

+    t_word *data, t_template *tmpl, float basex, float basey,

+    int state);

+        /*  making visible or invisible */

+typedef void (*t_parentvisfn)(t_gobj *x, struct _glist *glist,

+    t_word *data, t_template *tmpl, float basex, float basey,

+    int flag);

+        /*  field a mouse click */

+typedef int (*t_parentclickfn)(t_gobj *x, struct _glist *glist,

+    t_word *data, t_template *tmpl, t_scalar *sc, t_array *ap,

+    float basex, float basey,

+    int xpix, int ypix, int shift, int alt, int dbl, int doit);

+

+struct _parentwidgetbehavior

+{

+    t_parentgetrectfn w_parentgetrectfn;

+    t_parentdisplacefn w_parentdisplacefn;

+    t_parentselectfn w_parentselectfn;

+    t_parentactivatefn w_parentactivatefn;

+    t_parentvisfn w_parentvisfn;

+    t_parentclickfn w_parentclickfn;

+};

+

+    /* cursor definitions; used as return value for t_parentclickfn */

+#define CURSOR_RUNMODE_NOTHING 0

+#define CURSOR_RUNMODE_CLICKME 1

+#define CURSOR_RUNMODE_THICKEN 2

+#define CURSOR_RUNMODE_ADDPOINT 3

+#define CURSOR_EDITMODE_NOTHING 4

+#define CURSOR_EDITMODE_CONNECT 5

+#define CURSOR_EDITMODE_DISCONNECT 6

+EXTERN void canvas_setcursor(t_glist *x, unsigned int cursornum);

+

+extern t_canvas *canvas_editing;    /* last canvas to start text edting */ 

+extern t_canvas *canvas_whichfind;  /* last canvas we did a find in */ 

+extern t_canvas *canvas_list;       /* list of all root canvases */

+extern t_class *vinlet_class, *voutlet_class;

+extern int glist_valid;         /* incremented when pointers might be stale */

+

+#define PLOTSTYLE_POINTS 0     /* plotting styles for arrays */

+#define PLOTSTYLE_POLY 1

+#define PLOTSTYLE_BEZ 2

+

+/* ------------------- functions on any gobj ----------------------------- */

+EXTERN void gobj_getrect(t_gobj *x, t_glist *owner, int *x1, int *y1,

+    int *x2, int *y2);

+EXTERN void gobj_displace(t_gobj *x, t_glist *owner, int dx, int dy);

+EXTERN void gobj_select(t_gobj *x, t_glist *owner, int state);

+EXTERN void gobj_activate(t_gobj *x, t_glist *owner, int state);

+EXTERN void gobj_delete(t_gobj *x, t_glist *owner);

+EXTERN void gobj_vis(t_gobj *x, t_glist *glist, int flag);

+EXTERN int gobj_click(t_gobj *x, struct _glist *glist,

+    int xpix, int ypix, int shift, int alt, int dbl, int doit);

+EXTERN void gobj_save(t_gobj *x, t_binbuf *b);

+EXTERN void gobj_properties(t_gobj *x, struct _glist *glist);

+EXTERN void gobj_save(t_gobj *x, t_binbuf *b);

+

+/* -------------------- functions on glists --------------------- */

+EXTERN t_glist *glist_new( void);

+EXTERN void glist_init(t_glist *x);

+EXTERN void glist_add(t_glist *x, t_gobj *g);

+EXTERN void glist_cleanup(t_glist *x);

+EXTERN void glist_free(t_glist *x);

+

+EXTERN void glist_clear(t_glist *x);

+EXTERN t_canvas *glist_getcanvas(t_glist *x);

+EXTERN int glist_isselected(t_glist *x, t_gobj *y);

+EXTERN void glist_select(t_glist *x, t_gobj *y);

+EXTERN void glist_deselect(t_glist *x, t_gobj *y);

+EXTERN void glist_noselect(t_glist *x);

+EXTERN void glist_selectall(t_glist *x);

+EXTERN void glist_delete(t_glist *x, t_gobj *y);

+EXTERN void glist_retext(t_glist *x, t_text *y);

+EXTERN void glist_grab(t_glist *x, t_gobj *y, t_glistmotionfn motionfn,

+    t_glistkeyfn keyfn, int xpos, int ypos);

+EXTERN int glist_isvisible(t_glist *x);

+EXTERN int glist_istoplevel(t_glist *x);

+EXTERN t_glist *glist_findgraph(t_glist *x);

+EXTERN int glist_getfont(t_glist *x);

+EXTERN void glist_sort(t_glist *canvas);

+EXTERN void glist_read(t_glist *x, t_symbol *filename, t_symbol *format);

+EXTERN void glist_mergefile(t_glist *x, t_symbol *filename, t_symbol *format);

+

+EXTERN float glist_pixelstox(t_glist *x, float xpix);

+EXTERN float glist_pixelstoy(t_glist *x, float ypix);

+EXTERN float glist_xtopixels(t_glist *x, float xval);

+EXTERN float glist_ytopixels(t_glist *x, float yval);

+EXTERN float glist_dpixtodx(t_glist *x, float dxpix);

+EXTERN float glist_dpixtody(t_glist *x, float dypix);

+

+EXTERN void glist_getnextxy(t_glist *gl, int *xval, int *yval);

+EXTERN void glist_glist(t_glist *g, t_symbol *s, int argc, t_atom *argv);

+EXTERN t_glist *glist_addglist(t_glist *g, t_symbol *sym,

+    float x1, float y1, float x2, float y2,

+    float px1, float py1, float px2, float py2);

+EXTERN void glist_arraydialog(t_glist *parent, t_symbol *name,

+    t_floatarg size, t_floatarg saveit, t_floatarg newgraph);

+EXTERN t_binbuf *glist_writetobinbuf(t_glist *x, int wholething);

+EXTERN int glist_isgraph(t_glist *x);

+EXTERN void glist_redraw(t_glist *x);

+EXTERN void glist_drawiofor(t_glist *glist, t_object *ob, int firsttime,

+    char *tag, int x1, int y1, int x2, int y2);

+EXTERN void glist_eraseiofor(t_glist *glist, t_object *ob, char *tag);

+EXTERN void canvas_create_editor(t_glist *x, int createit);

+void canvas_deletelinesforio(t_canvas *x, t_text *text,

+    t_inlet *inp, t_outlet *outp);

+

+

+/* -------------------- functions on texts ------------------------- */

+EXTERN void text_setto(t_text *x, t_glist *glist, char *buf, int bufsize);

+EXTERN void text_drawborder(t_text *x, t_glist *glist, char *tag,

+    int width, int height, int firsttime);

+EXTERN void text_eraseborder(t_text *x, t_glist *glist, char *tag);

+EXTERN int text_xcoord(t_text *x, t_glist *glist);

+EXTERN int text_ycoord(t_text *x, t_glist *glist);

+EXTERN int text_xpix(t_text *x, t_glist *glist);

+EXTERN int text_ypix(t_text *x, t_glist *glist);

+EXTERN int text_shouldvis(t_text *x, t_glist *glist);

+

+/* -------------------- functions on rtexts ------------------------- */

+#define RTEXT_DOWN 1

+#define RTEXT_DRAG 2

+#define RTEXT_DBL 3

+#define RTEXT_SHIFT 4

+

+EXTERN t_rtext *rtext_new(t_glist *glist, t_text *who);

+EXTERN t_rtext *glist_findrtext(t_glist *gl, t_text *who);

+EXTERN void rtext_draw(t_rtext *x);

+EXTERN void rtext_erase(t_rtext *x);

+EXTERN t_rtext *rtext_remove(t_rtext *first, t_rtext *x);

+EXTERN int rtext_height(t_rtext *x);

+EXTERN void rtext_displace(t_rtext *x, int dx, int dy);

+EXTERN void rtext_select(t_rtext *x, int state);

+EXTERN void rtext_activate(t_rtext *x, int state);

+EXTERN void rtext_free(t_rtext *x);

+EXTERN void rtext_key(t_rtext *x, int n, t_symbol *s);

+EXTERN void rtext_mouse(t_rtext *x, int xval, int yval, int flag);

+EXTERN void rtext_retext(t_rtext *x);

+EXTERN int rtext_width(t_rtext *x);

+EXTERN int rtext_height(t_rtext *x);

+EXTERN char *rtext_gettag(t_rtext *x);

+EXTERN void rtext_gettext(t_rtext *x, char **buf, int *bufsize);

+EXTERN void rtext_getseltext(t_rtext *x, char **buf, int *bufsize);

+

+/* -------------------- functions on canvases ------------------------ */

+EXTERN t_class *canvas_class;

+

+EXTERN t_canvas *canvas_new(void *dummy, t_symbol *sel, int argc, t_atom *argv);

+EXTERN t_symbol *canvas_makebindsym(t_symbol *s);

+EXTERN void canvas_vistext(t_canvas *x, t_text *y);

+EXTERN void canvas_fixlinesfor(t_canvas *x, t_text *text);

+EXTERN void canvas_deletelinesfor(t_canvas *x, t_text *text);

+EXTERN void canvas_stowconnections(t_canvas *x);

+EXTERN void canvas_restoreconnections(t_canvas *x);

+EXTERN void canvas_redraw(t_canvas *x);

+

+EXTERN t_inlet *canvas_addinlet(t_canvas *x, t_pd *who, t_symbol *sym);

+EXTERN void canvas_rminlet(t_canvas *x, t_inlet *ip);

+EXTERN t_outlet *canvas_addoutlet(t_canvas *x, t_pd *who, t_symbol *sym);

+EXTERN void canvas_rmoutlet(t_canvas *x, t_outlet *op);

+EXTERN void canvas_redrawallfortemplate(t_template *tmpl, int action);

+EXTERN void canvas_redrawallfortemplatecanvas(t_canvas *x, int action);

+EXTERN void canvas_zapallfortemplate(t_canvas *tmpl);

+EXTERN void canvas_setusedastemplate(t_canvas *x);

+EXTERN t_canvas *canvas_getcurrent(void);

+EXTERN void canvas_setcurrent(t_canvas *x);

+EXTERN void canvas_unsetcurrent(t_canvas *x);

+EXTERN t_symbol *canvas_realizedollar(t_canvas *x, t_symbol *s);

+EXTERN t_canvas *canvas_getrootfor(t_canvas *x);

+EXTERN void canvas_dirty(t_canvas *x, t_int n);

+EXTERN int canvas_getfont(t_canvas *x);

+typedef int (*t_canvasapply)(t_canvas *x, t_int x1, t_int x2, t_int x3);

+

+EXTERN t_int *canvas_recurapply(t_canvas *x, t_canvasapply *fn,

+    t_int x1, t_int x2, t_int x3);

+

+EXTERN void canvas_resortinlets(t_canvas *x);

+EXTERN void canvas_resortoutlets(t_canvas *x);

+EXTERN void canvas_free(t_canvas *x);

+EXTERN void canvas_updatewindowlist( void);

+EXTERN void canvas_editmode(t_canvas *x, t_floatarg yesplease);

+EXTERN int canvas_isabstraction(t_canvas *x);

+EXTERN int canvas_istable(t_canvas *x);

+EXTERN int canvas_showtext(t_canvas *x);

+EXTERN void canvas_vis(t_canvas *x, t_floatarg f);

+EXTERN t_canvasenvironment *canvas_getenv(t_canvas *x);

+EXTERN void canvas_rename(t_canvas *x, t_symbol *s, t_symbol *dir);

+EXTERN void canvas_loadbang(t_canvas *x);

+EXTERN int canvas_hitbox(t_canvas *x, t_gobj *y, int xpos, int ypos,

+    int *x1p, int *y1p, int *x2p, int *y2p);

+EXTERN int canvas_setdeleting(t_canvas *x, int flag);

+

+typedef void (*t_undofn)(t_canvas *canvas, void *buf,

+    int action);        /* a function that does UNDO/REDO */

+#define UNDO_FREE 0                     /* free current undo/redo buffer */

+#define UNDO_UNDO 1                     /* undo */

+#define UNDO_REDO 2                     /* redo */

+EXTERN void canvas_setundo(t_canvas *x, t_undofn undofn, void *buf,

+    const char *name);

+EXTERN void canvas_noundo(t_canvas *x);

+EXTERN int canvas_getindex(t_canvas *x, t_gobj *y);

+

+EXTERN void canvas_connect(t_canvas *x,

+    t_floatarg fwhoout, t_floatarg foutno,t_floatarg fwhoin, t_floatarg finno);

+EXTERN void canvas_disconnect(t_canvas *x,

+    float index1, float outno, float index2, float inno);

+EXTERN int canvas_isconnected (t_canvas *x,

+    t_text *ob1, int n1, t_text *ob2, int n2);

+EXTERN void canvas_selectinrect(t_canvas *x, int lox, int loy, int hix, int hiy);

+

+

+/* ---- functions on canvasses as objects  --------------------- */

+

+EXTERN void canvas_fattenforscalars(t_canvas *x,

+    int *x1, int *y1, int *x2, int *y2);

+EXTERN void canvas_visforscalars(t_canvas *x, t_glist *glist, int vis);

+EXTERN int canvas_clicksub(t_canvas *x, int xpix, int ypix, int shift,

+    int alt, int dbl, int doit);

+EXTERN t_glist *canvas_getglistonsuper(void);

+

+EXTERN void linetraverser_start(t_linetraverser *t, t_canvas *x);

+EXTERN t_outconnect *linetraverser_next(t_linetraverser *t);

+EXTERN void linetraverser_skipobject(t_linetraverser *t);

+

+/* --------- functions on garrays (graphical arrays) -------------------- */

+

+EXTERN t_template *garray_template(t_garray *x);

+

+/* -------------------- arrays --------------------- */

+EXTERN t_garray *graph_array(t_glist *gl, t_symbol *s, t_symbol *tmpl,

+    t_floatarg f, t_floatarg saveit);

+EXTERN t_array *array_new(t_symbol *templatesym, t_gpointer *parent);

+EXTERN void array_resize(t_array *x, int n);

+EXTERN void array_free(t_array *x);

+

+/* --------------------- gpointers and stubs ---------------- */

+EXTERN t_gstub *gstub_new(t_glist *gl, t_array *a);

+EXTERN void gstub_cutoff(t_gstub *gs);

+EXTERN void gpointer_setglist(t_gpointer *gp, t_glist *glist, t_scalar *x);

+

+/* --------------------- scalars ------------------------- */

+EXTERN void word_init(t_word *wp, t_template *tmpl, t_gpointer *gp);

+EXTERN void word_restore(t_word *wp, t_template *tmpl,

+    int argc, t_atom *argv);

+EXTERN t_scalar *scalar_new(t_glist *owner,

+    t_symbol *templatesym);

+EXTERN void word_free(t_word *wp, t_template *tmpl);

+EXTERN void scalar_getbasexy(t_scalar *x, float *basex, float *basey);

+EXTERN void scalar_redraw(t_scalar *x, t_glist *glist);

+

+/* ------helper routines for "garrays" and "plots" -------------- */

+EXTERN int array_doclick(t_array *array, t_glist *glist, t_scalar *sc, t_array *ap,

+    t_symbol *elemtemplatesym,

+    float linewidth, float xloc, float xinc, float yloc, float scalarvis,

+    t_fielddesc *xfield, t_fielddesc *yfield, t_fielddesc *wfield,

+    int xpix, int ypix, int shift, int alt, int dbl, int doit);

+

+EXTERN void array_getcoordinate(t_glist *glist,

+    char *elem, int xonset, int yonset, int wonset, int indx,

+    float basex, float basey, float xinc,

+    t_fielddesc *xfielddesc, t_fielddesc *yfielddesc, t_fielddesc *wfielddesc,

+    float *xp, float *yp, float *wp);

+

+EXTERN int array_getfields(t_symbol *elemtemplatesym,

+    t_canvas **elemtemplatecanvasp,

+    t_template **elemtemplatep, int *elemsizep,

+    t_fielddesc *xfielddesc, t_fielddesc *yfielddesc, t_fielddesc *wfielddesc, 

+    int *xonsetp, int *yonsetp, int *wonsetp);

+

+/* --------------------- templates ------------------------- */

+EXTERN t_template *template_new(t_symbol *sym, int argc, t_atom *argv);

+EXTERN void template_free(t_template *x);

+EXTERN int template_match(t_template *x1, t_template *x2);

+EXTERN int template_find_field(t_template *x, t_symbol *name, int *p_onset,

+    int *p_type, t_symbol **p_arraytype);

+EXTERN t_float template_getfloat(t_template *x, t_symbol *fieldname, t_word *wp,

+    int loud);

+EXTERN void template_setfloat(t_template *x, t_symbol *fieldname, t_word *wp,

+    t_float f, int loud);

+EXTERN t_symbol *template_getsymbol(t_template *x, t_symbol *fieldname,

+    t_word *wp, int loud);

+EXTERN void template_setsymbol(t_template *x, t_symbol *fieldname,

+    t_word *wp, t_symbol *s, int loud);

+

+EXTERN t_template *gtemplate_get(t_gtemplate *x);

+EXTERN t_template *template_findbyname(t_symbol *s);

+EXTERN t_canvas *template_findcanvas(t_template *tmpl);

+EXTERN void template_notify(t_template *tmpl,

+    t_symbol *s, int argc, t_atom *argv);

+

+EXTERN t_float template_getfloat(t_template *x, t_symbol *fieldname,

+    t_word *wp, int loud);

+EXTERN void template_setfloat(t_template *x, t_symbol *fieldname,

+    t_word *wp, t_float f, int loud);

+EXTERN t_symbol *template_getsymbol(t_template *x, t_symbol *fieldname,

+    t_word *wp, int loud);

+EXTERN void template_setsymbol(t_template *x, t_symbol *fieldname,

+    t_word *wp, t_symbol *s, int loud);

+EXTERN t_float fielddesc_getcoord(t_fielddesc *f, t_template *tmpl,

+    t_word *wp, int loud);

+EXTERN void fielddesc_setcoord(t_fielddesc *f, t_template *tmpl,

+    t_word *wp, float pix, int loud);

+EXTERN t_float fielddesc_cvttocoord(t_fielddesc *f, float val);

+EXTERN float fielddesc_cvtfromcoord(t_fielddesc *f, float coord);

+

+

+/* ----------------------- guiconnects, g_guiconnect.c --------- */

+EXTERN t_guiconnect *guiconnect_new(t_pd *who, t_symbol *sym);

+EXTERN void guiconnect_notarget(t_guiconnect *x, double timedelay);

+

+/* ------------- IEMGUI routines used in other g_ files ---------------- */

+EXTERN t_symbol *iemgui_raute2dollar(t_symbol *s);

+EXTERN t_symbol *iemgui_dollar2raute(t_symbol *s);

+

+#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)

+}

+#endif

diff --git a/src/w_breakpoints.h b/src/w_breakpoints.h
new file mode 100755
index 0000000..f7d8754
--- /dev/null
+++ b/src/w_breakpoints.h
@@ -0,0 +1,569 @@
+#include <stdio.h>

+#include <string.h>

+#include <math.h>

+#ifdef _WIN32

+//#pragma warning( disable : 4244 )

+//#pragma warning( disable : 4305 )

+#define abs fabs

+#endif

+

+#define BACKGROUNDCOLOR "grey"

+#define LINECOLOR "grey30"

+#ifndef BACKGROUNDWIDTH

+#define BACKGROUNDWIDTH "1"

+#endif

+#define BORDER 2

+

+

+static void draw_inlets(t_breakpoints *x, t_glist *glist, int firsttime, int nin, int nout)

+{

+

+   if (x->r_sym == &s_) {

+     int n = nout;

+     int nplus, i;

+     int xpos = text_xpix(&x->x_obj,glist);

+     int ypos = text_ypix(&x->x_obj,glist);

+

+     nplus = (n == 1 ? 1 : n-1);

+     for (i = 0; i < n; i++)

+     {

+	  int onset = xpos + (x->w.width - IOWIDTH + 3 * BORDER) * i / nplus - BORDER;

+	  // OUTLETS

+	  if (firsttime)

+	       sys_vgui(".x%x.c create rectangle %d %d %d %d -tags %xo%d \n",

+			glist_getcanvas(glist),

+			onset, ypos + x->w.height - 2 + 2*BORDER,

+			onset + IOWIDTH, ypos + x->w.height  - 1+ 2*BORDER,

+			x, i);

+	  else

+	       sys_vgui(".x%x.c coords %xo%d %d %d %d %d\n",

+			glist_getcanvas(glist), x, i,

+			onset, ypos + x->w.height - 2 + 2*BORDER,

+			onset + IOWIDTH, ypos + x->w.height -1 + 2*BORDER);

+     }

+     n = nin; 

+     nplus = (n == 1 ? 1 : n-1);

+     for (i = 0; i < n; i++)

+     {

+	  int onset = xpos + (x->w.width - IOWIDTH + 3 * BORDER) * i / nplus - BORDER;

+	  // INLETS

+	  if (firsttime)

+	       sys_vgui(".x%x.c create rectangle %d %d %d %d -tags %xi%d\n",

+			glist_getcanvas(glist),

+			onset, ypos - BORDER + 1,

+			     onset + IOWIDTH, ypos + 2 - BORDER,

+			x, i);

+	  else

+	       sys_vgui(".x%x.c coords %xi%d %d %d %d %d\n",

+			glist_getcanvas(glist), x, i,

+			onset, ypos - BORDER + 1,

+			onset + IOWIDTH, ypos + 2 - BORDER);

+	  

+     }

+     }

+}

+

+

+

+static int breakpoints_next_doodle(t_breakpoints *x, struct _glist *glist,

+                              int xpos,int ypos)

+{

+     int ret = -1;

+     float xscale,yscale;

+     int dxpos,dypos;

+     float minval = 100000.0;

+     float tval;

+     int i;

+     int insertpos = -1;

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+

+     if (xpos > text_xpix(&x->x_obj,glist) + x->w.width) 

+         xpos = text_xpix(&x->x_obj,glist) + x->w.width;

+

+     xscale = x->w.width/x->duration[x->last_state];

+     yscale = x->w.height;

+     

+     dxpos = text_xpix(&x->x_obj,glist);/* + BORDER */;

+     dypos = text_ypix(&x->x_obj,glist) + BORDER;

+

+     for (i=0;i<=x->last_state;i++) {

+	  float dx2 = (dxpos + (x->duration[i] * xscale)) - xpos;

+	  float dy2 = (dypos + yscale - ( (x->finalvalues[i] - yBase) / ySize * yscale)) - ypos;

+

+	  dx2*=dx2;

+	  dy2*=dy2;

+	  tval = sqrt(dx2+dy2);

+

+	  if (tval <= minval) {

+	    minval = tval;	    

+	    insertpos = i;

+	  }

+     }

+

+     /* decide if we want to make a new one */

+     if (minval > /*5*/ 8 && insertpos >= 0 && !x->x_freeze) {

+

+	  while (((dxpos + (x->duration[insertpos] * xscale)) - xpos) < 0)

+	       insertpos++;

+	  while (((dxpos + (x->duration[insertpos-1] * xscale)) - xpos) > 0)

+	       insertpos--;

+

+	  if (x->last_state+1 >= x->args)

+	       breakpoints_resize(x,x->args+1);

+

+	  for (i=x->last_state;i>=insertpos;i--) {

+	       x->duration[i+1] = x->duration[i];

+	       x->finalvalues[i+1] = x->finalvalues[i];

+	  }

+	  x->duration[insertpos] = (float)(xpos-dxpos)/x->w.width*x->duration[x->last_state++];

+	  x->w.pointerx = xpos;

+	  x->w.pointery = ypos;

+     }

+     else {

+	  x->w.pointerx = text_xpix(&x->x_obj,glist) + x->duration[insertpos]*x->w.width/x->duration[x->last_state]; 

+

+

+	  x->w.pointery = ypos;	  

+	  //x->w.pointery = text_ypix(&x->x_obj,glist) +  (1.f - (x->finalvalues[i] - yBase) / ySize) * yscale;	

+     }

+    #ifdef DEBUG

+    post("pointery =%f",x->w.pointery);

+    post("insertpos =%f",insertpos);

+    #endif

+     x->w.grabbed = insertpos;

+     return insertpos;

+}

+

+static void breakpoints_create_doodles(t_breakpoints *x, t_glist *glist)

+{

+     float xscale,yscale;

+     int xpos,ypos;

+     int i;

+     char guistr[255];

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+     float yvalue;

+     

+     xscale = x->w.width/x->duration[x->last_state];

+     yscale = x->w.height;

+     

+     xpos = text_xpix(&x->x_obj,glist);

+     ypos = (int) (text_ypix(&x->x_obj,glist) + x->w.height);

+     for (i=0;i<=x->last_state;i++) {

+     yvalue = (x->finalvalues[i] - yBase) / ySize * yscale;

+	  sprintf(guistr,".x%x.c create oval %d %d %d %d -tags %xD%d",(unsigned int)glist_getcanvas(glist),

+		   (int) (xpos+(x->duration[i] * xscale) - 2),

+		   (int) (ypos - yvalue - 2),

+		   (int) (xpos+(x->duration[i] * xscale)+2),

+		   (int) (ypos - yvalue + 2),

+		   (unsigned int)x,i);

+

+	  if (i == x->w.grabbed) {

+	  	strcat(guistr," -fill red\n");

+	  } else {

+	   strcat(guistr," -fill "LINECOLOR"\n");

+   	  }

+	  sys_vgui("%s",guistr);

+     }

+     x->w.numdoodles = i;

+}

+

+

+static void breakpoints_delete_doodles(t_breakpoints *x, t_glist *glist)

+{

+     int i;

+     for (i=0;i<=x->w.numdoodles;i++) {

+	  sys_vgui(".x%x.c delete %xD%d\n",glist_getcanvas(glist),x,i);

+     }

+}

+

+static void breakpoints_update_doodles(t_breakpoints *x, t_glist *glist)

+{

+

+     breakpoints_delete_doodles(x,glist);

+/* LATER only create new doodles if necessary */

+     breakpoints_create_doodles(x, glist);

+}

+

+

+static void breakpoints_delnum(t_breakpoints *x)

+{

+     sys_vgui(".x%x.c delete %xT\n",glist_getcanvas(x->w.glist),x); 

+     

+}

+

+

+static void breakpoints_shownum(t_breakpoints *x,t_glist* glist) 

+{

+     float xscale,yscale;

+     int xpos,ypos;

+     int i= x->w.grabbed;

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+

+     xscale = x->w.width/x->duration[x->last_state];

+     yscale = x->w.height;

+     

+     xpos = text_xpix(&x->x_obj,glist);

+     ypos = (int) (text_ypix(&x->x_obj,glist) + x->w.height);

+

+     breakpoints_delnum(x);

+

+     sys_vgui(".x%x.c create text %d %d -text %.2fx%.2f -tags %xT\n",

+	     (unsigned int)glist_getcanvas(x->w.glist),

+	     

+	     (int) (xpos+(x->duration[i] * xscale) +3),

+	     (int) (ypos - (x->finalvalues[i]-yBase)/ySize*yscale - 10),

+	     

+	     x->finalvalues[i],

+	     x->duration[i],

+	     (unsigned int)x);

+     clock_delay(x->w.numclock,700);

+}

+

+

+

+static void breakpoints_create(t_breakpoints *x, t_glist *glist)

+{

+     int i;

+     static char  buf[1024];

+     float xscale,yscale;

+     int xpos,ypos;

+     char num[40];

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+

+     xpos = text_xpix(&x->x_obj,glist);

+     ypos = (int) text_ypix(&x->x_obj,glist);

+     x->w.numclock = clock_new(x, (t_method) breakpoints_delnum);     

+     sys_vgui(".x%x.c create rectangle \

+%d %d %d %d  -tags %xS -fill "BACKGROUNDCOLOR" -width "BACKGROUNDWIDTH"\n",

+	      glist_getcanvas(glist),

+	      xpos-BORDER, ypos-BORDER,

+	      xpos + x->w.width+2*BORDER, ypos + x->w.height+2*BORDER,

+	      x);

+     

+     xscale = x->w.width/x->duration[x->last_state];

+     yscale = x->w.height;

+     

+     sprintf(buf,".x%x.c create line",(unsigned int)glist_getcanvas(glist));

+     for (i=0;i<=x->last_state;i++) {

+	  sprintf(num," %d %d ",(int)(xpos + x->duration[i]*xscale),

+		                (int)(ypos + x->w.height- (x->finalvalues[i]-yBase)/ySize*yscale));

+	  strcat(buf,num);

+     }

+     

+     sprintf(num,"-tags %pP -fill "LINECOLOR"\n",x);

+     strcat(buf,num);

+     sys_vgui("%s",buf);

+     breakpoints_create_doodles(x,glist);

+}

+

+

+static void breakpoints_update(t_breakpoints *x, t_glist *glist)

+{

+int i;

+     static char  buf[1024];

+     float xscale,yscale;

+     char num[40];

+     int xpos = text_xpix(&x->x_obj,glist);

+     int ypos = text_ypix(&x->x_obj,glist);

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+

+     sys_vgui(".x%x.c coords %xS \

+%d %d %d %d\n",

+	      glist_getcanvas(glist), x,

+	      xpos - BORDER, ypos -BORDER,

+	      xpos + x->w.width+2*BORDER, ypos + x->w.height+2*BORDER);

+     

+     

+     xscale = x->w.width/x->duration[x->last_state];

+     yscale = x->w.height;

+     

+     sprintf(buf,".x%x.c coords %pP",(unsigned int)glist_getcanvas(glist),x);

+

+     for (i=0;i<=x->last_state;i++) {

+	  sprintf(num," %d %d ",(int)(xpos + x->duration[i]*xscale),

+		                (int) (ypos + x->w.height - (x->finalvalues[i]-yBase)/ySize*yscale));

+	  strcat(buf,num);

+     }

+     strcat(buf,"\n");

+     sys_vgui("%s",buf);

+     breakpoints_update_doodles(x,glist);

+     draw_inlets(x, glist, 0,1,3);

+}

+

+

+

+void breakpoints_drawme(t_breakpoints *x, t_glist *glist, int firsttime)

+{

+

+     if (firsttime) breakpoints_create(x,glist);

+     else breakpoints_update(x,glist);

+

+     draw_inlets(x, glist, firsttime, 1,3);

+}

+

+

+

+

+void breakpoints_erase(t_breakpoints* x,t_glist* glist)

+{

+     int n;

+     sys_vgui(".x%x.c delete %xS\n",

+	      glist_getcanvas(glist), x);

+

+     sys_vgui(".x%x.c delete %pP\n",

+	      glist_getcanvas(glist), x);

+

+     if (x->r_sym == &s_) {

+     sys_vgui(".x%x.c delete %xi0\n",glist_getcanvas(glist),x);

+     sys_vgui(".x%x.c delete %xo0\n",glist_getcanvas(glist),x);

+     sys_vgui(".x%x.c delete %xo1\n",glist_getcanvas(glist),x);

+     sys_vgui(".x%x.c delete %xo2\n",glist_getcanvas(glist),x);

+     }

+     breakpoints_delete_doodles(x,glist);

+}

+	

+

+

+/* ------------------------ breakpoints widgetbehaviour----------------------------- */

+

+

+static void breakpoints_getrect(t_gobj *z, t_glist *owner,

+    int *xp1, int *yp1, int *xp2, int *yp2)

+{

+    int width, height;

+    t_breakpoints* s = (t_breakpoints*)z;

+

+    width = s->w.width + 2*BORDER;

+    height = s->w.height + 2*BORDER;

+    *xp1 = text_xpix(&s->x_obj,owner)-BORDER;

+    *yp1 = text_ypix(&s->x_obj,owner)-BORDER;

+    *xp2 = text_xpix(&s->x_obj,owner) + width ; //+ 4

+    *yp2 = text_ypix(&s->x_obj,owner) + height ; //+ 4

+}

+

+static void breakpoints_displace(t_gobj *z, t_glist *glist,

+    int dx, int dy)

+{

+    t_breakpoints *x = (t_breakpoints *)z;

+    x->x_obj.te_xpix += dx;

+    x->x_obj.te_ypix += dy;

+

+    breakpoints_drawme(x, glist, 0);

+    canvas_fixlinesfor(glist_getcanvas(glist),(t_text*) x);

+}

+

+static void breakpoints_select(t_gobj *z, t_glist *glist, int state)

+{

+     t_breakpoints *x = (t_breakpoints *)z;

+    sys_vgui(".x%x.c itemconfigure %xS -fill %s\n", glist, 

+	     x, (state? "blue" : BACKGROUNDCOLOR));

+}

+

+

+static void breakpoints_activate(t_gobj *z, t_glist *glist, int state)

+{

+/*    t_text *x = (t_text *)z;

+    t_rtext *y = glist_findrtext(glist, x);

+    if (z->g_pd != gatom_class) rtext_activate(y, state);*/

+}

+

+static void breakpoints_delete(t_gobj *z, t_glist *glist)

+{

+    t_text *x = (t_text *)z;

+    canvas_deletelinesfor(glist_getcanvas(glist), x);

+}

+

+       

+static void breakpoints_vis(t_gobj *z, t_glist *glist, int vis)

+{

+    t_breakpoints* s = (t_breakpoints*)z;

+    if (vis)

+	 breakpoints_drawme(s, glist, 1);

+    else

+	 breakpoints_erase(s,glist);

+}

+

+/*  

+

+static void breakpoints_save(t_gobj *z, t_binbuf *b)

+{

+    t_breakpoints *x = (t_breakpoints *)z;

+    binbuf_addv(b, "ssiisiiffss", gensym("#X"), gensym("obj"),

+                (t_int)x->x_obj.te_xpix, (t_int)x->x_obj.te_ypix,  

+                atom_getsymbol(binbuf_getvec(x->x_obj.te_binbuf)),

+                x->w.width,x->w.height,x->max,x->min,x->r_sym,x->s_sym);

+    binbuf_addv(b, ";");

+}

+

+*/

+

+static void breakpoints_followpointer(t_breakpoints* x,t_glist* glist)

+{

+     float dur;

+     float xscale = x->duration[x->last_state]/x->w.width;

+     float ySize = x->max - x->min;

+     float yBase =  x->min;

+

+     if  ((x->w.grabbed > 0) && (x->w.grabbed < x->last_state)) {

+	  

+	  dur = (x->w.pointerx - text_xpix(&x->x_obj,glist))*xscale;

+	  if (dur < x->duration[x->w.grabbed-1])

+	       dur = x->duration[x->w.grabbed-1];

+	  if (dur > x->duration[x->w.grabbed+1])	  

+	       dur = x->duration[x->w.grabbed+1];

+

+	  x->duration[x->w.grabbed] = dur;

+     }

+     

+     float grabbed = (1.0f - (x->w.pointery - (float)text_ypix(&x->x_obj,glist))/(float)x->w.height);

+     #ifdef DEBUG

+     post("grabbed =%f",grabbed);

+     #endif

+     

+     if (grabbed < 0.0) 

+        grabbed= 0.0;

+     else if (grabbed > 1.0)

+        grabbed= 1.0;

+	  

+     x->finalvalues[x->w.grabbed] = grabbed * ySize + yBase;

+     

+

+    outlet_bang(x->out3);

+    if (x->c_sym != &s_) pd_bang(x->c_sym->s_thing);

+

+}

+

+

+void breakpoints_motion(t_breakpoints *x, t_floatarg dx, t_floatarg dy)

+{

+	if (x->w.shift) {

+	  x->w.pointerx+=dx/1000.f;

+	  x->w.pointery+=dy/1000.f;

+     }

+     else

+     {

+	  x->w.pointerx+=dx;

+	  x->w.pointery+=dy;

+     }

+     if (!x->resizing)

+	  breakpoints_followpointer(x,x->w.glist);

+     else {

+	       x->w.width+=dx;

+	       x->w.height+=dy;

+     }

+     breakpoints_shownum(x,x->w.glist);

+     breakpoints_update(x,x->w.glist);

+}

+

+void breakpoints_key(t_breakpoints *x, t_floatarg f)

+{

+     if (f == 8.0 && x->w.grabbed < x->last_state &&  x->w.grabbed > 0) {

+	  int i;

+

+	  for (i=x->w.grabbed;i<=x->last_state;i++) {

+	       x->duration[i] = x->duration[i+1];

+	       x->finalvalues[i] = x->finalvalues[i+1];

+	  }

+

+	  x->last_state--;

+	  x->w.grabbed--;

+	  breakpoints_update(x,x->w.glist);

+	  outlet_bang(x->out3);

+	  if (x->c_sym != &s_) pd_bang(x->c_sym->s_thing);

+     }

+}

+

+

+/* 

+static int bng_newclick(t_gobj *z, struct _glist *glist, int xpix, int ypix, int shift, int alt, int dbl, int doit)

+{

+    if(doit)

+        bng_click((t_bng *)z, (t_floatarg)xpix, (t_floatarg)ypix, (t_floatarg)shift, 0, (t_floatarg)alt);

+    return (1);

+}

+*/

+

+static int breakpoints_newclick(t_breakpoints *x, struct _glist *glist,

+    int xpos, int ypos, int shift, int alt, int dbl, int doit)

+{

+    // check if user wants to resize 

+     float wxpos = text_xpix(&x->x_obj,glist);

+     float wypos = (text_ypix(&x->x_obj,glist));

+

+     if (doit){

+     

+         #ifdef DEBUG

+     

+     post("clicked");

+      #endif

+

+         

+          /*

+          

+          if ( (xpos >= wxpos + BORDER) && (xpos <= wxpos + x->w.width - BORDER) \

+             && (ypos >= wypos + BORDER) && (ypos <= wypos + x->w.height - BORDER) ) {

+          */

+         

+         

+         if ( (xpos >= wxpos ) && (xpos <= wxpos + x->w.width ) \

+             && (ypos >= wypos ) && (ypos <= wypos + x->w.height ) ) {

+              #ifdef DEBUG

+             post("inside");

+              #endif

+             

+         breakpoints_next_doodle(x,glist,xpos,ypos);

+

+         glist_grab(x->w.glist, &x->x_obj.te_g, (t_glistmotionfn) breakpoints_motion,

+                    (t_glistkeyfn) breakpoints_key, xpos, ypos);

+             

+         x->w.shift = shift;

+         breakpoints_followpointer(x,glist);

+         breakpoints_shownum(x,glist);

+         breakpoints_update(x,glist);

+         

+         

+         }

+         

+     }

+     return (1);

+}

+

+/*

+static int breakpoints_newclick(t_breakpoints *x, struct _glist *glist,

+    int xpos, int ypos, int shift, int alt, int dbl, int doit)

+{

+    //check if user wants to resize

+     float wxpos = text_xpix(&x->x_obj,glist);

+     float wypos = (int) (text_ypix(&x->x_obj,glist) + x->w.height);

+

+     if (doit){

+         breakpoints_next_doodle(x,glist,xpos,ypos);

+

+         glist_grab(x->w.glist, &x->x_obj.te_g, (t_glistmotionfn) breakpoints_motion,

+                    (t_glistkeyfn) breakpoints_key, xpos, ypos);

+

+         x->resizing = 0;     

+         if (x->resizeable && (xpos > wxpos + x->w.width) && 

+             (ypos > wypos)) {

+             x->resizing = 1;     

+             

+         }

+         

+         if (xpos > wxpos + BORDER && (xpos < wxpos + x->w.width - BORDER) \

+             ypos > wypos + BORDER && (ypos < wypos + x->w.height - BORDER) ) {

+         x->w.shift = shift;

+         breakpoints_followpointer(x,glist);

+         breakpoints_shownum(x,glist);

+         breakpoints_update(x,glist);

+         }

+     }

+     return (1);

+}

+

+*/

+