TTErr TTScoreTimeProcessCreate(TTTimeProcessPtr *timeProcess, const std::string timeProcessClass, TTTimeEventPtr startEvent, TTTimeEventPtr endEvent, TTTimeContainerPtr timeContainer)
{
TTValue args;
*timeProcess = NULL;
if (timeContainer) {
TTValue out;
TTErr err;
args = TTSymbol(timeProcessClass);
args.append(TTObjectBasePtr(startEvent));
args.append(TTObjectBasePtr(endEvent));
err = timeContainer->sendMessage(TTSymbol("TimeProcessCreate"), args, out);
if (!err)
*timeProcess = TTTimeProcessPtr(TTObjectBasePtr(out[0]));
return err;
}
else {
args = TTObjectBasePtr(startEvent);
args.append(TTObjectBasePtr(endEvent));
return TTObjectBaseInstantiate(timeProcessClass.c_str(), TTObjectBaseHandle(timeProcess), args);
}
}
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;
}
TTErr TTClock::setDuration(const TTValue& value)
{
if (value.size() == 1) {
if (value[0].type() == kTypeFloat64) {
mDuration = value[0];
// update offset
if (mDuration < mOffset) {
mOffset = mDuration;
sendNotification(TTSymbol("ClockOffsetChanged"), mOffset);
}
mPosition = mOffset / mDuration;
mDate = mOffset;
sendNotification(TTSymbol("ClockDurationChanged"), mDuration);
return kTTErrNone;
}
}
return kTTErrGeneric;
}
TTErr TTClockLib::isClockNameAvailable(TTSymbol aClockName)
{
if (aClockName == TTSymbol("max") || aClockName == TTSymbol("system"))
return kTTErrNone;
else
return kTTErrValueNotFound;
}
void snapshot(XMLNode xmlNode, TTNodePtr ttNode)
{
TTSymbolPtr OSCaddress;
TTValue v, attributeNames;
TTList childList;
TTNodePtr p_node;
TTString s;
ttNode->getOscAddress(&OSCaddress);
ttNode->getChildren(S_WILDCARD, S_WILDCARD, childList);
const char* address = OSCaddress->getCString();
char* nodeName;
XMLNode childNode = xmlNode;
// don't write the first node AppName in xml because already written in application xml header
// don't write the node name if is an instance, don't want it in xml file, replaced by dynamic instances attribute
if (strcmp(address, AppName.c_str()) != 0 && strrchr(address, '.') == NULL) {
// get the substring representing the last node name
if (strlen(address) > 1) {
const char* c = strrchr(address, '/');
int start = c-address+1;
int end = strlen(address)-1;
nodeName = str_sub(address, start, end);
childNode = xmlNode.addChild(nodeName);
}
if (childList.isEmpty()) {
// get the Data object of the Node
TTObjectPtr param = ttNode->getObject();
if (param != NULL) {
addAttributeToXml(param, childNode, kTTSym_type);
addAttributeToXml(param, childNode, kTTSym_valueDefault);
addAttributeToXml(param, childNode, kTTSym_rangeBounds);
addAttributeToXml(param, childNode, kTTSym_rangeClipmode);
addAttributeToXml(param, childNode, kTTSym_valueStepsize);
addAttributeToXml(param, childNode, TTSymbol("dynamicInstances"));
addAttributeToXml(param, childNode, TTSymbol("instanceBounds"));
addAttributeToXml(param, childNode, kTTSym_priority);
addAttributeToXml(param, childNode, kTTSym_description);
addAttributeToXml(param, childNode, kTTSym_repetitionsFilter);
addAttributeToXml(param, childNode, kTTSym_readonly);
}
}
}
// repeat recursively for each child
for (childList.begin(); childList.end(); childList.next()) {
childList.current().get(0,(TTPtr*)&p_node);
snapshot(childNode, p_node);
}
}
NSPStatus
Namespace::namespaceParameterCreate(std::string address, int instanceNumber, void* object, void (*returnValueCallback) (TTPtr, TTValue&)
, void (*returnAddressCallback)(TTPtr, TTValue&))
{
// Create a TTData
TTDataPtr data = NULL;
TTCallbackPtr p_returnValueCallback, p_returnAddressCallback;
TTValuePtr p_returnValueBaton, p_returnAddressBaton;
// prepare arguments : see TTData.h to know which args are needed
TTValue args;
args.clear();
p_returnValueCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnValueCallback), kTTValNONE);
p_returnValueBaton = new TTValue(TTPtr(object));
p_returnValueCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnValueBaton));
p_returnValueCallback->setAttributeValue(kTTSym_function, TTPtr(returnValueCallback));
args.append(p_returnValueCallback);
p_returnAddressCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnAddressCallback), kTTValNONE);
p_returnAddressBaton = new TTValue(TTPtr(object));
p_returnAddressCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnAddressBaton));
p_returnAddressCallback->setAttributeValue(kTTSym_function, TTPtr(p_returnAddressCallback));
args.append(p_returnAddressCallback);
// Register a TTObject into the NSPDirectory
TTNodePtr returnedNode;
TTBoolean newInstanceCreated;
for (int i = 0; i < instanceNumber; i++) {
data = NULL;
returnedNode = NULL;
newInstanceCreated = NULL;
// create an instance of TTData
TTObjectInstantiate(TTSymbol("Data"), TTObjectHandle(&data), args);
std::string absAddress = AppName + address;
// add instance number
if (i != 0) {
absAddress += ".";
stringstream st;
st << i;
absAddress += st.str();
}
// add the parameter data in the namespace directory
NSPDirectory->TTNodeCreate(TT(absAddress), (TTObjectPtr)data, NULL, &returnedNode, &newInstanceCreated);
// note : our myRegistrationObserver is informed if declared
}
return NSP_NO_ERROR;
}
TTErr TTScoreTimeProcessEndCallbackCreate(TTTimeProcessPtr timeProcess, TTObjectBasePtr *endCallback, TTScoreTimeProcessEndCallbackPtr endCallbackFunction)
{
TTValue v, none;
TTValuePtr endMessageBaton;
TTMessagePtr aMessage;
TTErr err;
*endCallback = NULL;
// create a TTCallback to observe when time process starts (using internal_TTScoreTimeProcessEndCallback)
TTObjectBaseInstantiate(TTSymbol("callback"), endCallback, none);
// store the function to call and the time process to pass
endMessageBaton = new TTValue(TTPtr(timeProcess)); // endMessageBaton will be deleted during the callback destruction
endMessageBaton->append(TTPtr(endCallbackFunction));
(*endCallback)->setAttributeValue(kTTSym_baton, TTPtr(endMessageBaton));
(*endCallback)->setAttributeValue(kTTSym_function, TTPtr(&internal_TTScoreTimeProcessEndCallback));
// register for ProcessEnd message observation
err = timeProcess->findMessage(kTTSym_ProcessEnd, &aMessage);
if (!err)
aMessage->registerObserverForNotifications(**endCallback);
return err;
}
void data_array(TTPtr self, t_symbol *msg, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTInt32 d, i;
t_symbol *instanceAddress;
TTSymbol memoCursor;
if (!x->internals->isEmpty()) {
// is the incoming data size is a multiple of the array size ?
d = argc / x->arraySize;
if ((d * x->arraySize) == argc) {
memoCursor = x->cursor;
for (i = 1; i <= x->arraySize; i++) {
jamoma_edit_numeric_instance(x->arrayFormatInteger, &instanceAddress, i);
x->cursor = TTSymbol(instanceAddress->s_name);
TTObject o = selectedObject;
jamoma_data_command(o, _sym_nothing, d, argv+((i-1)*d));
}
x->cursor = memoCursor;
}
else
object_error((t_object*)x, "array : the array message size have to be a multiple of the array size");
}
else
object_error((t_object*)x, "array : the array is empty");
}
TTErr TTScoreTimeEventStatusCallbackCreate(TTTimeEventPtr timeEvent, TTObjectBasePtr *statusCallback, TTScoreTimeEventStatusCallbackPtr statusCallbackFunction)
{
TTValue v, none;
TTValuePtr statusAttributeBaton;
TTAttributePtr anAttribute;
TTErr err;
statusCallback = NULL;
// Create a TTCallback to observe time event status attribute (using internal_TTScoreTimeEventStatusCallback)
TTObjectBaseInstantiate(TTSymbol("callback"), statusCallback, none);
statusAttributeBaton = new TTValue(TTPtr(timeEvent)); // statusAttributeBaton will be deleted during the callback destruction
statusAttributeBaton->append(TTPtr(statusCallbackFunction));
(*statusCallback)->setAttributeValue(kTTSym_baton, TTPtr(statusAttributeBaton));
(*statusCallback)->setAttributeValue(kTTSym_function, TTPtr(&internal_TTScoreTimeEventStatusCallback));
// register for status attribute observation
err = timeEvent->findAttribute(kTTSym_status, &anAttribute);
if (!err)
anAttribute->registerObserverForNotifications(**statusCallback);
return err;
}
void in_update_amplitude(TTPtr self)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTInputPtr anInput = (TTInputPtr)x->wrappedObject;
TTValue storedObject;
TTObjectBasePtr anObject;
TTErr err;
if (anInput) {
if (x->internals) {
if (!x->internals->isEmpty()) {
// get internal data object used to return amplitude
err = x->internals->lookup(TTSymbol("amplitude"), storedObject);
if (!err) {
anObject = storedObject[0];
// set current meter value
anObject->setAttributeValue(kTTSym_value, EXTRA->meter);
}
}
}
// restart the clock
if (EXTRA->pollInterval)
clock_delay(EXTRA->clock, EXTRA->pollInterval);
}
}
TTErr WebSocketAnswerManager::ReceiveDiscoverAnswer(TTSymbol from, TTAddress address, const TTValue& value, TTErr error)
{
TTValue v;
TTString key;
WebSocketAnswerPtr anAnswer;
TTErr err;
key = from.string();
key += address.string();
err = mDiscoverAnswers->lookup(TTSymbol(key), v);
if (!err) {
anAnswer = WebSocketAnswerPtr((TTPtr)v[0]);
if (anAnswer->getState() != TIMEOUT_EXCEEDED) {
anAnswer->setAnswer(value, error);
return kTTErrNone;
}
}
else
cout << "WebSocketAnswerManager::ReceiveDiscoverAnswer can't find a request at " << key << endl;
return kTTErrGeneric;
}
NSPStatus
Namespace::namespaceInit(bool useDeviceManager)
{
// Initialise TT environments
TTModularInit(m_appName, "");
GalamusApplication = (TTApplicationPtr)TTModularGetApplication(TT(m_appName));
if (NSPDirectory == NULL) {
return NSP_INIT_ERROR;
}
if (useDeviceManager) {
// Initialise DeviceManager if wanted
/*TTDeviceManagerPtr */m_deMan = NULL;
TTValue args;
// Make a TTDeviceManager object
args.append(GalamusApplication);
args.append(TT(m_appName));
TTObjectInstantiate(TTSymbol("DeviceManager"), TTObjectHandle(&m_deMan), args);
// Load plugins and config with xml
TTValue value;
value.append(TT(PLUGINS_PATH));
value.append(TT(XML_CONFIG_PATH));
m_deMan->LoadPlugins(value);
// Load devices with xml
m_deMan->LoadDeviceXmlConfig(TT(XML_CONFIG_PATH));
}
return NSP_NO_ERROR;
}
NSPStatus
Namespace::namespaceValueSend(std::string address, TTSymbolPtr attribute, TTValue value, int instance)
{
TTSenderPtr sender = NULL;
// prepare arguments : see TTSender.h to know which args are needed
TTValue args;
args.clear();
args.append(GalamusApplication);
// add Application name to the address
std::string absAddress = AppName + address;
// add instance number
if (instance != 0) {
absAddress += ".";
stringstream st;
st << instance;
absAddress += st.str();
}
args.append(TT(absAddress));
args.append(attribute);
TTObjectInstantiate(TTSymbol("Sender"), TTObjectHandle(&sender), args);
sender->sendMessage(kTTSym_Send, value);
// note : the value is returned by the Data and the Receiver
//TTObjectRelease(TTObjectHandle(&sender));// throw an exception on windows
return NSP_NO_ERROR;
}
NSPStatus
Namespace::namespaceObserverCreate(std::string address, TTSymbolPtr attribute, void* object, void (*returnValueCallback) (TTPtr, TTValue&)
, void (*returnAddressCallback) (TTPtr, TTValue&)
, int instance)
{
TTReceiverPtr myReceiver = NULL;
TTCallbackPtr r_returnAddressCallback;
TTCallbackPtr r_returnValueCallback;
TTValuePtr r_returnAddressBaton, r_returnValueBaton;
// prepare arguments : see TTReceiver.h to know which args are needed
TTValue args;
args.clear();
args.append(GalamusApplication);
// add Application name to the address
std::string absAddress = AppName + address;
// add instance number
if (instance != 0) {
absAddress += ".";
stringstream st;
st << instance;
absAddress += st.str();
}
args.append(TT(absAddress));
args.append(attribute);
r_returnAddressCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&r_returnAddressCallback), kTTValNONE);
r_returnAddressBaton = new TTValue(TTPtr(object));
r_returnAddressCallback->setAttributeValue(kTTSym_baton, TTPtr(r_returnAddressBaton));
r_returnAddressCallback->setAttributeValue(kTTSym_function, TTPtr(returnAddressCallback));
args.append(r_returnAddressCallback);
r_returnValueCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&r_returnValueCallback), kTTValNONE);
r_returnValueBaton = new TTValue(TTPtr(object));
r_returnValueCallback->setAttributeValue(kTTSym_baton, TTPtr(r_returnValueBaton));
r_returnValueCallback->setAttributeValue(kTTSym_function, TTPtr(returnValueCallback));
args.append(r_returnValueCallback);
TTObjectInstantiate(TTSymbol("Receiver"), TTObjectHandle(&myReceiver), args);
return NSP_NO_ERROR;
}
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);
}
NSPStatus
Namespace::namespacePresetCall(std::string name)
{
TTValue v(TT(name));
m_presetManager->sendMessage(TTSymbol("Recall"), v);
return NSP_NO_ERROR;
}
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 TTAddressItemFind(const TTValue& itemValue, TTPtr aSymbolToMatch, TTBoolean& found)
void TTAddressItemFind(const TTValue& itemValue, TTPtr aSymbolBaseToMatch, TTBoolean& found)
{
TTAddressItemPtr anItem;
anItem = TTAddressItemPtr((TTPtr)itemValue[0]);
found = anItem->getSymbol() == TTSymbol(aSymbolBaseToMatch);
}
NSPStatus
Namespace::namespacePresetCall(int number)
{
TTValue v(number);
m_presetManager->sendMessage(TTSymbol("Recall"), v);
return NSP_NO_ERROR;
}
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);
}
TTInputAudio :: TTInputAudio (const TTValue& arguments) :
TTInput(arguments)
{
mTags = TTSymbol("audio");
mSignalIn = TTObject(kTTSym_audiosignal, 1);
mSignalOut = TTObject(kTTSym_audiosignal, 1);
mSignalZero = TTObject(kTTSym_audiosignal, 1);
}
void WebSocketAnswerManager::AddDiscoverAnswer(TTSymbol from, TTAddress address, int timeOutInMs)
{
TTString key = from.string();
key += address.string();
WebSocketAnswerPtr anAnswer = new WebSocketAnswer();
anAnswer->setTimeOut(timeOutInMs);
mDiscoverAnswers->append(TTSymbol(key), (TTPtr)anAnswer);
}
NSPStatus
Namespace::namespacePresetsLoadFromXml(std::string filepath)
{
TTValue args, v, attr;
// TTPresetManagerPtr returnedPresetManager = NULL;
TTXmlHandlerPtr aXmlHandler = NULL;
TTHashPtr toStore = new TTHash();
TTObjectPtr testObjectCallback;
// TTValuePtr testObjectBaton;
// Instanciate a PresetManager
args.append(GalamusApplication); // add application arg
testObjectCallback = NULL; // without this, TTObjectInstantiate try to release an oldObject that doesn't exist ... Is it good ?
TTObjectInstantiate(TTSymbol("callback"), &testObjectCallback, kTTValNONE);
// testObjectBaton = new TTValue(TTPtr(x));
// testObjectCallback->setAttributeValue(kTTSym_baton, TTPtr(testObjectBaton));
// testObjectCallback->setAttributeValue(kTTSym_function, TTPtr(&jamoma_presetManager_test_object_callback));
args.append(testObjectCallback); // add callback method arg (we don't need here)
// Here we decide to store only Value and Priority attributes for Data object
attr = TTValue(kTTSym_value);
attr.append(kTTSym_priority);
//toStore->append(TTSymbol("Data"), attr);
args.append((TTPtr)toStore); // add storing hash table arg
m_presetManager = NULL;
TTObjectInstantiate(TTSymbol("PresetManager"), TTObjectHandle(&m_presetManager), args);
// Instanciate a XmlHandler
args.clear();
TTObjectInstantiate(TTSymbol("XmlHandler"), TTObjectHandle(&aXmlHandler), args);
// Set XmlHandler being used by PresetManager
v = TTValue(TTPtr(m_presetManager));
aXmlHandler->setAttributeValue(kTTSym_object, v);
aXmlHandler->setAttributeValue(TTSymbol("headerNodeName"), TT(XML_PRESET_HEADER_NODE_NAME));
aXmlHandler->setAttributeValue(TTSymbol("version"), TT(XML_PRESET_VERSION));
aXmlHandler->setAttributeValue(TTSymbol("xmlSchemaLocation"), TT(XML_PRESET_SCHEMA_LOCATION));
v.clear();
v.append(TT(filepath));
aXmlHandler->sendMessage(TTSymbol("Read"), v);//TODO : return an error code if fail
// TTValue tmp;
// m_presetManager->getAttributeValue(TTSymbol("names"), tmp);
//
// for (int i = 0; i < tmp.getSize(); i++) {
// TTString s;
// tmp.toString();
// tmp.get(i, s);
//
// std::cout << s << std::endl;
// }
return NSP_NO_ERROR;
}
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
DemoApp::SetupScore()
{
TTValue args, out;
TTObject xmlHandler("XmlHandler");
TTLogMessage("\n*** Initialisation of Score environnement ***\n");
/////////////////////////////////////////////////////////////////////
// Init the Score library (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
TTLogMessage("\n*** Reading of an interactive scenario file ***\n");
/////////////////////////////////////////////////////////////////////
// Create an empty Scenario
mScenario = TTObject("Scenario");
// Read DemoScenario1.score file to fill mScenario
xmlHandler.set("object", mScenario);
xmlHandler.send("Read", "../DemoScenario.score", out);
TTLogMessage("\n*** Prepare scenario observation ***\n");
/////////////////////////////////////////////////////////////////////
// Create a callback for the "EventStatusChanged" notification sent by each event
mEventStatusChangedCallback = TTObject("callback");
mEventStatusChangedCallback.set("baton", TTPtr(this));
mEventStatusChangedCallback.set("function", TTPtr(&DemoAppEventStatusChangedCallback));
mEventStatusChangedCallback.set("notification", TTSymbol("EventStatusChanged"));
// Get all events of the scenario and attach a callback to them
TTValue timeEvents;
mScenario.get("timeEvents", timeEvents);
for (TTElementIter it = timeEvents.begin() ; it != timeEvents.end() ; it++) {
TTObject event = TTElement(*it);
event.registerObserverForNotifications(mEventStatusChangedCallback);
}
TTLogMessage("\n*** Start scenario execution ***\n");
/////////////////////////////////////////////////////////////////////
// Set the execution speed of the scenario
mScenario.set("speed", 2.);
// Start the scenario
mScenario.send("Start");
// Poll Scenario information
mPollingThread = new TTThread(TTThreadCallbackType(DemoAppScenarioPollingThread), this);
}
TTErr TTScoreTimeEventRelease(TTTimeEventPtr *timeEvent, TTTimeContainerPtr timeContainer)
{
if (timeContainer) {
TTValue none;
return timeContainer->sendMessage(TTSymbol("TimeEventRelease"), TTObjectBasePtr(*timeEvent), none);
}
else
return TTObjectBaseRelease(TTObjectBaseHandle(timeEvent));
}
TTObjectBasePtr OSCSenderManager::add(TTSymbol applicationName, TTSymbol ip, TTUInt16 port)
{
TTValue v;
TTObjectBasePtr anObject = NULL;
TTErr err;
err = TTObjectBaseInstantiate(TTSymbol("osc.send"), &anObject, kTTValNONE);
if (!err) {
anObject->setAttributeValue(TTSymbol("address"), ip);
anObject->setAttributeValue(TTSymbol("port"), port);
v.append(anObject);
v.append(ip);
v.append(port);
mSenders->append(applicationName, v);
}
return anObject;
}
TTErr TTScoreTimeProcessGetEndEvent(TTTimeProcessPtr timeProcess, TTTimeEventPtr *endEvent)
{
TTValue v;
TTErr err = timeProcess->getAttributeValue(TTSymbol("endEvent"), v);
if (!err)
*endEvent = TTTimeEventPtr(TTObjectBasePtr(v[0]));
return err;
}
void model_preset_dorecall(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, none;
if (argc && argv)
if (atom_gettype(argv) == A_SYM)
v = TTValue(TTSymbol(atom_getsym(argv)->s_name));
// recall the preset
EXTRA->presetManager->send(kTTSym_Recall, v, none);
}
t_max_err model_preset_set_presets(TTPtr self, TTPtr attr, long ac, const t_atom *av)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
if (ac&&av) {
EXTRA->attr_presets = TTSymbol(atom_getsym(av)->s_name);
}
else
EXTRA->attr_presets = kTTSym_none; // default true
return MAX_ERR_NONE;
}
