int main(int argc, const char * argv[]) { std::cout << "BEGIN testing for AnalysisLib...\n"; // CUSTOMIZE TTLoadJamomaExtension_AnalysisLib(); // CUSTOMIZE TTValue classNames; // if the follow group tag is present within the thisTTClassTags definition, the class will be tested TTValue testClassesWithTheseTags(TT("dspAnalysisLib")); // CUSTOMIZE TTObject::GetRegisteredClassNamesForTags(classNames, testClassesWithTheseTags); for (int i=0; i<classNames.size(); i++) { TTSymbol name = classNames[i]; try { TTObject obj(name); std::cout << "TESTING " << name.string() << std::endl; obj.send("test"); } catch (...) { TTLogMessage("UnitTest Failure to instantiate object of class %s! \n", name.c_str()); continue; } } std::cout << "END testing of AnalysisLib!\n"; // CUSTOMIZE return 0; }
MaxErr OpGetOperand(OpPtr self, ObjectPtr attr, AtomCount* argc, AtomPtr* argv) { TTValue v; self->audioGraphObject->getUnitGenerator()->getAttributeValue(TT("operand"), v); *argc = v.getSize(); if (!(*argv)) // otherwise use memory passed in *argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * v.getSize()); for (int i=0; i<v.getSize(); i++) { if(v.getType(i) == kTypeFloat32 || v.getType(i) == kTypeFloat64){ TTFloat64 value; v.get(i, value); atom_setfloat(*argv+i, value); } else if(v.getType(i) == kTypeSymbol){ TTSymbol value; v.get(i, value); atom_setsym(*argv+i, gensym((char*)value.c_str())); } else{ // assume int TTInt32 value; v.get(i, value); atom_setlong(*argv+i, value); } } return MAX_ERR_NONE; }
void ramp_setFunction(t_ramp *x, void *attr, long argc, t_atom *argv) { long n; TTValue names; TTSymbol* aName; TTString nameString; // set the function x->attr_function = atom_getsym(argv); x->rampUnit->setAttributeValue(TT("function"), TT(x->attr_function->s_name)); // cache the function's attribute names x->parameterNames->clear(); x->rampUnit->getFunctionParameterNames(names); n = names.getSize(); for (int i=0; i<n; i++) { names.get(i, &aName); nameString = aName->getString(); if (aName == TT("bypass") || aName == TT("mute") || aName == TT("maxNumChannels") || aName == TT("sampleRate")) continue; // don't publish these parameters if (nameString[0] > 64 && nameString[0] < 91) { // ignore all params not starting with upper-case nameString[0] += 32; // convert first letter to lower-case for Max TTValuePtr v = new TTValue(aName); x->parameterNames->append(TT(nameString.c_str()), *v); } } }
/* The attribute getter */ t_max_err MaxAudioGraphWrappedClass_attrGet(WrappedInstancePtr self, ObjectPtr attr, AtomCount* argc, AtomPtr* argv) { SymbolPtr attrName = (SymbolPtr)object_method(attr, _sym_getname); TTValue v; AtomCount i; TTSymbol ttAttrName(attrName->s_name); self->audioGraphObject->getUnitGenerator()->getAttributeValue(ttAttrName, v); *argc = v.getSize(); if (!(*argv)) // otherwise use memory passed in *argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * v.getSize()); for (i=0; i<v.getSize(); i++) { if(v.getType(i) == kTypeFloat32 || v.getType(i) == kTypeFloat64){ TTFloat64 value; v.get(i, value); atom_setfloat(*argv+i, value); } else if(v.getType(i) == kTypeSymbol){ TTSymbol value; v.get(i, value); atom_setsym(*argv+i, gensym((char*)value.c_str())); } else{ // assume int TTInt32 value; v.get(i, value); atom_setlong(*argv+i, value); } } return MAX_ERR_NONE; }
TTErr TTSvf::setMode(const TTValue& newValue) { TTSymbol newMode = newValue; if (newMode == TT("lowpass")) { setProcessMethod(processLowpass); setCalculateMethod(calculateLowpass); } else if (newMode == TT("highpass")) { setProcessMethod(processHighpass); setCalculateMethod(calculateHighpass); } else if (newMode == TT("bandpass")) { setProcessMethod(processBandpass); setCalculateMethod(calculateBandpass); } else if (newMode == TT("notch")) { setProcessMethod(processNotch); setCalculateMethod(calculateNotch); } else if (newMode == TT("peak")) { setProcessMethod(processPeak); setCalculateMethod(calculatePeak); } else { logError("bad mode specified for TTSvf: %s", newMode.c_str()); return kTTErrInvalidValue; } mMode = newMode; return kTTErrNone; }
TTErr convertUpperCasedNameInAddress(TTSymbol upperCasedName, TTAddress& convertedInAddress) { TTUInt32 upperCasedNameSize = strlen(upperCasedName.c_str()); TTCString upperCasedNameCString = new char[upperCasedNameSize+1]; TTUInt32 nbUpperCase = 0; TTUInt32 i; TTCString convertedNameCString = NULL; TTUInt32 convertedNameSize = 0; strncpy(upperCasedNameCString, upperCasedName.c_str(), upperCasedNameSize+1); // "ExampleName" to "example/name" // "anyOtherExample" to "any/other/example" if ((upperCasedNameCString[0] > 64 && upperCasedNameCString[0] < 91) || (upperCasedNameCString[0] > 96 && upperCasedNameCString[0] < 123)) { // count how many upper-case letter there are in the TTName after the first letter for (i=1; i<upperCasedNameSize; i++) { if (upperCasedNameCString[i] > 64 && upperCasedNameCString[i] < 91) nbUpperCase++; } // prepare the convertedName convertedNameSize = upperCasedNameSize + nbUpperCase; convertedNameCString = new char[convertedNameSize+1]; // convert first letter to lower-case if needed if (upperCasedNameCString[0] > 64 && upperCasedNameCString[0] < 91) convertedNameCString[0] = upperCasedNameCString[0] + 32; else convertedNameCString[0] = upperCasedNameCString[0]; // copy each letter while checking upper-case letter to replace them by a / + lower-case letter nbUpperCase = 0; for (i=1; i<upperCasedNameSize; i++) { if (upperCasedNameCString[i] > 64 && upperCasedNameCString[i] < 91) { convertedNameCString[i + nbUpperCase] = '/'; convertedNameCString[i + nbUpperCase + 1] = upperCasedNameCString[i] + 32; nbUpperCase++; } else convertedNameCString[i + nbUpperCase] = upperCasedNameCString[i]; } // ends the CString with a NULL letter convertedNameCString[convertedNameSize] = 0; convertedInAddress = TTAddress(convertedNameCString); delete convertedNameCString; convertedNameCString = NULL; } else convertedInAddress = TTAddress(upperCasedName); delete upperCasedNameCString; upperCasedNameCString = NULL; return kTTErrNone; }
void wrappedClass_anything(TTPtr self, t_symbol* s, long argc, t_atom* argv) { WrappedInstancePtr x = (WrappedInstancePtr)self; TTSymbol ttName; TTValue v_in; TTValue v_out; // err = hashtab_lookup(x->wrappedClassDefinition->pdNamesToTTNames, s, (t_object**)&ttName); ttName = x->wrappedClassDefinition->pdNamesToTTNames[s->s_name]; if (ttName.string().empty()) { pd_error((t_object*)x, "no method found for %s", s->s_name); return; } if (argc && argv) { v_in.resize(argc); for (long i=0; i<argc; i++) { if (atom_gettype(argv+i) == A_LONG) v_in[i] = (TTInt32)atom_getlong(argv+i); else if (atom_gettype(argv+i) == A_FLOAT) v_in[i] = atom_getfloat(argv+i); else if (atom_gettype(argv+i) == A_SYM) v_in[i] = TT(atom_getsym(argv+i)->s_name); else pd_error((t_object*)x, "bad type for message arg"); } } x->wrappedObject->send(ttName, v_in, v_out); // process the returned value for the dumpout outlet { long ac = v_out.size(); if (ac) { t_atom* av = (t_atom*)malloc(sizeof(t_atom) * ac); for (long i=0; i<ac; i++) { if (v_out[0].type() == kTypeSymbol) { TTSymbol ttSym; ttSym = v_out[i]; atom_setsym(av+i, gensym((char*)ttSym.c_str())); } else if (v_out[0].type() == kTypeFloat32 || v_out[0].type() == kTypeFloat64) { TTFloat64 f = 0.0; f = v_out[i]; atom_setfloat(av+i, f); } else { TTInt32 l = 0; l = v_out[i]; atom_setfloat(av+i, l); } } outlet_anything(x->dumpOut, s, ac, av); free(av); } } }
void wrappedClass_anything(WrappedInstancePtr self, t_symbol* s, long argc, t_atom* argv) { TTValue v; TTSymbol ttName; t_max_err err; err = hashtab_lookup(self->wrappedClassDefinition->maxNamesToTTNames, s, (t_object**)&ttName); if (err) { object_post(SELF, "no method found for %s", s->s_name); return; } if (argc && argv) { TTValue v; v.resize(argc); for (long i=0; i<argc; i++) { if (atom_gettype(argv+i) == A_LONG) v[i] = (TTInt32)atom_getlong(argv+i); else if (atom_gettype(argv+i) == A_FLOAT) v[i] = atom_getfloat(argv+i); else if (atom_gettype(argv+i) == A_SYM) v[i] = TT(atom_getsym(argv+i)->s_name); else object_error(SELF, "bad type for message arg"); } self->graphObject->mKernel.send(ttName, v, v); // FIXME: TEMPORARY HACK WHILE WE TRANSITION FROM 1-ARG MESSAGES to 2-ARG MESSAGES // process the returned value for the dumpout outlet { long ac = v.size(); if (ac) { t_atom* av = (t_atom*)malloc(sizeof(t_atom) * ac); for (long i=0; i<ac; i++) { if (v[i].type() == kTypeSymbol) { TTSymbol ttSym = v[i]; atom_setsym(av+i, gensym((char*)ttSym.c_str())); } else if (v[i].type() == kTypeFloat32 || v[i].type() == kTypeFloat64) { TTFloat64 f = v[i]; atom_setfloat(av+i, f); } else { TTInt32 l = v[i]; atom_setfloat(av+i, l); } } object_obex_dumpout(self, s, ac, av); free(av); } } } else self->graphObject->mKernel.send(ttName); }
// C Callback from any Graph Source objects we are observing void UnpackGraphCallback(UnpackPtr self, TTValue& arg) { TTDictionaryPtr aDictionary = NULL; TTValue v; long ac; t_atom* ap; TTBoolean firstItemASymbol = NO; TTSymbol firstItem; //arg.get(0, (TTPtr*)(&aDictionary)); aDictionary = (TTDictionaryPtr)(TTPtr)arg[0]; aDictionary->getValue(v); ac = v.size(); if (ac) { ap = new t_atom[ac]; for (int i=0; i<ac; i++) { if (v[i].type() == kTypeInt8 || v[i].type() == kTypeUInt8 || v[i].type() == kTypeInt16 || v[i].type() == kTypeUInt16 || v[i].type() == kTypeInt32 || v[i].type() == kTypeUInt32 || v[i].type() == kTypeInt64 || v[i].type() == kTypeUInt64) { TTInt32 ival; ival = v[i]; atom_setlong(ap+i, ival); } else if (v[i].type() == kTypeFloat32 || v[i].type() == kTypeFloat64) { atom_setfloat(ap+i, v[i]); } else if (v[i].type() == kTypeSymbol) { TTSymbol s; s = v[i]; atom_setsym(ap+i, gensym((char*)s.c_str())); if (i==0) { firstItemASymbol = YES; firstItem = s; } } } if (firstItemASymbol) outlet_anything(self->graphOutlets[0], gensym((char*)firstItem.c_str()), ac-1, ap+1); else if (ac == 1) outlet_float(self->graphOutlets[0], atom_getfloat(ap)); else outlet_anything(self->graphOutlets[0], _sym_list, ac, ap); delete ap; } }
/* Method for "anything" messages */ void MaxAudioGraphWrappedClass_anything(WrappedInstancePtr self, SymbolPtr s, AtomCount argc, AtomPtr argv) { TTValue v_in; TTValue v_out; TTSymbol ttName(s->s_name); if (argc && argv) { v_in.setSize(argc); // Typechecking - we only want ints, floats and symbols for (AtomCount i=0; i<argc; i++) { if (atom_gettype(argv+i) == A_LONG) v_in.set(i, AtomGetInt(argv+i)); else if (atom_gettype(argv+i) == A_FLOAT) v_in.set(i, atom_getfloat(argv+i)); else if (atom_gettype(argv+i) == A_SYM) v_in.set(i, TT(atom_getsym(argv+i)->s_name)); else object_error(SELF, "bad type for message arg"); } } // Now that we know that the message is OK we send it on to the wrapped class self->audioGraphObject->getUnitGenerator()->sendMessage(ttName, v_in, v_out); // process the returned value for the dumpout outlet { AtomCount ac = v_out.getSize(); if (ac) { AtomPtr av = (AtomPtr)malloc(sizeof(Atom) * ac); for (AtomCount i=0; i<ac; i++) { if (v_out.getType() == kTypeSymbol){ TTSymbol ttSym; v_out.get(i, ttSym); atom_setsym(av+i, gensym((char*)ttSym.c_str())); } else if (v_out.getType() == kTypeFloat32 || v_out.getType() == kTypeFloat64) { TTFloat64 f = 0.0; v_out.get(i, f); atom_setfloat(av+i, f); } else { TTInt32 l = 0; v_out.get(i, l); atom_setfloat(av+i, l); } } object_obex_dumpout(self, s, ac, av); free(av); } } // } // else // self->audioGraphObject->getUnitGenerator()->sendMessage(ttName); }
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_explorer(TTPtr self, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedExplorer, TTBoolean deferlow) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; TTValue v, args, baton; TTObject returnValueCallback; // check the internals do not exist yet if (!x->internals->lookup(name, v)) { returnedExplorer = v[0]; JamomaDebug object_post((t_object*)x, "makeInternals_explorer : \"%s\" internal already exists", name.c_str()); return kTTErrNone; } // prepare arguments 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); args.append((TTPtr)jamoma_explorer_default_filter_bank()); returnedExplorer = TTObject(kTTSym_Explorer, args); // default registration case : store object only (see in unregister method) x->internals->append(name, returnedExplorer); JamomaDebug object_post((t_object*)x, "makes internal \"%s\" explorer", name.c_str()); return kTTErrNone; }
TTErr TTHash::remove(const TTSymbol& key) { lock(); HASHMAP->erase(TTPtrSizedInt(key.rawpointer())); unlock(); return kTTErrNone; }
MaxErr MidiOutGetDevice(MidiOutPtr self, void* attr, AtomCount* argc, AtomPtr* argv) { TTValue v; TTSymbol s; self->graphObject->mKernel->getAttributeValue(TT("device"), v); v.get(0, s); if (!s) return MAX_ERR_GENERIC; *argc = 1; if (!(*argv)) // otherwise use memory passed in *argv = (t_atom *)sysmem_newptr(sizeof(t_atom)); atom_setsym(*argv, gensym((char*)s.c_str())); return MAX_ERR_NONE; }
void TTSCORE_EXPORT TTExpressionParseFromValue(const TTValue& toParse, TTExpression& anExpression) { // if the expression is composed by one symbol if (toParse.size() == 1 && toParse[0].type() == kTypeSymbol) { TTSymbol s = toParse[0]; anExpression = TTExpression(s.c_str()); } else { // copy to protect the value TTValue v = toParse; v.toString(); anExpression = TTExpression(TTString(v[0])); } }
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; }
TTErr DemoAppEventStatusChangedCallback(const TTValue& baton, const TTValue& value) { DemoApp* demoApp = (DemoApp*)TTPtr(baton[0]); TTObject event = value[0]; TTSymbol newStatus = value[1]; TTSymbol oldStatus = value[2]; // get the name of the event TTSymbol name; event.get("name", name); // print the event status TTLogMessage("%s status : %s \n", name.c_str(), newStatus.c_str()); return kTTErrNone; }
t_max_err dataspace_setDataspace(t_dataspace *self, void *attr, long argc, t_atom *argv) { TTValue v; TTSymbol s; self->attr_dataspace = atom_getsym(argv); self->dataspace->setAttributeValue(TT("dataspace"), TT(self->attr_dataspace->s_name)); self->dataspace->getAttributeValue(TT("inputUnit"), v); v.get(0, s); self->attr_dataspace_active = gensym(s.c_str()); self->dataspace->getAttributeValue(TT("outputUnit"), v); v.get(0, s); self->attr_dataspace_native = gensym(s.c_str()); return MAX_ERR_NONE; }
void dataspace_getUnits(t_dataspace *self) { t_atom a[2]; TTValue v; atom_setsym(a+0, gensym("clear")); object_obex_dumpout(self, gensym("UnitMenu"), 1, a); self->dataspace->sendMessage(TT("getAvailableUnits"), v, v); for (int i=0; i < v.getSize(); i++) { TTSymbol name; v.get(i, name); atom_setsym(a+0, gensym("append")); atom_setsym(a+1, gensym(name.c_str())); object_obex_dumpout(self, gensym("UnitMenu"), 2, a); } }
t_jit_err StencilGetEdges(StencilObjectPtr self, Ptr attr, AtomCount* ac, AtomPtr* av) { TTValue v; TTSymbol s; if (*ac && *av) { ; // memory passed-in, use it } else { *av = (AtomPtr)sysmem_newptr(sizeof(Atom)); } *ac = 1; self->stencilObject->getAttributeValue(TT("edges"), v); v.get(0, s); atom_setsym(*av, gensym(s.c_str())); return JIT_ERR_NONE; }
// Attributes of attributes void ramp_getFunctionParameter(t_ramp *obj, t_symbol *msg, long argc, t_atom *argv) { t_atom* a; TTSymbol* parameterName; TTValue parameterValue; int numValues; int i; TTSymbol* tempSymbol; double tempValue; TTValue v; if (!argc) { error("jcom.ramp: not enough arguments to function.parameter.get"); return; } // get the correct TT name for the parameter given the Max name parameterName = TT(atom_getsym(argv)->s_name); obj->parameterNames->lookup(parameterName, v); v.get(0, ¶meterName); obj->rampUnit->getFunctionParameterValue(parameterName, parameterValue); numValues = parameterValue.getSize(); if (numValues) { a = (t_atom *)sysmem_newptr(sizeof(t_atom) * (numValues+1)); // First list item is name of parameter atom_setsym(a, gensym((char*)parameterName->getCString())); // Next the whole shebang is copied for (i=0; i<numValues; i++) { if (parameterValue.getType(i) == kTypeSymbol) { parameterValue.get(i, &tempSymbol); atom_setsym(a+i+1, gensym((char*)tempSymbol->getCString())); } else { parameterValue.get(i, tempValue); atom_setfloat(a+i+1, tempValue); } } object_obex_dumpout(obj, gensym("function.parameter.get"), numValues+1, a); // The pointer to an atom assign in the getParameter method needs to be freed. sysmem_freeptr(a); } }
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); }
TTObject::TTObject(const TTSymbol aClassName) : mObjectInstance(NULL) { TTErr err = ttEnvironment->createInstance(aClassName, &mObjectInstance, TTValue()); if (err) { TTLogError("TTObject -- error %i instantiating %s\n", err, aClassName.c_str()); throw TTException("object instantiation failed"); } }
void ramp_getDrives(t_ramp *x) { t_atom a[2]; long numRampUnits = 0; long i; TTValue rampUnitNames; TTSymbol* aName; atom_setsym(a+0, gensym("clear")); object_obex_dumpout(x, gensym("drives"), 1, a); RampLib::getUnitNames(rampUnitNames); numRampUnits = rampUnitNames.getSize(); atom_setsym(a+0, gensym("append")); for (i=0; i<numRampUnits; i++) { rampUnitNames.get(i, &aName); atom_setsym(a+1, gensym((char*)aName->getCString())); object_obex_dumpout(x, gensym("drives"), 2, a); }}
TTAddressItemPtr TTAddressItem::getItem(TTSymbol aSymbol) { TTAddressItemPtr anItem = NULL; TTValue found; TTErr err = ((TTListPtr)this)->find(&TTAddressItemFind, aSymbol.rawpointer(), found); if (!err) anItem = TTAddressItemPtr((TTPtr)found[0]); return anItem; }
void MidiOutGetDeviceNames(MidiOutPtr self) { TTValue v; TTErr err; AtomCount ac; AtomPtr ap; TTSymbol name; err = self->graphObject->mKernel->sendMessage(TT("getAvailableDeviceNames"), kTTValNONE, v); if (!err) { ac = v.getSize(); ap = new Atom[ac]; for (AtomCount i=0; i<ac; i++) { v.get(i, name); atom_setsym(ap+i, gensym((char*)name.c_str())); } object_obex_dumpout(self, gensym("getAvailableDeviceNames"), ac, ap); delete ap; } }
void ramp_getFunctions(t_ramp *x) { t_atom a[2]; long numFunctions = 0; long i; TTValue functionNames; TTSymbol* aName; atom_setsym(a+0, gensym("clear")); object_obex_dumpout(x, gensym("functions"), 1, a); FunctionLib::getUnitNames(functionNames); numFunctions = functionNames.getSize(); atom_setsym(a+0, gensym("append")); for (i=0; i<numFunctions; i++) { functionNames.get(i, &aName); atom_setsym(a+1, gensym((char*)aName->getCString())); object_obex_dumpout(x, gensym("functions"), 2, a); } }
TTErr TTDictionary::remove(const TTSymbol& key) { // TTValue v; // TTErr err; // err = mList->find(TTDictionaryFindKeyInList, key.rawpointer(), v); // if (!err) // mList->remove(v); // return mHashTable->remove(key); mMap.erase(key.getSymbolId()); return kTTErrNone; }
void ramp_attrget(t_ramp *x, t_symbol *msg, long argc, t_atom *argv) { t_atom* a; TTSymbol* parameterName; TTValue parameterValue; int numValues; int i; TTSymbol* tempSymbol; double tempValue; if (!argc) { error("jcom.ramp: not enough arguments to parameter.get"); return; } parameterName = TT(atom_getsym(argv)->s_name); x->rampUnit->getAttributeValue(parameterName, parameterValue); numValues = parameterValue.getSize(); if (numValues) { a = (t_atom *)sysmem_newptr(sizeof(t_atom) * (numValues+1)); // First list item is name of parameter atom_setsym(a, gensym((char*)parameterName->getCString())); // Next the whole shebang is copied for (i=0; i<numValues; i++) { if (parameterValue.getType(i) == kTypeSymbol) { parameterValue.get(i, &tempSymbol); atom_setsym(a+i+1, gensym((char*)tempSymbol->getCString())); } else { parameterValue.get(i, tempValue); atom_setfloat(a+i+1, tempValue); } } object_obex_dumpout(x, gensym("current.parameter"), numValues+1, a); // The pointer to an atom assign in the getParameter method needs to be freed. sysmem_freeptr(a); } }
t_max_err wrappedClass_attrGet(TTPtr self, t_object* attr, long* argc, t_atom** argv) { t_symbol* attrName = (t_symbol*)object_method(attr, _sym_getname); TTValue v; long i; WrappedInstancePtr x = (WrappedInstancePtr)self; TTPtr rawpointer = NULL; rawpointer = x->wrappedClassDefinition->pdNamesToTTNames[attrName->s_name]; // err = hashtab_lookup(x->wrappedClassDefinition->pdNamesToTTNames, attrName, (t_object**)&rawpointer); if (!rawpointer) return -2; // MAX_ERR_INVALID_PTR TTSymbol ttAttrName(rawpointer); x->wrappedObject->get(ttAttrName, v); *argc = v.size(); if (!(*argv)) // otherwise use memory passed in *argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * v.size()); for (i=0; i<v.size(); i++) { if (v[i].type() == kTypeFloat32 || v[i].type() == kTypeFloat64) { TTFloat64 value; value = v[i]; atom_setfloat(*argv+i, value); } else if (v[i].type() == kTypeSymbol) { TTSymbol value; value = v[i]; atom_setsym(*argv+i, gensym((char*)value.c_str())); } else { // assume int TTInt32 value; value = v[i]; atom_setlong(*argv+i, value); } } return 0; }