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 map_reset(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long argc = 0;
t_atom *argv = NULL;
jamoma_ttvalue_to_Atom(*EXTRA->arguments, &argc, &argv);
// handle attribute args to reset to creation state
attr_args_process(x, argc, argv);
}
void data_address(TTPtr self, t_symbol *address)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long argc = 0;
t_atom *argv = NULL;
// unregister wrapped object (or internals)
wrappedModularClass_unregister(x);
// use stored arguments
jamoma_ttvalue_to_Atom(*(EXTRA->arrayArgs), &argc, &argv);
// rebuild wrapped object (or internals)
defer_low(self,(method)data_new_address, address, 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_get(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTHashPtr allCues;
TTValue v;
TTSymbol name, attribute;
TTObject cue;
long ac = 0;
t_atom *av = NULL;
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];
if (!cue.get(attribute, v)) {
v.prepend(name);
jamoma_ttvalue_to_Atom(v, &ac, &av);
object_obex_dumpout(self, atom_getsym(argv), ac, av);
}
else
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);
}
}
}
}
void wrappedModularClass_dump(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue names, v;
TTUInt32 i;
TTSymbol aName, address;
t_symbol *s;
long ac;
t_atom *av;
#ifndef ARRAY_EXTERNAL
t_atom a;
if (x->subscriberObject.valid())
{
// send out the absolute address of the subscriber
x->subscriberObject.get("nodeAddress", v);
address = v[0];
atom_setsym(&a, gensym((char *) address.c_str()));
object_obex_dumpout(self, gensym("address"), 1, &a);
}
#endif
selectedObject->getAttributeNames(names);
for (i = 0; i < names.size(); i++) {
aName = names[i];
selectedObject->getAttributeValue(aName, v);
s = jamoma_TTName_To_MaxName(aName);
ac = 0;
av = NULL;
jamoma_ttvalue_to_Atom(v, &ac, &av);
object_obex_dumpout(self, s, ac, av);
sysmem_freeptr(av);
}
}
t_max_err wrappedModularClass_attrGet(TTPtr self, t_object *attr, long* argc, t_atom** argv)
{
t_symbol *attrName = (t_symbol*)object_method(attr, _sym_getname);
TTValue v;
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
t_max_err err;
TTPtr ptr;
err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, attrName, (t_object**)&ptr);
if (err)
return err;
TTSymbol ttAttrName(ptr);
if (selectedObject)
{
selectedObject->getAttributeValue(ttAttrName, v);
jamoma_ttvalue_to_Atom(v, argc, argv);
}
return MAX_ERR_NONE;
}
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 data_new_address(TTPtr self, t_symbol *relativeAddress)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long argc = 0;
t_atom *argv = NULL;
TTUInt32 number;
TTUInt32 i;
TTAddress newAddress = relativeAddress->s_name;
TTAddress returnedAddress;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
t_symbol *instanceAddress;
TTObject anObject;
TTObject aSubscriber;
TTValue v;
x->useInternals = YES;
x->internals->clear();
x->internals->setThreadProtection(YES);
x->cursor = kTTSymEmpty;
x->arrayAddress = newAddress;
if (x->arrayAddress.getType() == kAddressRelative) {
number = jamoma_parse_bracket(relativeAddress, x->arrayFormatInteger, x->arrayFormatString);
// don't resize to 0
if (number && number <= MAX_ARRAY_SIZE) {
// Starts iteration on internals
x->iterateInternals = YES;
x->arraySize = number;
EXTRA->objectsSorted->clear();
for (i = 1; i <= x->arraySize; i++) {
jamoma_edit_numeric_instance(x->arrayFormatInteger, &instanceAddress, i);
// create a data
#ifdef JMOD_MESSAGE
data_array_create(self, anObject, kTTSym_message, i);
#endif
#if JMOD_RETURN
data_array_create(self, anObject, kTTSym_return, i);
#endif
#ifndef JMOD_MESSAGE
#ifndef JMOD_RETURN
data_array_create(self, anObject, kTTSym_parameter, i);
#endif
#endif
if (!jamoma_subscriber_create((t_object*)x, anObject, TTAddress(instanceAddress->s_name), aSubscriber, returnedAddress, &returnedNode, &returnedContextNode)) {
if (aSubscriber.valid()) {
// append the data to the internals table
v = TTValue(anObject);
v.append(TTSymbol(instanceAddress->s_name));
v.append(aSubscriber);
x->internals->append(TTSymbol(instanceAddress->s_name), v);
// inverse objects order for iteration purpose (see in data_array_return_value : array mode)
EXTRA->objectsSorted->insert(0, anObject);
}
}
}
// Ends iteration on internals
x->iterateInternals = NO;
// handle args
jamoma_ttvalue_to_Atom(x->arrayArgs, &argc, &argv);
if (argc && argv)
attr_args_process(x, argc, argv);
// select all datas
wrappedModularClass_ArraySelect(self, gensym("*"), 0, NULL);
#ifndef JMOD_MESSAGE
// init all datas created dynamically
if (!EXTRA->firstArray)
defer((t_object*)x, (method)wrappedModularClass_anything, _sym_init, 0, NULL);
#endif
}
else if (number > MAX_ARRAY_SIZE)
object_error((t_object*)x, "the size is greater than the maximum array size (%d)", MAX_ARRAY_SIZE);
EXTRA->firstArray = NO;
}
else
object_error((t_object*)x, "can't register because %s is not a relative address", relativeAddress->s_name);
}
