From 330173fc6f2897c2b15b523ea5ee9679bd5ca045 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?IOhannes=20m=20zm=C3=B6lnig?= Date: Tue, 29 Jul 2008 12:20:52 +0000 Subject: added new object [canvasdollarzero] which is a clone of iemlib2's [parentdollarzero] with the added feature of allowing you to specify the depth of the parent. depthified other objects svn path=/trunk/externals/iem/iemguts/; revision=10225 --- src/canvasconnections.c | 7 +++--- src/canvasdollarzero.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++++ src/canvasindex.c | 25 +++++++++++++++------ src/parentposition.c | 27 +++++++++++++++++------ src/propertybang.c | 22 ++++++++++++------- 5 files changed, 114 insertions(+), 25 deletions(-) create mode 100644 src/canvasdollarzero.c diff --git a/src/canvasconnections.c b/src/canvasconnections.c index 260e946..cebd085 100644 --- a/src/canvasconnections.c +++ b/src/canvasconnections.c @@ -110,7 +110,6 @@ static void *canvasconnections_new(t_floatarg f) depth--; } - if(canvas) { x->x_object = pd_checkobject((t_pd*)canvas); x->x_parent = canvas->gl_owner; @@ -123,7 +122,9 @@ static void *canvasconnections_new(t_floatarg f) void canvasconnections_setup(void) { - canvasconnections_class = class_new(gensym("canvasconnections"), (t_newmethod)canvasconnections_new, - (t_method)canvasconnections_free, sizeof(t_canvasconnections), 0, A_DEFFLOAT, 0); + canvasconnections_class = class_new(gensym("canvasconnections"), + (t_newmethod)canvasconnections_new, (t_method)canvasconnections_free, + sizeof(t_canvasconnections), 0, + A_DEFFLOAT, 0); class_addbang(canvasconnections_class, (t_method)canvasconnections_bang); } diff --git a/src/canvasdollarzero.c b/src/canvasdollarzero.c new file mode 100644 index 0000000..6a43eb9 --- /dev/null +++ b/src/canvasdollarzero.c @@ -0,0 +1,58 @@ +/* For information on usage and redistribution, and for a DISCLAIMER OF ALL +* WARRANTIES, see the file, "LICENSE.txt," in this distribution. + +based on iemlib2 written by Thomas Musil, Copyright (c) IEM KUG Graz Austria 2000 - 2006 */ + + +#include "m_pd.h" +#include "g_canvas.h" + + +/* -------------- canvasdollarzero --------------- */ +/* -- receives the $0 value of the parent canvas --*/ + +static t_class *canvasdollarzero_class; + +typedef struct _canvasdollarzero +{ + t_object x_obj; + t_symbol *s_dollzero; +} t_canvasdollarzero; + +static void canvasdollarzero_bang(t_canvasdollarzero *x) +{ + if(x->s_dollzero) + outlet_symbol(x->x_obj.ob_outlet, x->s_dollzero); +} + +static void *canvasdollarzero_new(t_floatarg f) +{ + t_canvasdollarzero *x = (t_canvasdollarzero *)pd_new(canvasdollarzero_class); + + t_glist *glist=(t_glist *)canvas_getcurrent(); + t_canvas *canvas=(t_canvas*)glist_getcanvas(glist); + int depth=(int)f; + + if(depth<0)depth=0; + while(depth && canvas) { + canvas=canvas->gl_owner; + depth--; + } + + x->s_dollzero=0; + if(canvas) { + x->s_dollzero = canvas_realizedollar(canvas, gensym("$0")); + } + + outlet_new(&x->x_obj, &s_symbol); + return (x); +} + +void canvasdollarzero_setup(void) +{ + canvasdollarzero_class = class_new(gensym("canvasdollarzero"), + (t_newmethod)canvasdollarzero_new, 0, + sizeof(t_canvasdollarzero), 0, + A_DEFFLOAT, 0); + class_addbang(canvasdollarzero_class, (t_method)canvasdollarzero_bang); +} diff --git a/src/canvasindex.c b/src/canvasindex.c index 8092351..2ebd6d8 100644 --- a/src/canvasindex.c +++ b/src/canvasindex.c @@ -20,6 +20,11 @@ * this object provides a way to get the position of the containing abstraction * within the parent-patch * this makes it easy to (dis)connect this abstraction to others + * + * by default the index of the containing abstraction within the parent-patch is + * queried; however you can give the "depth" as argument: + * e.g. [canvasindex 1] will give you the index of the abstraction containing the + * abstraction that holds this object */ #include "m_pd.h" @@ -44,14 +49,10 @@ static void canvasindex_bang(t_canvasindex *x) t_canvas*c=x->x_canvas; t_canvas*c0=0; - // int index=-1; - if(!c) return; c0=c->gl_owner; if(!c0)return; - // index=glist_getindex(c0, c); - // index=glist_getindex(c0, (t_gobj*)c); outlet_float(x->youtlet, (t_float)(glist_getindex(c0, 0))); outlet_float(x->xoutlet, (t_float)(glist_getindex(c0, (t_gobj*)c))); } @@ -62,12 +63,20 @@ static void canvasindex_free(t_canvasindex *x) outlet_free(x->youtlet); } -static void *canvasindex_new(void) +static void *canvasindex_new(t_floatarg f) { t_canvasindex *x = (t_canvasindex *)pd_new(canvasindex_class); t_glist *glist=(t_glist *)canvas_getcurrent(); t_canvas *canvas=(t_canvas*)glist_getcanvas(glist); + int depth=(int)f; + + if(depth<0)depth=0; + while(depth && canvas) { + canvas=canvas->gl_owner; + depth--; + } + x->x_canvas = canvas; x->xoutlet=outlet_new(&x->x_obj, &s_float); @@ -78,7 +87,9 @@ static void *canvasindex_new(void) void canvasindex_setup(void) { - canvasindex_class = class_new(gensym("canvasindex"), (t_newmethod)canvasindex_new, - (t_method)canvasindex_free, sizeof(t_canvasindex), 0, 0); + canvasindex_class = class_new(gensym("canvasindex"), + (t_newmethod)canvasindex_new, (t_method)canvasindex_free, + sizeof(t_canvasindex), 0, + A_DEFFLOAT, 0); class_addbang(canvasindex_class, (t_method)canvasindex_bang); } diff --git a/src/parentposition.c b/src/parentposition.c index 7f25951..086c902 100644 --- a/src/parentposition.c +++ b/src/parentposition.c @@ -17,8 +17,14 @@ /* - * this object provides a way to get the position of the containing abstraction - * within the parent-patch + * this object provides a way to get and set the position of the containing + * abstraction within the parent-patch + * + * by default the position of the containing abstraction within the parent-patch is + * queried + * you can give the "depth" as argument; + * e.g. [parentposition 1] will set/get the position of the abstraction containing the + * abstraction within its canvas. */ #include "m_pd.h" @@ -34,7 +40,6 @@ typedef struct _parentposition { t_object x_obj; t_canvas *x_canvas; - t_glist *x_glist; t_outlet*xoutlet, *youtlet; } t_parentposition; @@ -107,14 +112,20 @@ static void parentposition_free(t_parentposition *x) outlet_free(x->youtlet); } -static void *parentposition_new(void) +static void *parentposition_new(t_floatarg f) { t_parentposition *x = (t_parentposition *)pd_new(parentposition_class); t_glist *glist=(t_glist *)canvas_getcurrent(); t_canvas *canvas=(t_canvas*)glist_getcanvas(glist); + int depth=(int)f; + + if(depth<0)depth=0; + while(depth && canvas) { + canvas=canvas->gl_owner; + depth--; + } x->x_canvas = canvas; - x->x_glist = glist; x->xoutlet=outlet_new(&x->x_obj, &s_list); x->youtlet=outlet_new(&x->x_obj, &s_list); @@ -124,8 +135,10 @@ static void *parentposition_new(void) void parentposition_setup(void) { - parentposition_class = class_new(gensym("parentposition"), (t_newmethod)parentposition_new, - (t_method)parentposition_free, sizeof(t_parentposition), 0, 0); + parentposition_class = class_new(gensym("parentposition"), + (t_newmethod)parentposition_new, (t_method)parentposition_free, + sizeof(t_parentposition), 0, + A_DEFFLOAT, 0); class_addbang(parentposition_class, (t_method)parentposition_bang); class_addlist(parentposition_class, (t_method)parentposition_list); } diff --git a/src/propertybang.c b/src/propertybang.c index d994582..63d541a 100644 --- a/src/propertybang.c +++ b/src/propertybang.c @@ -48,15 +48,21 @@ static void propertybang_free(t_propertybang *x) pd_unbind(&x->x_obj.ob_pd, x->x_d0name); } -static void propertybang_anything(t_propertybang *x, t_symbol*s, int argc, t_atom*argv) { - if(s==&s_bang && argc==0) { - outlet_bang(x->x_obj.ob_outlet); - } +static void propertybang_bang(t_propertybang *x) { + outlet_bang(x->x_obj.ob_outlet); } - static void propertybang_properties(t_gobj*z, t_glist*owner) { - // argh: z is the abstraction! but we need to access ourselfs! - // we handle this by binding to a special symbol. e.g. "$0-propertybang" + /* argh: z is the abstraction! but we need to access ourselfs! + * we handle this by binding to a special symbol. e.g. "$0 propertybang" + * (we use the space between in order to make it hard for the ordinary user + * to use this symbol for other things... + */ + + /* alternatively we could just search the abstraction for all instances of propertybang_class + * and bang these; + * but using the pd_bind-trick is simpler for now + * though not as sweet, as somebody could use our bind-symbol for other things... + */ t_symbol*s_d0name=canvas_realizedollar((t_canvas*)z, gensym("$0 propertybang")); pd_bang(s_d0name->s_thing); @@ -82,5 +88,5 @@ void propertybang_setup(void) { propertybang_class = class_new(gensym("propertybang"), (t_newmethod)propertybang_new, (t_method)propertybang_free, sizeof(t_propertybang), CLASS_NOINLET, 0); - class_addanything(propertybang_class, propertybang_anything); + class_addbang(propertybang_class, propertybang_bang); } -- cgit v1.2.1