Max 5 API Reference

jit.qt.component.c

/* 
    jit.qtcomponent.c

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

#include "jit.common.h"

static unsigned long _jit_qt_component_uid = 0;

typedef struct _jit_qt_component 
{
    t_jit_object                        ob;
    Component                           c;
    struct _jit_qt_component_instance   *instance;
    long                                instance_count;
    t_symbol                            *name;
    t_symbol                            *owner_instance_name;
} t_jit_qt_component;
    
typedef struct _jit_qt_component_instance 
{
    ComponentInstance                   ci;
    t_symbol                            *instance_name;
    struct _jit_qt_component_instance   *prev;
    struct _jit_qt_component_instance   *next;
    struct _jit_qt_component_objlist        *objlist;
    long                                objlist_count; // number of attached objects
    long                                misc; // general slot for a pointer
} t_jit_qt_component_instance;

typedef struct _jit_qt_component_objlist
{
    void                                *obj;
    struct _jit_qt_component_objlist        *prev;
    struct _jit_qt_component_objlist        *next;
} t_jit_qt_component_objlist;

t_jit_err jit_qt_component_init(void);
void jit_qt_component_access_notify(t_jit_qt_component *o, void *x);
void *jit_qt_component_open(void *x, Component c, t_symbol *instance_name);
t_jit_err jit_qt_component_close(void *x, void *o);
void *jit_qt_component_new(Component c, t_symbol *instance_name);
t_jit_err jit_qt_component_free(t_jit_qt_component *x);
ComponentInstance jit_qt_component_getinstance(t_jit_qt_component *o, void *x);
t_symbol *jit_qt_component_getinstancename(t_jit_qt_component *o, void *x);
GWorldPtr jit_qt_component_getgworld(t_jit_qt_component *o, void *x);
void jit_qt_component_clear_misc(t_jit_qt_component *o, void *x);
long jit_qt_component_count(t_jit_qt_component *x);
t_jit_qt_component_instance *jit_qt_component_instance_new(t_jit_qt_component *o, t_symbol *instance_name);
t_jit_qt_component_objlist *jit_qt_component_objlist_new(void *x);
t_symbol *jit_qt_component_instance_name_unique(void);
long jit_qt_component_getcount(t_jit_qt_component *o, void *x);
long jit_qt_component_is_owner(t_jit_qt_component *o, void *x);
t_symbol *jit_qt_component_getowner(t_jit_qt_component *o);

void *_jit_qt_component_class;

t_jit_err jit_qt_component_init(void)
{
    void *attr;
    long attrflags = 0;
    
    _jit_qt_component_class = jit_class_new("jit_qt_component",(method)jit_qt_component_new,(method)jit_qt_component_free,
        sizeof(t_jit_qt_component),A_CANT,0L); //A_CANT = untyped

    attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"name",_jit_sym_symbol,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_qt_component,name));
    jit_class_addattr(_jit_qt_component_class,attr);
        
    jit_class_addmethod(_jit_qt_component_class, (method)jit_method_true, "class_jit_qt_component" , A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_object_register, "register",   A_CANT, 0L); //can register
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_getowner, "getowner", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_is_owner, "is_owner", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_getinstance, "getinstance", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_getcount, "getcount", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_getinstancename, "getinstancename", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_getgworld, "getgworld", A_CANT, 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_access_notify, "access", 0L);
    jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_clear_misc, "clear_misc", 0L);
//  jit_class_addmethod(_jit_qt_component_class, (method)jit_qt_component_count, "count", 0L);

    jit_class_register(_jit_qt_component_class);
    return JIT_ERR_NONE;
}

long jit_qt_component_getcount(t_jit_qt_component *o, void *x)
{
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    
    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered
                    return instance->objlist_count;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
    return 0L;
}

long jit_qt_component_is_owner(t_jit_qt_component *o, void *x)
{
    t_symbol *owner_name;
    t_symbol *instance_name;
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    
    
    if (x && o) {
        owner_name =  o->owner_instance_name;

        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered
                    instance_name = instance->instance_name;
                    goto compare;
                }
                list = list->next;
            }
            instance = instance->next;
        }
        
compare:
//          jit_object_post((t_object *)x,"owner_name: %s, instance_name: %s", owner_name->s_name, instance_name->s_name);
            if (owner_name == instance_name)
                return 1;
            else
                return 0;
    }
    return -1;
}

t_symbol *jit_qt_component_getowner(t_jit_qt_component *o)
{
    if (o) {
        return o->owner_instance_name;
    }
    return NULL;
}


t_symbol *jit_qt_component_getinstancename(t_jit_qt_component *o, void *x)
{
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    
    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered
                    return instance->instance_name;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
    return NULL;
}

ComponentInstance jit_qt_component_getinstance(t_jit_qt_component *o, void *x)
{
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    
    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered
//                  jit_object_post((t_object *)x,"found object");
                    return instance->ci;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
    return NULL;
}

GWorldPtr jit_qt_component_getgworld(t_jit_qt_component *o, void *x)
{
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;

    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (x == list->obj) { // object is registered
                    if (instance->ci && !instance->misc)
                        QTVideoOutputGetGWorld(instance->ci, (GWorldPtr *)(&instance->misc));
                    return (GWorldPtr)instance->misc;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
    return NULL;
}

void jit_qt_component_clear_misc(t_jit_qt_component *o, void *x)
{   
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;

    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (x == list->obj) { // object is registered
                    instance->misc = 0L;
                    return;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
}

void jit_qt_component_access_notify(t_jit_qt_component *o, void *x)
{   
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    
    if (x && o) {
        instance = o->instance;
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered
                    o->owner_instance_name = instance->instance_name;
                }
                list = list->next;
            }
            instance = instance->next;
        }
    }
    
    jit_object_notify(o, gensym("qtcomponent_accessed"),NULL);
}
/*
long jit_qt_component_count(t_jit_qt_component *x)
{
    void *o=NULL;
    
    o = jit_robject_findbyptr(x);

    if (o) { 
        return jit_attr_getlong(o, gensym("refcount"));
    }
    else return 0;
}
*/
        
t_symbol *jit_qt_component_instance_name_unique(void)
{
    char s[256];
    
    sprintf(s,"c%03d%06d",jit_rand()%1000,++_jit_qt_component_uid); //randomize the first 3 digits for better hashing

    return gensym(s);   
} 

void *jit_qt_component_open(void *x, Component c, t_symbol *instance_name)
{
    char str[256];
    void *o;
    t_symbol *s;
    t_jit_qt_component *qtc;
    t_jit_qt_component_instance *instance;
    t_jit_qt_component_objlist *list;
    t_jit_qt_component_objlist *newlist;

    if (!c)
        return NULL;
        
    if (!instance_name)
        instance_name = _jit_sym_nothing;
    if (instance_name == gensym("unique"))
        instance_name = jit_qt_component_instance_name_unique();

    sprintf(str, "_qtcomponent%x", c);
    s = gensym(str);

    o = jit_object_findregistered(s);
    if (o) {        
        if (jit_object_method(o, gensym("class_jit_qt_component"))) {
            jit_object_register(o, s);
            jit_object_attach(s, x);
//          jit_object_post((t_object *)x,"found registered");
            
            qtc = o;
            instance = qtc->instance;
            while (instance) {
                if (instance->instance_name == instance_name)
                    break;
                else {
                    if (instance->next)
                        instance = instance->next;
                    else { // we're at the last entry. make a new instance
                        t_jit_qt_component_instance *new_instance;
                        
                        new_instance = jit_qt_component_instance_new(qtc, instance_name);
                        if (new_instance) {
                            instance->next = new_instance;
                            new_instance->prev = instance;
                            qtc->instance_count++;
                        }
                        else {
                            error("jit.qt.component: could not create component instance");
                            goto failed;
                        }
                        
                        instance = new_instance; // and make a new objlist
                        list = jit_qt_component_objlist_new(x);
                        if (list) {
                            instance->objlist = list;
                            instance->objlist_count = 1;
                        }
                        else {
                            error("jit.qt.component: could not create object list");
                            goto badinstance;
                        }
                        return o;
                    }
                }
            }
            
            if (instance) { // we're requesting a connection to this instance
                list = instance->objlist;
                while (list->next)
                    list = list->next; // go to end of the object list
                newlist = jit_qt_component_objlist_new(x);
                if (newlist) {
                    newlist->prev = list;
                    list->next = newlist;
                    instance->objlist_count++;
                }
                else {
                    error("jit.qt.component: could not create object list");
                    goto failed;
                }
            }
        }
        else {
            error("jit.qt.component: wrong object type");
            return NULL;
        }
    }
    else {
        o = jit_object_new(gensym("jit_qt_component"), c, instance_name); // new instance will be created
        if (o) {
            jit_attr_setsym(o,_jit_sym_name,s);
            jit_object_register(o, s);
            jit_object_attach(s, x);
            
            qtc = o;
            instance = qtc->instance;
            
            list = jit_qt_component_objlist_new(x);
            if (list) {
                instance->objlist = list;
                instance->objlist_count = 1;
            }
            else {
                error("jit.qt.component: could not create object list");
                goto badinstance;
            }
        }
    }
    
    return o;
    
badinstance: // only happens with a new object, but what the hell
    if (instance) {
        jit_freebytes(instance, sizeof(t_jit_qt_component_instance));
        qtc->instance_count--;
    }
    
failed: // don't kill the instance -- it was preexisting
    if (s && o) {
        jit_object_free(o);
        jit_object_detach(s, x);
        o = NULL;
        return o;
    }
    return NULL;
}

t_jit_err jit_qt_component_close(void *x, void *o)
{
    t_symbol *s = NULL;
    t_jit_qt_component *qtc;
    t_jit_qt_component_instance *instance, *prev, *next;
    t_jit_qt_component_objlist *list, *listprev, *listnext;
    long err = 0;
    
    if (x && o) {
        qtc = o;
        instance = qtc->instance;

//      jit_object_post((t_object *)x,"instance_count: %d, objlist_count: %d", qtc->instance_count, instance->objlist_count);
        while (instance) {
            list = instance->objlist;
            while (list) {
                if (list->obj == x) { // object is registered, remove it
                    listprev = list->prev;
                    listnext = list->next;
                    
                    if (listprev)
                        listprev->next = list->next;
                    else
                        instance->objlist = list->next;
                    if (listnext)
                        listnext->prev = list->prev;
                    jit_freebytes(list, sizeof(t_jit_qt_component_objlist));
//                  jit_object_post((t_object *)x,"object removed");
                        
                    if (!(--(instance->objlist_count))) { // kill the instance, too
                        prev = instance->prev;
                        next = instance->next;
                        if (prev)
                            prev->next = instance->next;
                        else 
                            qtc->instance = instance->next;
                        if (next)
                            next->prev = instance->prev;
                        err = CloseComponent(instance->ci);
//                      if (err) jit_object_post((t_object *)x,"error closing qtcomponent: %d", err);
                        jit_freebytes(instance, sizeof(t_jit_qt_component_instance));
                        qtc->instance_count--;
//                      jit_object_post((t_object *)x,"instance closed");
                    }
                    
                    goto detach;
                }
                list = list->next;
            }
            instance = instance->next;
        }           

detach:
        s = jit_attr_getsym(o,_jit_sym_name);
        jit_object_free(o);
        jit_object_detach(s, x);
    }
    return err;
}

t_jit_err jit_qt_component_free(t_jit_qt_component *x)
{
//  jit_object_post((t_object *)x,"freeing jit_qt_component");
    return JIT_ERR_NONE;
}

t_jit_qt_component_objlist *jit_qt_component_objlist_new(void *x)
{
    t_jit_qt_component_objlist      *list = NULL;
    
    if (x) {
        list = (t_jit_qt_component_objlist *)jit_getbytes(sizeof(t_jit_qt_component_objlist)); // attach object to instance list
        if (list) {
            list->obj = x;
            list->prev = NULL;
            list->next = NULL;
        }
    }
    return list;
}

t_jit_qt_component_instance *jit_qt_component_instance_new(t_jit_qt_component *o, t_symbol *instance_name)
{
    ComponentInstance           ci;
    t_jit_qt_component_instance *instance = NULL;
    
    if (o && o->c) {
        ci = OpenComponent(o->c);
        if (ci) {
            instance = (t_jit_qt_component_instance *)jit_getbytes(sizeof(t_jit_qt_component_instance));//jit_object_new(gensym("jit_qt_component_instance"), ci);
            if (instance) {
                instance->ci = ci;
                instance->next = NULL;
                instance->prev = NULL;
//              instance->share = 1;
                instance->misc = 0L;
                instance->objlist_count = 0;
                instance->objlist = NULL;
                instance->instance_name = instance_name;
            }
            else {
                error("jit.qt.qtcomponent: out of memory");
                CloseComponent(ci);
            }
        }
    }
    return instance;
}

void *jit_qt_component_new(Component c, t_symbol *instance_name)
{
    t_jit_qt_component *x;
    ComponentInstance ci;

    if (x=(t_jit_qt_component *)jit_object_alloc(_jit_qt_component_class)) {
        x->c = c;
        x->instance = jit_qt_component_instance_new(x, instance_name);
        if (x->instance) {
            x->instance_count = 1;
        }
        else { // must have at least one instance
            jit_object_free(x);
            x = NULL;
            return x;
        }
    }
    else {
        jit_object_free(x);
        x = NULL;
    }
    return x;
}

Copyright © 2008, Cycling '74