Max 5 API Reference

myobex.c

/* 
    myobex
    Copyright 2004 - Cycling '74
    jeremy bernstein - jeremy@bootsquad.com 
*/

#include "ext.h"
#include "ext_common.h"
#include "ext_obex.h"

typedef struct _myobex 
{
    t_object                    ob;
    void                        *obex;
    uchar                       charval;
    long                        longval;
    double                      floatval;
    t_symbol                    *symval;
    t_atom                      atomarray[32];
    long                        atomarraycount;
    char                        mode;
    void                        *out;
} t_myobex;

void *myobex_new(t_symbol *s, long argc, t_atom *argv);
void myobex_free(t_myobex *x);
void myobex_assist(t_myobex *x, void *b, long m, long a, char *s);
void myobex_anything(t_myobex *x, t_symbol *s, long argc, t_atom *argv);
void myobex_bang(t_myobex *x);
void myobex_output(t_myobex *x);
void myobex_float(t_myobex *x, double f);
void myobex_int(t_myobex *x, long c);

// attribute method prototypes, for attributes which override their defaults
t_max_err myobex_floatval_rounded(t_myobex *x, void *attr, long *ac, t_atom **av);
t_max_err myobex_pattrmode_set(t_myobex *x, void *attr, long ac, t_atom *av);

// pattr support function prototypes
t_max_err myobex_getvalueof(t_myobex *x, long *ac, t_atom **av);
t_max_err myobex_setvalueof(t_myobex *x, long ac, t_atom *av);

void *myobex_class;
            
void main(void)
{   
    t_class *c;
    void    *attr;
    long    attrflags = 0;
    
    c = class_new("myobex", (method)myobex_new, (method)myobex_free, (short)sizeof(t_myobex), 
        0L, A_GIMME, 0);
    
    // initialize the common symbols, since we want to use them
    common_symbols_init();
    
    // register the byte offset of obex with the class
    class_obexoffset_set(c, calcoffset(t_myobex, obex));
    
    // add some attributes
    attr = attr_offset_new("charval", _sym_char, attrflags, 
        (method)0L, (method)0L, calcoffset(t_myobex, charval));
    class_addattr(c, attr);
    
    attr = attr_offset_new("longval", _sym_long, attrflags, 
        (method)0L, (method)0L, calcoffset(t_myobex, longval));
    class_addattr(c, attr);
    
    attr = attr_offset_new("floatval", _sym_float64, attrflags, 
        (method)0L, (method)0L, calcoffset(t_myobex, floatval));
    class_addattr(c, attr);

    // this attribute doesn't actually reference any data directly, but
    // operates upon another attribute's data. we use a custom 'get' method
    // and disable the set method using attribute flags.
    attrflags = ATTR_SET_OPAQUE_USER | ATTR_SET_OPAQUE;
    attr = attr_offset_new("floatval_rounded", _sym_float64, attrflags, 
        (method)myobex_floatval_rounded, (method)0L, 0L);
    class_addattr(c, attr);

    // reset attr flags to 0
    attrflags = 0;
    attr = attr_offset_new("symval", _sym_symbol, attrflags, 
        (method)0L, (method)0L, calcoffset(t_myobex, symval));
    class_addattr(c, attr);

    attr = attr_offset_array_new("array", _sym_atom, 32, attrflags, 
        (method)0L, (method)0L, 
        calcoffset(t_myobex, atomarraycount), calcoffset(t_myobex, atomarray));
    class_addattr(c, attr);

    // this attribute will determine which of the previous attributes will
    // be visible to pattr, for the getvalueof and setvalueof methods. since
    // setting this value should cause a few things to happen, we're using a
    // custom set method.
    attr = attr_offset_new("pattrmode", _sym_char, attrflags, 
        (method)0L, (method)myobex_pattrmode_set, calcoffset(t_myobex, mode));
    class_addattr(c, attr);
    
    // add methods to the class
    class_addmethod(c, (method)myobex_bang,     "bang",     0);
    class_addmethod(c, (method)myobex_float,    "float",    A_FLOAT, 0);
    class_addmethod(c, (method)myobex_int,      "int",      A_LONG, 0);
    class_addmethod(c, (method)myobex_anything, "list",     A_GIMME,0); 
    class_addmethod(c, (method)myobex_anything, "anything", A_GIMME,0); 
    class_addmethod(c, (method)myobex_assist,   "assist",   A_CANT,0);  

    // these methods support the pattr set of objects
    class_addmethod(c, (method)myobex_getvalueof,       "getvalueof",   A_CANT,0);  
    class_addmethod(c, (method)myobex_setvalueof,       "setvalueof",   A_CANT,0);

    // add methods for dumpout and quickref 
    class_addmethod(c, (method)object_obex_dumpout,     "dumpout",      A_CANT, 0); 
    class_addmethod(c, (method)object_obex_quickref,    "quickref",     A_CANT, 0);

    // we want this class to instantiate inside of the Max UI; ergo CLASS_BOX
    class_register(CLASS_BOX, c);
    myobex_class = c;
}

// custom attribute get methods all need to be implemented using this basic form
t_max_err myobex_floatval_rounded(t_myobex *x, void *attr, long *ac, t_atom **av)
{
    float floatval;
    
    if (ac && av) {
        if (*ac && *av) {
            // memory passed in; use it
        }
        else {
            if (!(*av = (t_atom *)getbytes(sizeof(t_atom)))) {
                *ac = 0;
                return MAX_ERR_OUT_OF_MEM;
            }
            *ac = 1;
        }
        // query the attribute's value. we could do this directly, too (x->floatval)
        // but then that wouldn't be so pedagogically useful, would it?
        floatval = object_attr_getfloat(x, gensym("floatval"));
        atom_setfloat(*av, (float)((long)(floatval + 0.5)));
    }
    return MAX_ERR_NONE;
}

// custom attribute set methods all need to be implemented using this basic form
t_max_err myobex_pattrmode_set(t_myobex *x, void *attr, long ac, t_atom *av)
{
    t_box *b;
    long mode;
    
    /*  note that we're using this attribute to perform the notification call, too.
        as such, we call it whenever data changes, not just when we're changing the mode */
    if (ac && av) {
        mode = atom_getlong(av);
        
        if (mode != x->mode) {
            x->mode = mode;
        }

        // now, notify pattr that something has changed
        // get the box pointer from the obex
        object_obex_lookup(x, gensym("#B"), (t_object **)&b);
        // we call this on the box, not on the object
        object_notify(b, _sym_modified, 0L);
        
        // by the way, attributes notify pattr themselves, and don't require this
        
        // trigger output from the left outlet, since we've changed the info of note
        myobex_output(x);
    }
    return MAX_ERR_NONE;
}

void myobex_bang(t_myobex *x)
{
    myobex_output(x);
}

void myobex_output(t_myobex *x)
{
    switch(x->mode) {
        case 0: outlet_int(x->out, x->charval); break;
        case 1: outlet_int(x->out, x->longval); break;
        case 2: outlet_float(x->out, x->floatval); break;
        case 3: outlet_anything(x->out, x->symval, 0, 0L); break;
        case 4: outlet_float(x->out, object_attr_getfloat(x, gensym("floatval_rounded"))); break;
        case 5:
            if (x->atomarray[0].a_type != A_SYM)
                outlet_list(x->out, NULL, x->atomarraycount, x->atomarray);
            else
                outlet_anything(x->out, atom_getsym(x->atomarray), x->atomarraycount - 1, x->atomarray + 1);
            break;
        default: break;
    }
}


void myobex_float(t_myobex *x, double f)
{
    object_attr_setfloat(x, gensym("floatval"), f);
    object_attr_setlong(x, gensym("pattrmode"), 2);
}

void myobex_int(t_myobex *x, long c)
{
    object_attr_setfloat(x, gensym("longval"), c);
    object_attr_setlong(x, gensym("pattrmode"), 1);
}
    
void myobex_anything(t_myobex *x, t_symbol *s, long ac, t_atom *av)
{
    if (ac && av) {
        if (s == _sym_list) {
            object_attr_setvalueof(x, gensym("array"), ac, av);
            x->atomarraycount = ac;
        }
        else {
            t_atom *a;
            
            if (a = (t_atom *)getbytes(sizeof(t_atom) * (ac + 1))) {
                atom_setsym(a, s);
                sysmem_copyptr(av, a + 1, sizeof(t_atom) * ac);
                object_attr_setvalueof(x, gensym("array"), ac + 1, a);
                freebytes(a, sizeof(t_atom) * (ac + 1));
                x->atomarraycount = ac + 1;
            }
            else {
                error("myobex: could not allocate memory for atom array");
                return;
            }
        }
        object_attr_setlong(x, gensym("pattrmode"), 5);
    }
    else {
        x->symval = s;
        object_attr_setlong(x, gensym("pattrmode"), 3);
    }
}

t_max_err myobex_getvalueof(t_myobex *x, long *ac, t_atom **av)
{
    if (ac && av) {
        if (*ac && *av) {
            // memory passed in; use it. but responsibly
            if (*ac > x->atomarraycount) 
                *ac = x->atomarraycount;
        }
        else {
            switch (x->mode) {
                case 5: *ac = x->atomarraycount; break;
                default: *ac = 1; break;
            }
            if (!(*av = (t_atom *)getbytes(sizeof(t_atom) * (*ac)))) {
                *ac = 0;
                return MAX_ERR_OUT_OF_MEM;
            }
        }
        switch (x->mode) {
            case 0: atom_setlong(*av, x->charval); break;
            case 1: atom_setlong(*av, x->longval); break;
            case 2: atom_setfloat(*av, x->floatval); break;
            case 3: atom_setsym(*av, x->symval); break;
            case 4: atom_setfloat(*av, object_attr_getfloat(x, gensym("floatval_rounded"))); break;
            case 5: sysmem_copyptr(x->atomarray, *av, sizeof(t_atom) * (*ac)); break;
            default: break;
        }
    }
    return MAX_ERR_NONE;
}

t_max_err myobex_setvalueof(t_myobex *x, long ac, t_atom *av)
{
    if (ac && av) {
        if (ac == 1) {
            switch(av->a_type) {
                case A_LONG: myobex_int(x, atom_getlong(av)); break;
                case A_FLOAT: myobex_float(x, atom_getfloat(av)); break;
                case A_SYM: myobex_anything(x, atom_getsym(av), 0, NULL); break;
                default: break;
            }
        }
        else {
            if (av->a_type == A_SYM)
                myobex_anything(x, atom_getsym(av), ac - 1, av + 1);
            else
                myobex_anything(x, _sym_list, ac, av);
        }
    }
    return MAX_ERR_NONE;
}

void myobex_assist(t_myobex *x, void *b, long m, long a, char *s)
{
    if (m == 1) { //input
        sprintf(s, "int, float, list, set, anything");          
    } 
    else {  //output
        if (a == 0)
            sprintf(s, "anything out"); 
        else
            sprintf(s, "dumpout");
    }
}

void myobex_free(t_myobex *x)
{
    ;
}

void *myobex_new(t_symbol *s, long ac, t_atom *av)
{
    t_myobex *x;
    t_atom a;

    // we use object_alloc here, rather than newobject
    if (x = (t_myobex *)object_alloc(myobex_class)) {
        // add a dumpout outlet
        object_obex_store(x, _sym_dumpout, outlet_new(x, NULL));

        // add a left outlet
        x->out = outlet_new(x, 0L);
        
        // set defaults before attribute args are processed!
        x->charval = 0;
        x->longval = 0;
        x->floatval = 0;
        x->symval = _sym_nothing;
        x->atomarraycount = 0;
        
        x->mode = 0;
        
        attr_args_process(x, ac, av);       
    }
    return (x);
}

Copyright © 2008, Cycling '74