Max 5 API Reference

myregob.c

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

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

typedef struct _myregob 
{
    t_object                    ob;
    void                        *obex;
    void                        **proxy; // proxies
    void                        **out; // out
    void                        **mmo;  // minimetro objects
    long                        count;
    long                        inlet_no;
} t_myregob;

void *myregob_new(t_symbol *s, long argc, t_atom *argv);
void myregob_free(t_myregob *x);
void myregob_assist(t_myregob *x, void *b, long m, long a, char *s);
void myregob_notify(t_myregob *x, t_symbol *s, t_symbol *msg, void *sender, void *data);

void myregob_int(t_myregob *x, long c);
void myregob_speed(t_myregob *x, double speed);
// pattr support function prototypes
t_max_err myregob_getvalueof(t_myregob *x, long *ac, t_atom **av);
t_max_err myregob_setvalueof(t_myregob *x, long ac, t_atom *av);

void minimetro_init(void);

void *myregob_class;
            
void main(void)
{   
    t_class *c;
    void    *attr;
    long    attrflags = 0;
    
    c = class_new("myregob", (method)myregob_new, (method)myregob_free, (short)sizeof(t_myregob), 
        0L, A_GIMME, 0);
    
    // initialize the common symbols, since we want to use them
    common_symbols_init();
    
    // initialize the minimetro class
    minimetro_init();
    
    // register the byte offset of obex with the class
    class_obexoffset_set(c, calcoffset(t_myregob, obex));
    
    // add some attributes
    
    // add methods to the class
    class_addmethod(c, (method)myregob_int,     "int",      A_LONG,0);  
    class_addmethod(c, (method)myregob_speed,   "speed",    A_FLOAT,0);  
    class_addmethod(c, (method)myregob_assist,  "assist",   A_CANT,0);  

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

    // add a notify method, so we get notifications from child objects
    class_addmethod(c, (method)myregob_notify,          "notify",       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);
    myregob_class = c;
}

t_max_err myregob_getvalueof(t_myregob *x, long *ac, t_atom **av)
{
    // not implemented
    return MAX_ERR_NONE;
}

t_max_err myregob_setvalueof(t_myregob *x, long ac, t_atom *av)
{
    // not implemented
    return MAX_ERR_NONE;
}

void myregob_assist(t_myregob *x, void *b, long m, long a, char *s)
{
    if (m == 1) { //input
        sprintf(s, "0 / 1, speed");
    } 
    else {  //output
        if (a == x->count)
            sprintf(s, "dumpout"); 
        else
            sprintf(s, "bang out");
    }
}

void myregob_int(t_myregob *x, long c)
{
    long inlet;
    
    inlet = proxy_getinlet((t_object *)x);
    
    if (inlet >= x->count)
        return;

    // send a method to the appropriate minimetro to turn it on or off
    object_method(x->mmo[inlet], gensym("onoff"), c);
}

void myregob_speed(t_myregob *x, double speed)
{
    t_symbol *newname;
    long inlet;
    t_object *mmo;
    
    inlet = proxy_getinlet((t_object *)x);
    
    if (inlet >= x->count)
        return;
        
    if (speed < 0.)
        speed = 0.;
    
    mmo = x->mmo[inlet];
    // set the speed attribute of the internal minimetro object
    object_attr_setfloat(mmo, gensym("speed"), speed);
}

void myregob_notify(t_myregob *x, t_symbol *s, t_symbol *msg, void *sender, void *data)
{
    if (msg == _sym_bang) {
        // bang the outlet sent as data
        outlet_bang(x->out[(long)data]);
    }
    else if (msg == _sym_free) { // this message is sent when the object is freeing
        object_detach(gensym("_regob_test"), s, x);
        //object_unregister(sender); // DO NOT UNREGISTER IN RESPONSE TO FREE NOTIFICATION -jkc
    }
}

void myregob_free(t_myregob *x)
{
    long i;
    
    if (x->mmo) {
        for (i = 0; i < x->count; i++) {
            object_free(x->mmo[i]);
        }
        freebytes(x->mmo, sizeof(void *) * x->count);
    }
    if (x->proxy) {
        for (i = 1; i < x->count; i++) {
            freeobject(x->proxy[i]);
        }
        freebytes(x->proxy, sizeof(void *) * x->count);
    }
    if (x->out)
        freebytes(x->out, sizeof(void *) * x->count);
}

void *myregob_new(t_symbol *s, long ac, t_atom *av)
{
    t_myregob *x;
    t_symbol *name;
    long i;

    // we use object_alloc here, rather than newobject
    if (x = (t_myregob *)object_alloc(myregob_class)) { //only max object, no jit object
        // add a dumpout outlet
        object_obex_store(x, _sym_dumpout, outlet_new(x, NULL));
        
        if (ac && av) {
            // allocate memory for the proxy pointers
            x->proxy = (void **)getbytes(sizeof(void *) * ac);
            x->proxy[0] = 0; // unused
            // allocate memory for the outlet pointers
            x->out = (void **)getbytes(sizeof(void *) * ac);
            // allocate memory for the minimetro pointers
            x->mmo = (void **)getbytes(sizeof(void *) * ac);
            x->count = ac;

            for (i = ac - 1; i >= 0; i--) {
                if (i) // don't make a 0th proxy
                    x->proxy[i] = proxy_new(x, i, &x->inlet_no);
                // create some outlets
                x->out[i] = outlet_new(x, 0L);
                
                // create some minimetro objects
                x->mmo[i] = object_new(CLASS_NOBOX, gensym("minimetro"), i, atom_getlong(av + i));
                object_register(gensym("_regob_test"), name = symbol_unique(), x->mmo[i]);
                object_attach(gensym("_regob_test"), name, x);
            }
        } else {
            x->proxy = NULL;
            x->out = NULL;
            x->mmo = NULL;
            x->count = 0;
        }
        attr_args_process(x, ac, av);
    }
    return (x);
}

Copyright © 2008, Cycling '74