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