TTErr makeInternals_sender(TTPtr self, TTAddress address, TTSymbol name, TTObject& returnedSender, TTBoolean appendNameAsAttribute)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedSender = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_sender : \"%s\" internal already exists", name.c_str());
return kTTErrNone;
}
returnedSender = TTObject(kTTSym_Sender);
// edit address
if (appendNameAsAttribute)
adrs = address.appendAttribute(name);
else
adrs = address.appendAddress(TTAddress(name.c_str()));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedSender);
// set address attribute
returnedSender.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" sender to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}
TTErr makeInternals_viewer(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedViewer, TTBoolean deferlow)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, baton;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedViewer = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_viewer : \"%s\" internal already exists", name.c_str());
return kTTErrNone;
}
returnedViewer = TTObject(kTTSym_Viewer);
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnedViewer.set(kTTSym_baton, baton);
returnedViewer.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
// edit address
adrs = address.appendAddress(TTAddress(name));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedViewer);
// set address attribute (after registration as the value can be updated in the same time)
returnedViewer.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" viewer to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}
TTErr makeInternals_data(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTPtr context, TTSymbol service, TTObject& returnedData, TTBoolean deferlow)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue baton, v, out;
TTAddress dataAddress, dataRelativeAddress;
TTNodePtr dataNode;
returnedData = TTObject(kTTSym_Data, service);
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnedData.set(kTTSym_baton, baton);
returnedData.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
// absolute registration
dataAddress = address.appendAddress(TTAddress(name));
v = TTValue(dataAddress, returnedData, context);
out = MaxApplication.send("ObjectRegister", v);
// retreive relative effective address
dataAddress = out[0];
dataNode = TTNodePtr((TTPtr)out[1]);
dataNode->getAddress(dataRelativeAddress, address);
// absolute registration case : set the address in second position (see in unregister method)
v = TTValue(returnedData, dataAddress);
x->internals->append(dataRelativeAddress, v);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" %s at : %s", dataRelativeAddress.c_str(), service.c_str(), dataAddress.c_str());
return kTTErrNone;
}
void model_preset_amenities(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTAddress modelAdrs;
TTValue v, a, args, none;
TTAddress presetAddress;
// get model:address
EXTRA->modelInfo->get(kTTSym_address, v);
modelAdrs = v[0];
// create the preset manager
jamoma_presetManager_create((t_object*)x, *EXTRA->presetManager);
// suscribe it under a preset node
presetAddress = modelAdrs.appendAddress(TTAddress("preset"));
args = TTValue(presetAddress, *EXTRA->presetManager, x->patcherPtr);
if (!MaxApplication.send("ObjectRegister", args, none)) {
EXTRA->presetManager->set(kTTSym_address, modelAdrs);
defer_low(x, (method)model_preset_default, 0, 0, 0L);
}
}
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);
}
}
TTErr makeInternals_receiver(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedReceiver, TTBoolean deferlow, TTBoolean appendNameAsAttribute)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, args, baton;
TTObject returnValueCallback, empty;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedReceiver = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_receiver : \"%s\" internal already exists", name.c_str());
returnedReceiver.send("Get");
return kTTErrNone;
}
// prepare arguments
// we don't want the address back
args.append(empty);
returnValueCallback = TTObject("callback");
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnValueCallback.set(kTTSym_baton, baton);
returnValueCallback.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
args.append(returnValueCallback);
returnedReceiver = TTObject(kTTSym_Receiver, args);
// edit address
if (appendNameAsAttribute)
adrs = address.appendAttribute(name);
else
adrs = address.appendAddress(TTAddress(name.c_str()));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedReceiver);
// set address attribute (after registration as the value can be updated in the same time)
returnedReceiver.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" receiver to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}