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; }