void data_subscribe(TTPtr self, t_symbol *relativeAddress, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTAddress returnedAddress;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
// for relative address
if (TTAddress(relativeAddress->s_name).getType() == kAddressRelative) {
jamoma_subscriber_create((t_object*)x, x->wrappedObject, TTAddress(jamoma_parse_dieze((t_object*)x, relativeAddress)->s_name), x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode);
#ifndef JMOD_MESSAGE
#ifndef JMOD_RETURN
// if a j.parameter is registered under the root : reset to the default value our self
if (returnedContextNode == accessApplicationLocalDirectory->getRoot())
{
TTBoolean initialized;
x->wrappedObject.get("initialized", initialized);
if (!initialized)
x->wrappedObject.send(kTTSym_Init);
}
#endif
#endif
}
else
object_error((t_object*)x, "can't register because %s is not a relative address", relativeAddress->s_name);
}
void init_subscribe(t_init *x)
{
TTValue v, args, none;
TTAddress contextAddress = kTTAdrsEmpty;
TTAddress returnedAddress;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
TTObject returnAddressCallback, returnValueCallback, empty;
// for relative address
if (x->address.getType() == kAddressRelative) {
if (!jamoma_subscriber_create((t_object*)x, empty, x->address, x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode)) {
// get the context address to make
// a receiver on the contextAddress:initialized attribute
x->subscriberObject.get("contextAddress", v);
contextAddress = v[0];
}
// bind on the /model:address parameter (view patch) or return (model patch)
if (contextAddress != kTTAdrsEmpty) {
// Make a TTReceiver object
returnAddressCallback = TTObject("callback");
returnAddressCallback.set(kTTSym_baton, TTPtr(x));
returnAddressCallback.set(kTTSym_function, TTPtr(&jamoma_callback_return_address));
args.append(returnAddressCallback);
returnValueCallback = TTObject("callback");
returnValueCallback.set(kTTSym_baton, TTPtr(x));
returnValueCallback.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
args.append(returnValueCallback);
x->initReceiver = TTObject(kTTSym_Receiver, args);
x->initReceiver.set(kTTSym_address, contextAddress.appendAttribute(kTTSym_initialized));
}
// while the context node is not registered : try to binds again :(
// (to -- this is not a good way todo. For binding we should make a subscription
// to a notification mechanism and each time an TTObjet subscribes to the namespace
// using jamoma_subscriber_create we notify all the externals which have used
// jamoma_subscriber_create with NULL object to bind)
else {
// release the subscriber
x->subscriberObject = TTObject();
// 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)init_subscribe, NULL, 0, 0);
}
}
else
object_error((t_object*)x, "can't bind because %s is not a relative address", x->address.c_str());
}
void out_subscribe(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTAddress signalAddress;
TTAddress outputAddress;
TTAddress inputAddress;
TTValue v, args;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
TTAddress returnedAddress, parentAddress;
TTString formatDescription, sInstance;
t_object *modelOrView = NULL;
#ifdef J_OUT_TILDE
signalAddress = TTAddress("audio");
#endif
#ifdef J_OUT_MULTI
signalAddress = TTAddress("audio");
#endif
#ifndef J_OUT_TILDE
#ifndef J_OUT_MULTI
signalAddress = TTAddress("data");
#endif
#endif
// edit "signal/out.instance" address
outputAddress = signalAddress.appendAddress(TTAddress("out")).appendInstance(EXTRA->instance);
// if the subscription is successful
if (!jamoma_subscriber_create((t_eobj*)x, x->wrappedObject, outputAddress, x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode)) {
// get patcher
x->patcherPtr = ((t_eobj*)x)->o_canvas;
// update instance symbol in case of duplicate instance
EXTRA->instance = returnedAddress.getInstance();
// observe /parent/in address in order to link/unlink with an Input object below
returnedNode->getParent()->getAddress(parentAddress);
inputAddress = parentAddress.appendAddress(TTAddress("in")).appendInstance(EXTRA->instance);
x->wrappedObject.set("inputAddress", inputAddress);
// get model or view object
jamoma_patcher_get_model_or_view(x->patcherPtr, &modelOrView);
// notify the model there is something new concerning signal processing
if (modelOrView)
object_method_typed(modelOrView, gensym("output_created"), 0, NULL, NULL);
}
}
void node_subscribe(TTPtr self, t_symbol* relativeAddress, long argc, t_atom* argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTAddress returnedAddress;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
// for relative address
if (TTAddress(relativeAddress->s_name).getType() == kAddressRelative) {
if(!jamoma_subscriber_create((t_eobj*)x, x->wrappedObject, TTAddress(relativeAddress->s_name), x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode))
pd_error((t_object*)x, "error when registering %s", relativeAddress->s_name);
}
else
pd_error((t_object*)x, "can't register because %s is not a relative address", relativeAddress->s_name);
}
void in_subscribe(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTAddress inputAddress;
TTAddress outputAddress;
TTValue v, args;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
TTAddress returnedAddress, parentAddress;
TTDataPtr aData;
TTString formatDescription, sInstance;
SymbolPtr inDescription;
inputAddress = TTAddress("in").appendInstance(EXTRA->instance);
// if the subscription is successful
if (!jamoma_subscriber_create((ObjectPtr)x, x->wrappedObject, inputAddress, &x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode)) {
// get patcher
x->patcherPtr = jamoma_patcher_get((ObjectPtr)x);
// update instance symbol in case of duplicate instance
EXTRA->instance = returnedAddress.getInstance();
// observe /parent/out address in order to link/unlink with an Input object below
returnedNode->getParent()->getAddress(parentAddress);
outputAddress = parentAddress.appendAddress(TTAddress("out")).appendInstance(EXTRA->instance);
x->wrappedObject->setAttributeValue(TTSymbol("outputAddress"), outputAddress);
#ifdef JCOM_IN_TILDE
// make internal data to return amplitude
v = TTValue(0., 1.);
formatDescription = "instant amplitude of %s input";
sInstance = EXTRA->instance.c_str();
jamoma_edit_string_instance(formatDescription, &inDescription, sInstance);
makeInternals_data(x, returnedAddress, TTSymbol("amplitude"), NULL, x->patcherPtr, kTTSym_return, (TTObjectBasePtr*)&aData);
aData->setAttributeValue(kTTSym_type, kTTSym_decimal);
aData->setAttributeValue(kTTSym_tag, kTTSym_generic);
aData->setAttributeValue(kTTSym_rangeBounds, v);
aData->setAttributeValue(kTTSym_description, TTSymbol(inDescription->s_name));
aData->setAttributeValue(kTTSym_dataspace, TTSymbol("gain"));
aData->setAttributeValue(kTTSym_dataspaceUnit, TTSymbol("linear"));
// make internal data to parameter in/amplitude/active
makeInternals_data(x, returnedAddress, TTSymbol("amplitude/active"), gensym("return_amplitude_active"), x->patcherPtr, kTTSym_parameter, (TTObjectBasePtr*)&aData);
aData->setAttributeValue(kTTSym_type, kTTSym_integer);
aData->setAttributeValue(kTTSym_tag, kTTSym_generic);
v = TTValue((int)EXTRA->pollInterval);
aData->setAttributeValue(kTTSym_valueDefault, v);
v = TTValue(0, 1000);
aData->setAttributeValue(kTTSym_rangeBounds, v);
aData->setAttributeValue(kTTSym_rangeClipmode, kTTSym_low);
aData->setAttributeValue(kTTSym_description, TTSymbol("set the sample rate of the amplitude follower"));
// launch the clock to update amplitude regulary
EXTRA->clock = clock_new(x, (method)in_update_amplitude);
if (EXTRA->pollInterval)
clock_delay(EXTRA->clock, EXTRA->pollInterval);
#endif
// expose bypass and mute attributes of TTInput as TTData in the tree structure
x->subscriberObject->exposeAttribute(x->wrappedObject, kTTSym_bypass, kTTSym_parameter, &aData);
aData->setAttributeValue(kTTSym_type, kTTSym_boolean);
aData->setAttributeValue(kTTSym_tag, kTTSym_generic);
aData->setAttributeValue(kTTSym_description, TTSymbol("When active, this attribute bypasses the model's processing algtorithm, letting incoming signal pass through unaffected"));
v = TTValue(0);
aData->setAttributeValue(kTTSym_valueDefault, v);
x->subscriberObject->exposeAttribute(x->wrappedObject, kTTSym_mute, kTTSym_parameter, &aData);
aData->setAttributeValue(kTTSym_type, kTTSym_boolean);
aData->setAttributeValue(kTTSym_tag, kTTSym_generic);
aData->setAttributeValue(kTTSym_description, TTSymbol("When active, this attribute turns off model's inputs."));
v = TTValue(0);
aData->setAttributeValue(kTTSym_valueDefault, v);
}
}
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);
}
