Max 5 API Reference

jit.attribute.c

/* 
    jit.attribute.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/

#include "jit.common.h"
#include "ext_obex.h"

/**
 * t_jit_attribute object struct.
 *
 * @ingroup attrmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference. Attribute 
 *          objects do not typically use attributes 
 *          themselves to access members, but rather 
 *          accessor methods--i.e. use jit_object_method
 *          in place of the jit_attr_* functions to access 
 *          attribute state.
 */
typedef struct _jit_attribute
{
    t_jit_object    ob;             ///< common object header
    t_symbol        *name;          ///< attribute name
    t_symbol        *type;          ///< attribute type (char, long, float32, float64, symbol, atom, or obj)
    long            flags;          ///< flags for public/private get/set methods
    method          get;            ///< override default get method
    method          set;            ///< override default set method
    void            *filterget;     ///< filterobject for get method
    void            *filterset;     ///< filterobject for set method
    void            *reserved;      ///< for future use
    void            *data;          ///< interally stored data
    long            size;           ///< data size
} t_jit_attribute;      

/**
 * t_jit_attr_offset object struct.
 *
 * @ingroup attrmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference. Attribute 
 *          objects do not typically use attributes 
 *          themselves to access members, but rather 
 *          accessor methods--i.e. use jit_object_method
 *          in place of the jit_attr_* functions to access 
 *          attribute state.
 */
typedef struct _jit_attr_offset
{
    t_jit_object    ob;             ///< common object header
    t_symbol        *name;          ///< attribute name
    t_symbol        *type;          ///< attribute type (char, long, float32, float64, symbol, atom, or obj)
    long            flags;          ///< flags for public/private get/set methods
    method          get;            ///< override default get method
    method          set;            ///< override default set method
    void            *filterget;     ///< filterobject for get method
    void            *filterset;     ///< filterobject for set method
    void            *reserved;      ///< for future use
    long            offset;         ///< byte offset to the attribute data  
} t_jit_attr_offset;        

/**
 * t_jit_attr_offset_array object struct.
 *
 * @ingroup attrmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference. Attribute 
 *          objects do not typically use attributes 
 *          themselves to access members, but rather 
 *          accessor methods--i.e. use jit_object_method
 *          in place of the jit_attr_* functions to access 
 *          attribute state.
 */
typedef struct _jit_attr_offset_array
{
    t_jit_object    ob;             ///< common object header
    t_symbol        *name;          ///< attribute name
    t_symbol        *type;          ///< attribute type (char, long, float32, float64, symbol, atom, or obj)
    long            flags;          ///< flags for public/private get/set methods
    method          get;            ///< override default get method
    method          set;            ///< override default set method
    void            *filterget;     ///< filterobject for get method
    void            *filterset;     ///< filterobject for set method
    void            *reserved;      ///< for future use
    long            offset;         ///< byte offset to the attribute data  
    long            size;           ///< maximum size
    long            offsetcount;    ///< byte offset to the attribute count
} t_jit_attr_offset_array;      

/**
 * t_jit_attr_filter_clip object struct.
 *
 * @ingroup attrmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference when calling 
 *          Jitter attribute functions.
 */
typedef struct _jit_attr_filter_clip
{
    t_jit_object    ob;             ///< common object header
    t_symbol        *type;          ///< "type" attribute
    double          scale;          ///< scaling factor; "scale" attribute
    double          min;            ///< minimum vlaue; "min" attribute
    double          max;            ///< maximum value; "max" attribute
    char            usescale;       ///< use scaling flag; "usescale" attribute
    char            usemin;         ///< clip to minimum flag; "usemin" attribute
    char            usemax;         ///< clip to maximum flag; "usemax" attribute
} t_jit_attr_filter_clip;       

/**
 * t_jit_attr_filter_proc object struct.
 *
 * @ingroup attrmod
 *
 * @warning This struct should not be accessed directly, 
 *          but is provided for reference when calling 
 *          Jitter attribute functions.
 */
typedef struct _jit_attr_filter_proc
{
    t_jit_object    ob;             ///< common object header
    method          proc;           ///< filter procedure
} t_jit_attr_filter_proc;       


void *_jit_attr_offset_class,*_jit_attr_offset_array_class;
void *_jit_attribute_class;

t_jit_err jit_attr_setup_class(void *c);
t_symbol *jit_attr_getname(t_jit_attr *x);
t_symbol *jit_attr_gettype(t_jit_attr *x);
long jit_attr_canget(t_jit_attr *x);
long jit_attr_canset(t_jit_attr *x);
long jit_attr_usercanget(t_jit_attr *x);
long jit_attr_usercanset(t_jit_attr *x);
method jit_attr_getmethod(t_jit_attr *x, t_symbol *methodtype);
t_jit_err jit_attr_setmethod(t_jit_attr *x, t_symbol *methodtype, method m);
long jit_attr_getmethodtype(t_jit_attr *x, t_symbol *methodname);
t_jit_err jit_attr_filterget(t_jit_attr *x, void *y);
t_jit_err jit_attr_filterset(t_jit_attr *x, void *y);
t_jit_err jit_attr_filterget_wrap(void *parent, t_jit_attr *x, long *ac, t_atom **av);
t_jit_err jit_attr_filterset_wrap(void *parent, t_jit_attr *x, long ac, t_atom *av);
// jit_object_method versions, for compatibility with decorated attributes
t_jit_err jit_attr_get(t_jit_attr *x, void *parent, long *ac, t_atom **av);
t_jit_err jit_attr_set(t_jit_attr *x, void *parent, long ac, t_atom *av);
void jit_attr_getformat(t_jit_attr *x, t_object *parent, long *argc, t_atom **argv);
t_jit_err jit_attr_gettext(t_jit_attr *x, t_object *parent, long *textlen, char **text, long maxatoms, long maxlen, long flags);

t_jit_err jit_attribute_init(void);
t_jit_object *jit_attribute_new(char *name, t_symbol *type, long flags, method mget, method mset);
size_t jit_attribute_sizeof(t_symbol *s);
t_jit_err jit_attribute_free(t_jit_attribute *x);
t_jit_attribute *jit_attribute_clone(t_jit_attribute *x);
long jit_attribute_getsize(t_jit_attribute *x);
t_symbol *jit_attribute_getattach_name(t_jit_attribute *x);
t_jit_err jit_attribute_method_get(void *parent, t_jit_attribute *x, long *ac, t_atom **av);
t_jit_err jit_attribute_method_set(void *parent, t_jit_attribute *x, long ac, t_atom *av);

t_jit_err jit_attr_offset_init(void);
t_jit_object *jit_attr_offset_new(char *name, t_symbol *type, long flags, method mget, method mset, long offset);
t_jit_err jit_attr_offset_free(t_jit_attr_offset *x);
t_jit_attr_offset *jit_attr_offset_clone(t_jit_attr_offset *x);
t_jit_err jit_attr_offset_get(void *parent, t_jit_attr_offset *x, long *ac, t_atom **av);
t_jit_err jit_attr_offset_set(void *parent, t_jit_attr_offset *x, long ac, t_atom *av);
t_jit_err jit_attr_offset_offset(t_jit_attr_offset *x, long offset);
long jit_attr_offset_getoffset(t_jit_attr_offset *x);
long jit_attr_offset_getsize(t_jit_attr_offset *x);

t_jit_err jit_attr_offset_array_init(void);
t_jit_object *jit_attr_offset_array_new(char *name, t_symbol *type, long size, long flags, method mget, method mset, long offsetcount, long offset);
t_jit_err jit_attr_offset_array_free(t_jit_attr_offset_array *x);
t_jit_attr_offset_array *jit_attr_offset_array_clone(t_jit_attr_offset_array *x);
t_jit_err jit_attr_offset_array_get(void *parent, t_jit_attr_offset_array *x, long *ac, t_atom **av);
t_jit_err jit_attr_offset_array_set(void *parent, t_jit_attr_offset_array *x, long ac, t_atom *av);
t_jit_err jit_attr_offset_array_offsetcount(t_jit_attr_offset_array *x, long offsetcount);
long jit_attr_offset_array_getoffsetcount(t_jit_attr_offset_array *x);
t_jit_err jit_attr_offset_array_size(t_jit_attr_offset_array *x, long size);
long jit_attr_offset_array_getsize(t_jit_attr_offset_array *x);

void *_jit_attr_filter_clip_class;

t_jit_err jit_attr_filter_clip_init(void);
t_jit_object *jit_attr_filter_clip_new(void);
t_jit_err jit_attr_filter_clip_free(t_jit_attr_filter_clip *x);
t_jit_err jit_attr_filter_clip_filter(t_jit_attr_filter_clip *x, t_symbol *s, long ac, t_atom *av, void *parent, void *attr);

void *_jit_attr_filter_proc_class;

t_jit_err jit_attr_filter_proc_init(void);
t_jit_object *jit_attr_filter_proc_new(method proc);
t_jit_err jit_attr_filter_proc_free(t_jit_attr_filter_proc *x);
t_jit_err jit_attr_filter_proc_filter(t_jit_attr_filter_proc *x, t_symbol *s, long ac, t_atom *av, void *parent, void *attr);
t_jit_err jit_attr_filter_proc_setproc(t_jit_attr_filter_proc *x, method proc);


t_jit_err jit_attr_init(void) 
{
    t_jit_err err=JIT_ERR_NONE;
    
    err = jit_attribute_init();
    err = jit_attr_offset_init();
    err = jit_attr_offset_array_init();
    err = jit_attr_filter_clip_init();
    err = jit_attr_filter_proc_init();

    
    return err;
}

t_jit_err jit_attr_setup_class(void *c)
{
    jit_class_addmethod(c, (method)jit_attr_getname,        "getname",      A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_gettype,        "gettype",      A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_getmethod,      "getmethod",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_setmethod,      "setmethod",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_getmethodtype,  "getmethodtype",A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_canget,         "canget",       A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_canset,         "canset",       A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_usercanget,     "usercanget",   A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_usercanset,     "usercanset",   A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_filterget,      "filterget",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_filterset,      "filterset",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_get,            "get",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_set,            "set",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_get,            "getvalueof",   A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_set,            "setvalueof",   A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_getformat,      "getformat",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_attr_gettext,        "gettext",      A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_object_register,     "register",     A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_method_true,         "class_jit_attribute", A_CANT, 0L);
    return JIT_ERR_NONE;
}

/**
 * Retrieves attribute name.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  attribute name
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_symbol *jit_attr_getname(t_jit_attr *x)
{
    if (x)
        return x->name;
    else 
        return _jit_sym_nothing;
}

/**
 * Retrieves attribute type.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  attribute type
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_symbol *jit_attr_gettype(t_jit_attr *x)
{
    if (x)
        return x->type;
    else 
        return _jit_sym_nothing;
}

/**
 * Retrieves attribute gettable flag.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  gettable flag
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
long jit_attr_canget(t_jit_attr *x)
{
    if (x) return (!(x->flags&JIT_ATTR_GET_OPAQUE));
    else return 0;
}

/**
 * Retrieves attribute settable flag.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  settable flag
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
long jit_attr_canset(t_jit_attr *x)
{
    if (x) return (!(x->flags&JIT_ATTR_SET_OPAQUE));
    else return 0;
}

/**
 * Retrieves attribute user gettable flag.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  user gettable flag
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
long jit_attr_usercanget(t_jit_attr *x)
{
    if (x) return (!(x->flags&JIT_ATTR_GET_OPAQUE_USER));
    else return 0;
}

/**
 * Retrieves attribute user settable flag.
 *
 * @ingroup attrmod
 *
 * @param   x       attribute object pointer
 *
 * @return  user settable flag
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
long jit_attr_usercanset(t_jit_attr *x)
{
    if (x) return (!(x->flags&JIT_ATTR_SET_OPAQUE_USER));
    else return 0;
}

/**
 * Retrieves attribute getter or setter method.
 *
 * @ingroup attrmod
 *
 * @param   x           attribute object pointer
 * @param   methodname  "get" or "set" symbol
 *
 * @return  getter or setter method
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
method jit_attr_getmethod(t_jit_attr *x, t_symbol *methodname)
{
    if (x) {
        if (methodname==_jit_sym_get)
            return x->filterget?(method)jit_attr_filterget_wrap:x->get;
        else if (methodname==_jit_sym_set)
            return x->filterset?(method)jit_attr_filterset_wrap:x->set;
    } 
    return 0;
}

t_jit_err jit_attr_setmethod(t_jit_attr *x, t_symbol *methodtype, method m)
{
    if (x&&m) {
        if (methodtype==_jit_sym_get)
            x->get = m;
        else if (methodtype==_jit_sym_set)
            x->set = m;
    } 
    return JIT_ERR_NONE;
}


long jit_attr_getmethodtype(t_jit_attr *x, t_symbol *methodname)
{
    long type = A_GIMME;
    
    if (x) {
        if (methodname==_jit_sym_get) {
            if (x->flags&JIT_ATTR_GET_USURP_LOW) {
                type = A_USURP_LOW;
            } else if (x->flags&JIT_ATTR_GET_USURP) {
                type = A_USURP;
            } else if (x->flags&JIT_ATTR_GET_DEFER_LOW) {
                type = A_DEFER_LOW;
            } else if (x->flags&JIT_ATTR_GET_DEFER) {
                type = A_DEFER;
            }
        } else if (methodname==_jit_sym_set) {
            if (x->flags&JIT_ATTR_SET_USURP_LOW) {
                type = A_USURP_LOW;
            } else if (x->flags&JIT_ATTR_SET_USURP) {
                type = A_USURP;
            } else if (x->flags&JIT_ATTR_SET_DEFER_LOW) {
                type = A_DEFER_LOW;
            } else if (x->flags&JIT_ATTR_SET_DEFER) {
                type = A_DEFER;
            }
        }
    } 
    return type;

}

/**
 * Sets attribute getter filter.
 *
 * @ingroup attrmod
 *
 * @param   x           attribute object pointer
 * @param   y           getter filter object
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_jit_err jit_attr_filterget(t_jit_attr *x, void *y)
{
    if (x) {
        if (y) {
            static method mf=NULL;
            if (!mf)
                mf = jit_object_getmethod(NULL,NULL);
            //check object for filter method
            if (jit_object_getmethod(y,_jit_sym_filter)!=mf)
                x->filterget = y;
            else 
                return JIT_ERR_GENERIC;
        } else {
            x->filterget = NULL;
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Sets attribute setter filter.
 *
 * @ingroup attrmod
 *
 * @param   x           attribute object pointer
 * @param   y           setter filter object
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_jit_err jit_attr_filterset(t_jit_attr *x, void *y)
{
    if (x) {
        if (y) {
            static method mf=NULL;
            if (!mf)
                mf = jit_object_getmethod(NULL,NULL);
            //check object for filter method
            if (jit_object_getmethod(y,_jit_sym_filter)!=mf)
                x->filterset = y;
            else
                return JIT_ERR_GENERIC;
        } else {
            x->filterset = NULL;
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_attr_filterget_wrap(void *parent, t_jit_attr *x, long *ac, t_atom **av)
{
    t_jit_err err;
        
    if (x&&x->filterget) {
        err = (t_jit_err) x->get(parent,x,ac,av);
        jit_object_method(x->filterget,_jit_sym_filter,_jit_sym_filter,*ac,*av,parent,x);
        return err;
    } 
    return JIT_ERR_INVALID_PTR; 
}

t_jit_err jit_attr_filterset_wrap(void *parent, t_jit_attr *x, long ac, t_atom *av)
{
    long i,ac2;
    t_atom av2[256];
    
    if (x&&x->filterset) {
        //must copy
        CLIP(ac,0,256);
        ac2=ac;
        for (i=0;i<ac;i++) {
            av2[i]=av[i];
        }   
        jit_object_method(x->filterset,_jit_sym_filter,_jit_sym_filter,ac2,av2,parent,x);
        return (t_jit_err) x->set(parent,x,ac2,av2);
    } 
    return JIT_ERR_INVALID_PTR; 
}

/**
 * Calls attribute getter to retrieve from parent object.
 *
 * @ingroup attrmod
 *
 * @param   x           attribute object pointer
 * @param   parent      target object pointer
 * @param   ac          pointer to argument count
 * @param   av          pointer to argument vector
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_jit_err jit_attr_get(t_jit_attr *x, void *parent, long *ac, t_atom **av)
{
    if (x) {
        if (x->filterget)
            jit_attr_filterget_wrap(parent, x, ac, av);
        else {
            (*x->get)(parent, x, ac, av);
        }
    }
    return JIT_ERR_NONE;
}

/**
 * Calls attribute setter to set in parent object.
 *
 * @ingroup attrmod
 *
 * @param   x           attribute object pointer
 * @param   parent      target object pointer
 * @param   ac          argument count
 * @param   av          argument vector
 *
 * @return  t_jit_err error code
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_method
 *          on an intance of any attribute obejct.
 */
t_jit_err jit_attr_set(t_jit_attr *x, void *parent, long ac, t_atom *av)
{
    if (x) {
        if (x->filterset)
            jit_attr_filterset_wrap(parent, x, ac, av);
        else
            (*x->set)(parent, x, ac, av);
    }
    return JIT_ERR_NONE;
}


void jit_attr_getformat(t_jit_attr *x, t_object *parent, long *argc, t_atom **argv)
{
    long size;
    long i;
    char alloc; 
    
    size = (long)object_method(x, gensym("getsize"));
    
    if (size > 4) { // is it really as big as all that?
        long ac = 0;
        t_atom *av = NULL;
        
        jit_attr_get(x, parent, &ac, &av);
        if (ac && av) {
            size = ac;
            jit_freebytes(av, sizeof(t_atom) * ac);
        }
    }

    size = CLIP(size, 1, 9);
    atom_alloc_array(size, argc, argv, &alloc); 
    for (i = 0; i < size; i++) {
        ((*argv)+i)->a_type = A_DOLLAR; 
        ((*argv)+i)->a_w.w_long = i+1; 
    }
}

t_jit_err jit_attr_gettext(t_jit_attr *x, t_object *parent, long *textlen, char **text, long maxatoms, long maxlen, long flags)
{
#ifdef COMMA_SEPARATED
    static t_symbol *ps_style = NULL;
    static t_symbol *ps_text_commaseparated = NULL;
    static t_symbol *ps_text_large_commaseparated = NULL;
#endif
    
    long ac=0;
    t_atom *av=NULL;
    t_symbol *typesym = (t_symbol *)jit_object_method(x,_jit_sym_gettype);
    t_jit_attr *at;
    t_jit_object *jitob;
#ifdef COMMA_SEPARATED
    t_symbol *style = jit_attr_getsym(x, ps_style);
    char commasep;
#endif
    
    if (!(x && parent && textlen && text))
        return JIT_ERR_GENERIC;
    
    // verify that parent is really the parent
    if (jitob = max_jit_obex_jitob_get(parent)) {
        at = jit_object_attr_get(jitob, x->name);
        if (at && at == x) 
            parent = jitob;
    }
    
#ifdef COMMA_SEPARATED
    if (!ps_style) {
        ps_style = gensym("style");
        ps_text_commaseparated = gensym("text_commaseparated");
        ps_text_large_commaseparated = gensym("text_large_commaseparated");
    }
    commasep = (style == ps_text_commaseparated || style == ps_text_large_commaseparated);
#endif
    object_attr_getvalueof(parent, x->name, &ac, &av);
    if (ac && av) {
        if ((typesym==_jit_sym_long) ||
            (typesym==_jit_sym_char) ||
            (typesym==_jit_sym_symbol) ||
            (typesym==_jit_sym_float32) ||
            (typesym==_jit_sym_float64) ||
            (typesym==_jit_sym_atom))
        {
            long textbufsize = 0;
            char *textbuf = NULL;
            long charcount;
            long getatoms;
            char cutoff;
            
#ifdef COMMA_SEPARATED
            if (commasep)
                flags |= OBEX_UTIL_ATOM_GETTEXT_COMMA_DELIM;
#endif
            // truncate symbols and atoms to max string len, rather than # of items
            // this improves display of A_COMMA separated atom lists
            if (typesym == _jit_sym_symbol || typesym == _jit_sym_atom)
                getatoms = 0;
            else
                getatoms = MIN(maxatoms,ac);
            
            // Note exemplary use of UTF8 funs!
            atom_gettext(getatoms ? getatoms : ac,av,&textbufsize,&textbuf,flags);
            if (textbufsize && textbuf) {
                charcount = charset_utf8_count(textbuf, NULL);
                if (maxlen > 0 && charcount > maxlen) {
                    char *c = (char *)charset_utf8_offset(textbuf, maxlen, NULL);
                    if (c) *c = '\0'; // truncate text pointer
                }
                cutoff = ((getatoms && maxatoms > 0 && ac > maxatoms) || (maxlen > 0 && charcount > maxlen));
                if (*text && *textlen) {
                    ;
                } else {
                    *textlen = strlen(textbuf) + 1;
                    if (cutoff) // something got cut off
                        *textlen += strlen(" ...");
                    *text = jit_getbytes(*textlen);
                }
                strncpy(*text, textbuf, *textlen);
                if (cutoff) // something got cut off
                    strncat_zero(*text," ...", *textlen);
                sysmem_freeptr(textbuf);
            }
        }
    }
    jit_freebytes((char *)av,sizeof(t_atom)*ac);
    return JIT_ERR_NONE;
}

#pragma mark -

t_jit_err jit_attribute_init(void)
{
    _jit_attribute_class = jit_class_new("jit_attribute",(method)jit_attribute_new,(method)jit_attribute_free,
        sizeof(t_jit_attribute),A_CANT,0L); //A_CANT = untyped

    jit_attr_setup_class(_jit_attribute_class);
    jit_class_addmethod(_jit_attribute_class, (method)jit_attribute_getsize,        "getsize", A_CANT, 0L);
    jit_class_addmethod(_jit_attribute_class, (method)jit_attribute_clone,          "object_clone", A_CANT, 0L);

    jit_class_register(_jit_attribute_class);

    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_attribute.
 *
 * @ingroup attrmod
 *
 * @param   name    attribute name
 * @param   type    data type
 * @param   flags   privacy flags
 * @param   mget    getter method
 * @param   mset    setter method
 *
 * @return  t_jit_attribute object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_attribute_new(char *name, t_symbol *type, long flags, method mget, method mset)
{
    t_jit_attribute *x;
    method mget_default,mset_default;
    
    if (x = (t_jit_attribute *)jit_object_alloc(_jit_attribute_class)) {
        x->name         = gensym(name);
        x->type         = type;
        x->flags        = flags;
        x->get          = mget?(method)mget:(method)jit_attribute_method_get;
        x->set          = mset?(method)mset:(method)jit_attribute_method_set;
        x->filterget    = NULL;
        x->filterset    = NULL;
        x->reserved     = NULL;
        x->data         = NULL;
        x->size         = 0;
    }
    
    return (t_jit_object *)x;
}

size_t jit_attribute_sizeof(t_symbol *s)
{
    if (s == _jit_sym_char)
        return sizeof(char);
    else if (s == _jit_sym_long)
        return sizeof(long);
    else if (s == _jit_sym_float32)
        return sizeof(float);
    else if (s == _jit_sym_float64)
        return sizeof(double);
    else if (s == _jit_sym_atom)
        return sizeof(t_atom);
    else if (s == _jit_sym_symbol)
        return sizeof(void *);
    else if (s == _jit_sym_pointer)
        return sizeof(void *);
    else if (s == _jit_sym_object)
        return sizeof(void *);
    else {
        post("jit.attribute: unknown type");
        return 0;
    }
}

t_jit_err jit_attribute_free(t_jit_attribute *x)
{
    if (x->filterget) jit_object_free(x->filterget);
    if (x->filterset) jit_object_free(x->filterset);
    if (x->data) jit_freebytes(x->data, jit_attribute_sizeof(x->type) * x->size);
    return JIT_ERR_NONE;
}

t_jit_attribute *jit_attribute_clone(t_jit_attribute *x)
{
    t_jit_attribute *clone;
    
    clone = (t_jit_attribute *)object_clone_generic((t_object *)x);
    if (x&&clone)
    {
        if (x->filterget) 
            clone->filterget = object_clone((t_object *)x->filterget);
        if (x->filterset) 
            clone->filterset = object_clone((t_object *)x->filterset);
        // if the type is A_OBJ, should we be cloning here?
        // we don't free the object though, perhaps desirable? 
        // unclear w/r/t reference counting. leaving for now -jkc 
        if (x->data) 
        {
            unsigned long bytecount;
            bytecount = jit_attribute_sizeof(x->type) * x->size;
            clone->data = (void *) jit_getbytes(bytecount);
            sysmem_copyptr((const void *)x->data,(void *)clone->data,bytecount);
        }
    }   
    return clone;
}

long jit_attribute_getsize(t_jit_attribute *x)
{
    return x->size;
}

t_jit_err jit_attribute_method_get(void *parent, t_jit_attribute *x, long *ac, t_atom **av)
{
    long i;
    
    if (x) {
        if (*ac && *av)
            *ac = MIN(*ac, x->size);
        else {
            *ac = x->size;
            if (!(*av = jit_getbytes(sizeof(t_atom) * (*ac)))) {
                *ac = 0;
                return JIT_ERR_OUT_OF_MEM;
            }
        }
        for (i = 0; i < *ac; i++) {
            if (x->type == _jit_sym_char)
                jit_atom_setlong((*av) + i, ((uchar *)x->data)[i]);
            else if (x->type == _jit_sym_long)
                jit_atom_setlong((*av) + i, ((long *)x->data)[i]);
            else if (x->type == _jit_sym_float32)
                jit_atom_setfloat((*av) + i, ((float *)x->data)[i]);
            else if (x->type == _jit_sym_float64)
                jit_atom_setfloat((*av) + i, ((double *)x->data)[i]);
            else if (x->type == _jit_sym_symbol)
                jit_atom_setsym((*av) + i, ((t_symbol **)x->data)[i]);
            else if (x->type == _jit_sym_object)
                jit_atom_setobj((*av) + i, ((void **)x->data)[i]);
            else if (x->type == _jit_sym_pointer)
                jit_atom_setobj((*av) + i, ((void **)x->data)[i]);
            else if (x->type == _jit_sym_atom)
                *((*av) + i) = ((t_atom *)x->data)[i];
            else 
                jit_atom_setlong((*av) + i, 0);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_attribute_method_set(void *parent, t_jit_attribute *x, long ac, t_atom *av)
{
    long i, c;
    
    if (x) {
        if (ac && av) {
            if (x->data)
                jit_freebytes(x->data, jit_attribute_sizeof(x->type) * x->size);
            if (x->data = jit_getbytes(jit_attribute_sizeof(x->type) * ac)) {
                x->size = ac;
                for (i = 0; i < ac; i++) {
                    if (x->type == _jit_sym_char)
                        ((uchar *)x->data)[i] = jit_atom_getlong(av + i);
                    else if (x->type == _jit_sym_long)
                        ((long *)x->data)[i] = jit_atom_getlong(av + i);
                    else if (x->type == _jit_sym_float32)
                        ((float *)x->data)[i] = jit_atom_getfloat(av + i);
                    else if (x->type == _jit_sym_float64)
                        ((double *)x->data)[i] = jit_atom_getfloat(av + i);
                    else if (x->type == _jit_sym_symbol)
                        ((t_symbol **)x->data)[i] = jit_atom_getsym(av + i);
                    else if (x->type == _jit_sym_object)
                        ((void **)x->data)[i] = jit_atom_getobj(av + i);
                    else if (x->type == _jit_sym_pointer)
                        ((void **)x->data)[i] = jit_atom_getobj(av + i);
                    else if (x->type == _jit_sym_atom)
                        ((t_atom *)x->data)[i] = *(av + i);
                }
            }
            else {
                x->size = 0;
                return JIT_ERR_OUT_OF_MEM;
            }
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

#pragma mark -
// --------------------------------------------------------------------------------
//

t_jit_err jit_attr_offset_init(void)
{
    _jit_attr_offset_class = jit_class_new("jit_attr_offset",(method)jit_attr_offset_new,(method)jit_attr_offset_free,
        sizeof(t_jit_attr_offset),A_CANT,0L); //A_CANT = untyped

    jit_attr_setup_class(_jit_attr_offset_class);
    jit_class_addmethod(_jit_attr_offset_class, (method)jit_attr_offset_getsize,    "getsize",      A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_class, (method)jit_attr_offset_offset,     "offset",       A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_class, (method)jit_attr_offset_getoffset,  "getoffset",    A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_class, (method)jit_attr_offset_clone,      "object_clone", A_CANT, 0L);

    jit_class_register(_jit_attr_offset_class);

    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_attr_offset.
 *
 * @ingroup attrmod
 *
 * @param   name    attribute name
 * @param   type    data type
 * @param   flags   privacy flags
 * @param   mget    getter method
 * @param   mset    setter method
 * @param   offset  byte offset to struct member
 *
 * @return  t_jit_attr_offset object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_attr_offset_new(char *name, t_symbol *type, long flags, method mget, method mset, long offset)
{
    t_jit_attr_offset *x;
    method mget_default,mset_default;
    
    if (x = (t_jit_attr_offset *)jit_object_alloc(_jit_attr_offset_class)) {
        x->name         = gensym(name);
        x->type         = type;
        x->flags        = flags;
        x->get          = mget?(method)mget:(method)jit_attr_offset_get;
        x->set          = mset?(method)mset:(method)jit_attr_offset_set;
        x->filterget    = NULL;
        x->filterset    = NULL;
        x->reserved     = NULL;
        x->offset       = offset;
    }
    
    return (t_jit_object *)x;
}

t_jit_attr_offset *jit_attr_offset_clone(t_jit_attr_offset *x)
{
    t_jit_attr_offset *clone;
    
    clone = (t_jit_attr_offset *)object_clone_generic((t_object *)x);
    if (x&&clone)
    {
        if (x->filterget) 
            clone->filterget = object_clone((t_object *)x->filterget);
        if (x->filterset) 
            clone->filterset = object_clone((t_object *)x->filterset);
    }   
    return clone;
}

t_jit_err jit_attr_offset_free(t_jit_attr_offset *x)
{
    if (x->filterget) jit_object_free(x->filterget);
    if (x->filterset) jit_object_free(x->filterset);
    return JIT_ERR_NONE;
}

t_jit_err jit_attr_offset_offset(t_jit_attr_offset *x, long offset)
{
    if (x) {
        x->offset=offset;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

long jit_attr_offset_getsize(t_jit_attr_offset *x)
{
    return 1;
}

long jit_attr_offset_getoffset(t_jit_attr_offset *x)
{
    return x?x->offset:0;
}

t_jit_err jit_attr_offset_get(void *parent, t_jit_attr_offset *x, long *ac, t_atom **av)
{
    if (x) {
        if ((*ac)&&(*av)) {
            //memory passed in, use it
        } else {
            //otherwise allocate memory
            *ac = 0;
            if (!(*av = jit_getbytes(sizeof(t_atom))))
                return JIT_ERR_OUT_OF_MEM;
        }
        *ac = 1;
        if (x->type==_jit_sym_char)
            jit_atom_setlong(*av,*((uchar *)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_long)
            jit_atom_setlong(*av,*((long *)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_float32)
            jit_atom_setfloat(*av,*((float *)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_float64)
            jit_atom_setfloat(*av,*((double *)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_symbol)
            jit_atom_setsym(*av,*((t_symbol **)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_object)
            jit_atom_setobj(*av,*((void **)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_pointer)
            jit_atom_setobj(*av,*((void **)(((char *)parent)+x->offset)));
        else if (x->type==_jit_sym_atom)
            **av = *((t_atom *)(((char *)parent)+x->offset));
        else 
            jit_atom_setlong(*av,0);
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_attr_offset_set(void *parent, t_jit_attr_offset *x, long ac, t_atom *av)
{
    if (x && ac && av) {
        if (x->type==_jit_sym_char)
            *((uchar *)(((char *)parent)+x->offset)) = jit_atom_getlong(av);
        else if (x->type==_jit_sym_long)
            *((long *)(((char *)parent)+x->offset)) = jit_atom_getlong(av);
        else if (x->type==_jit_sym_float32)
            *((float *)(((char *)parent)+x->offset)) = jit_atom_getfloat(av);
        else if (x->type==_jit_sym_float64)
            *((double *)(((char *)parent)+x->offset)) = jit_atom_getfloat(av);
        else if (x->type==_jit_sym_symbol)
            *((t_symbol **)(((char *)parent)+x->offset)) = jit_atom_getsym(av);
        else if (x->type==_jit_sym_object)
            *((void **)(((char *)parent)+x->offset)) = jit_atom_getobj(av);
        else if (x->type==_jit_sym_pointer)
            *((void **)(((char *)parent)+x->offset)) = jit_atom_getobj(av);
        else if (x->type==_jit_sym_atom)
            *((t_atom *)(((char *)parent)+x->offset)) = *av;

        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

#pragma mark -
// --------------------------------------------------------------------------------
//

t_jit_err jit_attr_offset_array_init(void)
{
    _jit_attr_offset_array_class = jit_class_new("jit_attr_offset_array",(method)jit_attr_offset_array_new,
        (method)jit_attr_offset_array_free,sizeof(t_jit_attr_offset_array),A_CANT,0L); //A_CANT = untyped

    jit_attr_setup_class(_jit_attr_offset_array_class);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_offset,               "offset",       A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_getoffset,            "getoffset",    A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_array_offsetcount,    "offsetcount",  A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_array_getoffsetcount, "getoffsetcount",   A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_array_size,           "size",         A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_array_getsize,        "getsize",      A_CANT, 0L);
    jit_class_addmethod(_jit_attr_offset_array_class, (method)jit_attr_offset_array_clone,          "object_clone", A_CANT, 0L);

    jit_class_register(_jit_attr_offset_array_class);

    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_attr_offset_array.
 *
 * @ingroup attrmod
 *
 * @param   name            attribute name
 * @param   type            data type
 * @param   size            maximum size
 * @param   flags           privacy flags
 * @param   mget            getter method
 * @param   mset            setter method
 * @param   offsetcount     byte offset to count struct member (if zero, remain fixed size with max size)
 * @param   offset          byte offset to array struct member
 *
 * @return  t_jit_attr_offset_array object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_attr_offset_array_new(char *name, t_symbol *type, long size, long flags, method mget, method mset, long offsetcount, long offset)
{
    t_jit_attr_offset_array *x;
    method mget_default,mset_default;
    
    if (x = (t_jit_attr_offset_array *)jit_object_alloc(_jit_attr_offset_array_class)) {
        x->name         = gensym(name);
        x->type         = type;
        x->flags        = flags;
        x->get          = mget?(method)mget:(method)jit_attr_offset_array_get;
        x->set          = mset?(method)mset:(method)jit_attr_offset_array_set;
        x->filterget    = NULL;
        x->filterset    = NULL;
        x->reserved     = NULL;
        x->offset       = offset;
        x->size         = size;
        x->offsetcount  = offsetcount;
    }
    
    return (t_jit_object *)x;
}

t_jit_err jit_attr_offset_array_free(t_jit_attr_offset_array *x)
{
    if (x->filterget) jit_object_free(x->filterget);
    if (x->filterset) jit_object_free(x->filterset);
    return JIT_ERR_NONE;
}

t_jit_attr_offset_array *jit_attr_offset_array_clone(t_jit_attr_offset_array *x)
{
    t_jit_attr_offset_array *clone;
    
    clone = (t_jit_attr_offset_array *)object_clone_generic((t_object *)x);
    if (x&&clone)
    {
        if (x->filterget) 
            clone->filterget = object_clone((t_object *)x->filterget);
        if (x->filterset) 
            clone->filterset = object_clone((t_object *)x->filterset);
    }   
    return clone;
}

t_jit_err jit_attr_offset_array_get(void *parent, t_jit_attr_offset_array *x, long *ac, t_atom **av)
{
    long i;
    
    if (x) {
        if ((*ac)&&(*av)) {
            //memory passed in, use it
            if (x->offsetcount) *ac = MIN(*ac,*((long *)(((char *)parent)+x->offsetcount)));
            else *ac = MIN(*ac,x->size);
        } else {
            //otherwise allocate memory
            if (x->offsetcount) *ac = *((long *)(((char *)parent)+x->offsetcount));
            else *ac = x->size;
            if (!(*av = jit_getbytes(sizeof(t_atom)*(*ac)))) {
                *ac = 0;
                return JIT_ERR_OUT_OF_MEM;
            }
        }
        for (i=0;i<*ac;i++) {
            if (x->type==_jit_sym_char)
                jit_atom_setlong((*av)+i,((uchar *)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_long)
                jit_atom_setlong((*av)+i,((long *)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_float32)
                jit_atom_setfloat((*av)+i,((float *)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_float64)
                jit_atom_setfloat((*av)+i,((double *)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_symbol)
                jit_atom_setsym((*av)+i,((t_symbol **)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_object)
                jit_atom_setobj((*av)+i,((void **)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_pointer)
                jit_atom_setobj((*av)+i,((void **)(((char *)parent)+x->offset))[i]);
            else if (x->type==_jit_sym_atom)
                *((*av)+i) = ((t_atom *)(((char *)parent)+x->offset))[i];
            else 
                jit_atom_setlong((*av)+i,0);
        }       
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_attr_offset_array_set(void *parent, t_jit_attr_offset_array *x, long ac, t_atom *av)
{
    long i,c;
    if (x) {
        c = MIN(ac,x->size);
        for (i=0;i<c;i++) {
            if (x->type==_jit_sym_char)
                ((uchar *)(((char *)parent)+x->offset))[i] = jit_atom_getlong(av+i);
            else if (x->type==_jit_sym_long)
                ((long *)(((char *)parent)+x->offset))[i] = jit_atom_getlong(av+i);
            else if (x->type==_jit_sym_float32)
                ((float *)(((char *)parent)+x->offset))[i] = jit_atom_getfloat(av+i);
            else if (x->type==_jit_sym_float64)
                ((double *)(((char *)parent)+x->offset))[i] = jit_atom_getfloat(av+i);
            else if (x->type==_jit_sym_symbol)
                ((t_symbol **)(((char *)parent)+x->offset))[i] = jit_atom_getsym(av+i);
            else if (x->type==_jit_sym_object)
                ((void **)(((char *)parent)+x->offset))[i] = jit_atom_getobj(av+i);
            else if (x->type==_jit_sym_pointer)
                ((void **)(((char *)parent)+x->offset))[i] = jit_atom_getobj(av+i);
            else if (x->type==_jit_sym_atom)
                ((t_atom *)(((char *)parent)+x->offset))[i] = *(av+i);          
        }
        if (x->offsetcount) {
            *((long *)(((char *)parent)+x->offsetcount)) = c;
        } else { //fixed size array, set other elements to zero?
            if (c<x->size) {
                for (i=c;i<x->size;i++) {
                    if (x->type==_jit_sym_char)
                        ((uchar *)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_long)
                        ((long *)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_float32)
                        ((float *)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_float64)
                        ((double *)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_symbol)
                        ((t_symbol **)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_object)
                        ((void **)(((char *)parent)+x->offset))[i] = 0;
                    else if (x->type==_jit_sym_pointer)
                        ((void **)(((char *)parent)+x->offset))[i] = 0;
                    //nothing for fixed atom arrays???
                }
            } 
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_attr_offset_array_offsetcount(t_jit_attr_offset_array *x, long offsetcount)
{
    if (x) {
        x->offsetcount=offsetcount;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

long jit_attr_offset_array_getoffsetcount(t_jit_attr_offset_array *x)
{
    return x?x->offsetcount:0;
}

t_jit_err jit_attr_offset_array_size(t_jit_attr_offset_array *x, long size)
{
    if (x) {
        x->size=size;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

long jit_attr_offset_array_getsize(t_jit_attr_offset_array *x)
{
    return x?x->size:0;
}

#pragma mark -
// --------------------------------------------------------------------------------
//

t_jit_err jit_attr_filter_clip_init(void)
{
    long attrflags;
    void *attr;
    
    _jit_attr_filter_clip_class = jit_class_new("jit_attr_filter_clip",(method)jit_attr_filter_clip_new,
        (method)jit_attr_filter_clip_free,sizeof(t_jit_attr_filter_clip),A_CANT,0L); //A_CANT = untyped

    jit_class_addmethod(_jit_attr_filter_clip_class, (method)jit_attr_filter_clip_filter,       "filter",       A_CANT, 0L);

    //add attributes
    attrflags = 0;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"type",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,type));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"scale",_jit_sym_float64,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,scale));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"min",_jit_sym_float64,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,min));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"max",_jit_sym_float64,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,max));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"usescale",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,usescale));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"usemin",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,usemin));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset,"usemax",_jit_sym_char,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_attr_filter_clip,usemax));
    jit_class_addattr(_jit_attr_filter_clip_class,attr);
    
    jit_class_register(_jit_attr_filter_clip_class);

    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_attr_filter_clip.
 *
 * @ingroup attrmod
 *
 * @return  t_jit_attr_filter_clip object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_attr_filter_clip_new(void)
{
    t_jit_attr_filter_clip *x;
    
    if (x = (t_jit_attr_filter_clip *)jit_object_alloc(_jit_attr_filter_clip_class)) {
        x->type     = _jit_sym_float64;
        x->min      = 0.;
        x->max      = 1.;
        x->scale    = 1.;
        x->usemin   = 1;
        x->usemax   = 1;
        x->usescale = 0;
    }
    
    return (t_jit_object *)x;
}

t_jit_err jit_attr_filter_clip_free(t_jit_attr_filter_clip *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_attr_filter_clip_filter(t_jit_attr_filter_clip *x, t_symbol *s, long ac, t_atom *av, void *parent, void *attr)
{
    long i;
    double f;
    
    if (x) {
        for (i=0;i<ac;i++) {
            if (x->type==_jit_sym_char) {
                f=jit_atom_getfloat(av+i);
                if (x->usescale) f*=x->scale;
                if (x->usemin&&f<x->min) f=x->min;
                if (x->usemax&&f>x->max) f=x->max;
                jit_atom_setlong(av+i,f);
            } else if (x->type==_jit_sym_long) {
                f=jit_atom_getfloat(av+i);
                if (x->usescale) f*=x->scale;
                if (x->usemin&&f<x->min) f=x->min;
                if (x->usemax&&f>x->max) f=x->max;
                jit_atom_setlong(av+i,f);
            } else if (x->type==_jit_sym_float32) {
                f=jit_atom_getfloat(av+i);
                if (x->usescale) f*=x->scale;
                if (x->usemin&&f<x->min) f=x->min;
                if (x->usemax&&f>x->max) f=x->max;
                jit_atom_setfloat(av+i,f);
            } else if (x->type==_jit_sym_float64) {
                f=jit_atom_getfloat(av+i);
                if (x->usescale) f*=x->scale;
                if (x->usemin&&f<x->min) f=x->min;
                if (x->usemax&&f>x->max) f=x->max;
                jit_atom_setfloat(av+i,f);
            }
        }   
        return JIT_ERR_NONE;
    } 
    return JIT_ERR_INVALID_PTR; 
}


#pragma mark -
// --------------------------------------------------------------------------------
//

t_jit_err jit_attr_filter_proc_init(void)
{
    long attrflags;
    void *attr;
    
    _jit_attr_filter_proc_class = jit_class_new("jit_attr_filter_proc",(method)jit_attr_filter_proc_new,
        (method)jit_attr_filter_proc_free,sizeof(t_jit_attr_filter_proc),A_CANT,0L); //A_CANT = untyped

    jit_class_addmethod(_jit_attr_filter_proc_class, (method)jit_attr_filter_proc_filter,       "filter",       A_CANT, 0L);
    jit_class_addmethod(_jit_attr_filter_proc_class, (method)jit_attr_filter_proc_setproc,      "setproc",      A_CANT, 0L);
    
    jit_class_register(_jit_attr_filter_proc_class);

    return JIT_ERR_NONE;
}

/**
 * Constructs instance of t_jit_attr_filter_proc.
 *
 * @ingroup attrmod
 *
 * @param   proc    filter procedure
 *
 * @return  t_jit_attr_filter_clip object pointer
 *
 * @warning This function is not exported, but is provided 
 *          for reference when calling via jit_object_new.
 */
t_jit_object *jit_attr_filter_proc_new(method proc)
{
    t_jit_attr_filter_proc *x;
    
    if (x = (t_jit_attr_filter_proc *)jit_object_alloc(_jit_attr_filter_proc_class)) {
        x->proc = proc;
    }
    
    return (t_jit_object *)x;
}

t_jit_err jit_attr_filter_proc_free(t_jit_attr_filter_proc *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_attr_filter_proc_filter(t_jit_attr_filter_proc *x, t_symbol *s, long ac, t_atom *av, void *parent, void *attr)
{
    
    if (x&&x->proc&&parent&&attr) {
        return (t_jit_err) (x->proc)(parent,attr,ac,av);
    } 
    return JIT_ERR_INVALID_PTR; 
}

t_jit_err jit_attr_filter_proc_setproc(t_jit_attr_filter_proc *x, method proc)
{
    x->proc = proc;
    
    return JIT_ERR_NONE;
}

Copyright © 2008, Cycling '74