Max 5 API Reference

jit.atom.c

/* 
    jit.atom.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/
#include "jit.common.h"

/**
 *  @defgroup atommod Atom Module
    @ingroup jitter
 */


/**
 * Sets atom value to long integer.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * @param   b       integer value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_atom_setlong(t_atom *a, long b)
{
    if (a) {
        a->a_type   = A_LONG;
        a->a_w.w_long = b;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Sets atom value to floating point number.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * @param   b       floating point value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_atom_setfloat(t_atom *a, double b)
{
    if (a) {
        a->a_type   = A_FLOAT;
        a->a_w.w_float = b;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Sets atom value to symbol.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * @param   b       symbol value
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_atom_setsym(t_atom *a, t_symbol *b)
{
    if (a) {
        a->a_type   = A_SYM;
        a->a_w.w_sym = b;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}
                
/**
 * Sets atom value to object pointer.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * @param   b       object pointer
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_atom_setobj(t_atom *a, void *b)
{
    if (a) {
        a->a_type   = A_OBJ;
        a->a_w.w_obj = b;
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

/**
 * Retrieves atom value as long integer.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * 
 * @return  long integer value. 0 if atom has no numeric value.
 *
 */
long jit_atom_getlong(t_atom *a)
{
    long b=0;
    
    if (a) {
        switch (a->a_type) {
        case A_LONG:    b = a->a_w.w_long;  break;
        case A_FLOAT:   b = a->a_w.w_float; break;
        }
    }   
    return b;
}

/**
 * Retrieves atom value as floating point number.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * 
 * @return  floating point value. 0 if atom has no numeric value.
 *
 */
double jit_atom_getfloat(t_atom *a)
{
    double b=0;
    
    if (a) {
        switch (a->a_type) {
        case A_LONG:    b = a->a_w.w_long;  break;
        case A_FLOAT:   b = a->a_w.w_float; break;
        }
    }   
    return b;
}

/**
 * Retrieves atom value as symbol pointer.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * 
 * @return  symbol pointer. _jit_sym_nothing if atom has no symbolic value.
 *
 */
t_symbol *jit_atom_getsym(t_atom *a)
{
    t_symbol *b=_jit_sym_nothing;
    
    if (a) {
        switch (a->a_type) {
        case A_SYM:     b = a->a_w.w_sym;   break;
        }
        if (!b) b= _jit_sym_nothing; 
    }   
    return b;
}

/**
 * Retrieves atom value as object pointer.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * 
 * @return  object pointer. NULL if atom has no object value.
 *
 */
void *jit_atom_getobj(t_atom *a)
{
    t_jit_object *b=NULL;
    
    if (a) {
        switch (a->a_type) {
        case A_OBJ:     b = a->a_w.w_obj;   break;
        }
    }   
    return b;
}

/**
 * Retrieves atom value as an 8 bit fixed point number.
 *
 * @ingroup atommod 
 *
 * @param   a       atom pointer
 * 
 * @return  8 bit fixed point value in the range 0-255. 0 if atom has no numeric value.
 *
 */
long jit_atom_getcharfix(t_atom *a)
{
    long b=0;
    
    if (a) {
        switch (a->a_type) {
        case A_LONG:    b = a->a_w.w_long;          break;
        case A_FLOAT:   b = a->a_w.w_float*255.;    break;
        }
    }
    CLIP(b,0,255);  
    return b;
}

//the following are useful for setting the values _only_ if there is an arg
//rather than setting it to 0 or _jit_sym_nothing

/**
 * Retrieves atom argument at index as long integer if present.
 * This function is useful for setting the values only if there is an
 * argument at the specified index, otherwise, the input value is untouched.
 *
 * @ingroup atommod 
 *
 * @param   c           pointer to long (should contain desired default)
 * @param   idx         atom argument index
 * @param   ac          atom argument count
 * @param   av          atom argument vector
 * 
 * @return  t_jit_err error code. JIT_ERR_NONE if successful.
 *
 */
long jit_atom_arg_getlong(long *c, long idx, long ac, t_atom *av)
{
    if (c&&ac&&av&&(idx<ac)) {
        *c = jit_atom_getlong(av+idx); 
        return JIT_ERR_NONE;
    } else  
        return JIT_ERR_GENERIC;
}

/**
 * Retrieves atom argument at index as floating point number if present.
 * This function is useful for setting the values only if there is an
 * argument at the specified index, otherwise, the input value is untouched.
 *
 * @ingroup atommod 
 *
 * @param   c           pointer to float (should contain desired default)
 * @param   idx         atom argument index
 * @param   ac          atom argument count
 * @param   av          atom argument vector
 * 
 * @return  t_jit_err error code. JIT_ERR_NONE if successful.
 *
 */
long jit_atom_arg_getfloat(float *c, long idx, long ac, t_atom *av)
{
    if (c&&ac&&av&&(idx<ac)) {
        *c = jit_atom_getfloat(av+idx); 
        return JIT_ERR_NONE;
    } else  
        return JIT_ERR_GENERIC;
}

/**
 * Retrieves atom argument at index as double precision floating point number if present.
 * This function is useful for setting the values only if there is an
 * argument at the specified index, otherwise, the input value is untouched.
 *
 * @ingroup atommod 
 *
 * @param   c           pointer to double (should contain desired default)
 * @param   idx         atom argument index
 * @param   ac          atom argument count
 * @param   av          atom argument vector
 * 
 * @return  t_jit_err error code. JIT_ERR_NONE if successful.
 *
 */
long jit_atom_arg_getdouble(double *c, long idx, long ac, t_atom *av)
{
    if (c&&ac&&av&&(idx<ac)) {
        *c = jit_atom_getfloat(av+idx); 
        return JIT_ERR_NONE;
    } else  
        return JIT_ERR_GENERIC;
}

/**
 * Retrieves atom argument at index as symbol pointer if present.
 * This function is useful for setting the values only if there is an
 * argument at the specified index, otherwise, the input value is untouched.
 *
 * @ingroup atommod 
 *
 * @param   c           pointer to symbol pointer (should contain desired default)
 * @param   idx         atom argument index
 * @param   ac          atom argument count
 * @param   av          atom argument vector
 * 
 * @return  t_jit_err error code. JIT_ERR_NONE if successful.
 *
 */
long jit_atom_arg_getsym(t_symbol **c, long idx, long ac, t_atom *av)
{
    if (c&&ac&&av&&(idx<ac)) {
        *c = jit_atom_getsym(av+idx); 
        return JIT_ERR_NONE;
    } else  
        return JIT_ERR_GENERIC;
}

Copyright © 2008, Cycling '74