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