void WrappedMapperClass_new(TTPtr self, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_symbol *relativeAddress;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
// possible relativeAddress
if (attrstart && argv)
relativeAddress = atom_getsym(argv);
else
relativeAddress = _sym_nothing;
if (relativeAddress) x->address = TTAddress(relativeAddress->s_name);
jamoma_mapper_create((t_object*)x, x->wrappedObject);
// Make two outlets
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
x->outlets[data_out] = outlet_new((t_object*)x, NULL); // anything outlet to output data
x->dumpOut = outlet_new((t_object*)x, NULL);
// handle attribute args
attr_args_process(x, argc, argv);
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
EXTRA->arguments = new TTValue();
jamoma_ttvalue_from_Atom(*EXTRA->arguments, _sym_nothing, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
// map_subscribe(x);
// defer_low((t_object*)x, (method)map_subscribe, NULL, 0, 0);
}
TTErr wrappedModularClass_setAttribute(TTPtr self, t_symbol *s, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue inputValue, outputValue;
TTSymbol ttName;
TTAttributePtr anAttribute= NULL;
long ac = 0;
t_atom *av = NULL;
TTErr err;
err = selectedObject->findAttribute(TTSymbol(s->s_name), &anAttribute);
if (!err) {
// set attribute's value
if (argc && argv) {
jamoma_ttvalue_from_Atom(inputValue, _sym_nothing, argc, argv);
selectedObject->setAttributeValue(TTSymbol(s->s_name), inputValue);
}
// or get it and dumpout his value
else {
selectedObject->getAttributeValue(TTSymbol(s->s_name), outputValue);
jamoma_ttvalue_to_Atom(outputValue, &ac, &av);
object_obex_dumpout(self, s, ac, av);
sysmem_freeptr(av);
}
}
return err;
}
void WrappedInputClass_new(TTPtr self, AtomCount argc, AtomPtr argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTString sInstance;
TTValue v;
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
// Get input instance symbol
if (attrstart && argv) {
jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv);
v.toString();
sInstance = TTString(v[0]);
EXTRA->instance = TTSymbol(sInstance.data());
}
else
EXTRA->instance = kTTSymEmpty;
// Create Input Object and one outlet
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
#ifdef JCOM_IN_TILDE
jamoma_input_create_audio((ObjectPtr)x, &x->wrappedObject);
dsp_setup((t_pxobject *)x, 1);
x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST;
outlet_new((t_pxobject *)x, "signal");
// Prepare memory to store internal datas
x->internals = new TTHash();
// Prepare extra data for envelope tracking
EXTRA->clock = NULL;
EXTRA->pollInterval = 0; // not active by default
EXTRA->meter = 0.;
EXTRA->peak = 0.;
#else
jamoma_input_create((ObjectPtr)x, &x->wrappedObject);
x->outlets[0] = outlet_new(x, 0L);
#endif
// handle attribute args
attr_args_process(x, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
defer_low((ObjectPtr)x, (method)in_subscribe, NULL, 0, NULL);
}
void data_dec(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, none;
jamoma_ttvalue_from_Atom(v, _sym_nothing, argc, argv);
x->wrappedObject.send("Dec", v, none);
}
void data_dec(TTPtr self, t_symbol *msg, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, none;
jamoma_ttvalue_from_Atom(v, _sym_nothing, argc, argv);
selectedObject->sendMessage(TTSymbol("Dec"), v, none);
}
void WrappedOutputClass_new(TTPtr self, long argc, t_atom* argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTString sInstance;
TTValue v;
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
// Get input instance symbol
if (attrstart && argv) {
jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv);
v.toString();
sInstance = TTString(v[0]);
EXTRA->instance = TTSymbol(sInstance.data());
}
else
EXTRA->instance = kTTSymEmpty;
// Create Input Object and one outlet
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
#ifdef J_OUT_TILDE
jamoma_output_create_audio((t_object*)x, x->wrappedObject);
dsp_setup((t_pxobject *)x, 1);
x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST;
outlet_new((t_pxobject *)x, "signal");
#endif
#ifdef J_OUT_MULTI
jamoma_output_create_audio((t_object*)x, x->wrappedObject);
x->outlets[0] = outlet_new(x, 0L);
#endif
#ifndef J_OUT_TILDE
#ifndef J_OUT_MULTI
jamoma_output_create((t_object*)x, x->wrappedObject);
x->outlets[0] = outlet_new((t_object*)x, 0L);
#endif
#endif
// handle attribute args
attr_args_process(x, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
// out_subscribe(x);
// defer_low((t_object*)x, (method)out_subscribe, NULL, 0, NULL);
}
void map_list(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue inputValue, outputValue;
jamoma_ttvalue_from_Atom(inputValue, msg, argc, argv);
x->wrappedObject.send(kTTSym_Map, inputValue, outputValue);
// we don't send the output value here because there is callback for this
}
void map_list(TTPtr self, SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue inputValue, outputValue;
jamoma_ttvalue_from_Atom(inputValue, msg, argc, argv);
x->wrappedObject->sendMessage(kTTSym_Map, inputValue, outputValue);
// we don't send the output value here because there is callback for this
}
void WrappedDataClass_new(TTPtr self, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_symbol* relativeAddress;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
// check address argument
relativeAddress = _sym_nothing;
if (attrstart && argv)
if (atom_gettype(argv) == A_SYM)
relativeAddress = atom_getsym(argv);
if (relativeAddress == _sym_nothing) {
object_error((t_object*)x, "needs a name as first argument");
return;
}
// check for reserved address
if (relativeAddress == gensym("data/mute") ||
relativeAddress == gensym("data/bypass") ||
relativeAddress == gensym("data/freeze") ||
relativeAddress == gensym("data/preview") ||
relativeAddress == gensym("audio/mute") ||
relativeAddress == gensym("audio/bypass") ||
relativeAddress == gensym("audio/mix") ||
relativeAddress == gensym("audio/gain") ||
relativeAddress == gensym("model") ||
relativeAddress == gensym("preset") ) {
object_error((t_object*)x, "%s address is reserved by j.model", relativeAddress->s_name);
return;
}
x->useInternals = false;
// Make outlets (before attr_args_process)
/////////////////////////////////////////////////////////////////////////////////
// Don't create outlets during dynamic changes
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 2);
x->outlets[data_out] = outlet_new(x, NULL); // anything outlet to output data
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
EXTRA->arrayArgs = new TTValue();
// Store arguments
if (argc > 1 && argv)
jamoma_ttvalue_from_Atom(*(EXTRA->arrayArgs), _sym_list, argc--, argv++);
data_new_address(self, relativeAddress, argc--, argv++);
}
TTErr wrappedModularClass_sendMessage(TTPtr self, t_symbol *s, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue inputValue, outputValue;
TTSymbol ttName;
TTMessagePtr aMessage = NULL;
long ac = 0;
t_atom *av = NULL;
t_max_err m_err;
TTErr err;
TTPtr ptr;
m_err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, s, (t_object**)&ptr);
if (!m_err)
{
// Is it a message of the wrapped object ?
ttName = TTSymbol(ptr);
err = selectedObject->findMessage(ttName, &aMessage);
if (!err)
{
// send message
if (argc && argv)
{
jamoma_ttvalue_from_Atom(inputValue, _sym_nothing, argc, argv);
selectedObject->sendMessage(ttName, inputValue, outputValue);
inputValue.append(outputValue);
jamoma_ttvalue_to_Atom(inputValue, &ac, &av);
object_obex_dumpout(self, s, ac, av);
sysmem_freeptr(av);
}
else
{
selectedObject->sendMessage(ttName);
object_obex_dumpout(self, s, ac, av);
}
}
return err;
}
else
return kTTErrGeneric;
}
void cue_set(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTHashPtr allCues;
TTValue v;
TTSymbol name, attribute;
TTObject cue;
if (argc >= 2) {
if (atom_gettype(argv) == A_SYM && atom_gettype(argv+1) == A_SYM) {
attribute = TTSymbol((char*)atom_getsym(argv)->s_name);
name = TTSymbol((char*)atom_getsym(argv+1)->s_name);
// get cue object table
x->wrappedObject.get("cues", v);
allCues = TTHashPtr((TTPtr)v[0]);
if (allCues) {
// get cue
if (!allCues->lookup(name, v)) {
cue = v[0];
// prepare value to set
jamoma_ttvalue_from_Atom(v, _sym_nothing, argc-2, argv+2);
if (cue.set(attribute, v))
object_error((t_object*)x, "%s attribute doesn't exist", atom_getsym(argv)->s_name);
}
else
object_error((t_object*)x, "%s cue doesn't exist", atom_getsym(argv+1)->s_name);
}
}
}
}
t_max_err wrappedModularClass_attrSet(TTPtr self, t_object *attr, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_symbol *attrName = (t_symbol*)object_method(attr, _sym_getname);
TTValue v;
long ac = 0;
t_atom *av = NULL;
t_max_err m_err;
TTErr err;
TTPtr ptr;
// for an array of wrapped object
if (x->useInternals && !x->iterateInternals) {
TTValue keys;
// temporary set x->iterateInternals to YES
x->iterateInternals = YES;
// then recall this method for each element of the array
if (!x->internals->isEmpty()) {
err = x->internals->getKeys(keys);
if (!err) {
for (TTUInt32 i = 0; i < keys.size(); i++) {
x->cursor = keys[i];
wrappedModularClass_attrSet(self, attr, argc, argv);
}
}
}
// reset x->iterateInternals to NO
x->iterateInternals = NO;
return MAX_ERR_NONE;
}
m_err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, attrName, (t_object**)&ptr);
if (m_err)
return m_err;
TTSymbol ttAttrName(ptr);
// set attribute's value
if (argc && argv) {
jamoma_ttvalue_from_Atom(v, _sym_nothing, argc, argv);
if (selectedObject) {
selectedObject->setAttributeValue(ttAttrName, v);
return MAX_ERR_NONE;
}
else
return MAX_ERR_GENERIC;
}
// or get it and dumpout his value
else {
if (selectedObject) {
// don't consider array case here (they should have all the same attribute value)
selectedObject->getAttributeValue(ttAttrName, v);
jamoma_ttvalue_to_Atom(v, &ac, &av);
object_obex_dumpout(self, attrName, ac, av);
sysmem_freeptr(av);
return MAX_ERR_NONE;
}
else
return MAX_ERR_GENERIC;
}
return MAX_ERR_GENERIC;
}
void WrappedDataClass_new(TTPtr self, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_symbol *relativeAddress;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTValue none;
// check address argument
relativeAddress = _sym_nothing;
if (attrstart && argv)
if (atom_gettype(argv) == A_SYM)
relativeAddress = atom_getsym(argv);
if (relativeAddress == _sym_nothing) {
object_error((t_object*)x, "needs a name as first argument");
x->extra = NULL;
return;
}
// add an inlet for the index
x->inlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 1);
x->inlets[0] = proxy_new(x, 1, &x->index); // use this member to store index (because index is used for data array)
// Make outlets (before attr_args_process)
/////////////////////////////////////////////////////////////////////////////////
// Don't create outlets during dynamic changes
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 2);
x->outlets[index_out] = outlet_new(x, NULL); // long outlet to output data index
x->outlets[data_out] = outlet_new(x, NULL); // anything outlet to output data
x->useInternals = YES;
x->internals->setThreadProtection(YES);
x->arraySize = 0;
x->arrayIndex = 0;
x->arrayAddress = kTTAdrsEmpty;
x->arrayArgs = none;
x->arrayAttrFormat = gensym("single");
// Prepare extra data for parameters and messages
x->extra = (t_extra*)malloc(sizeof(t_extra));
EXTRA->changingAddress = NO;
EXTRA->firstArray = YES;
EXTRA->objectsSorted = new TTList();
// handle args
if (argc && argv) {
// set the external attribute
attr_args_process(x, argc, argv);
// keep args to set the wrapped object attributes
if (argc > 1)
jamoma_ttvalue_from_Atom(x->arrayArgs, _sym_list, argc--, argv++);
}
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
defer_low((t_object*)x, (method)data_new_address, relativeAddress, 0, NULL);
}
