Index: cpp/frams/param/mutableparam.cpp
===================================================================
--- cpp/frams/param/mutableparam.cpp	(revision 791)
+++ cpp/frams/param/mutableparam.cpp	(revision 792)
@@ -7,131 +7,131 @@
 
 #define FIELDSTRUCT MutableParam
-ParamEntry MutableParam::pe_tab[]=
-{
-{"clear",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove all properties","p",PROCEDURE(p_clear),},
-{"add",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"add property (id,type,name,help)","p",PROCEDURE(p_addprop),},
-{"remove",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove property (index)","p",PROCEDURE(p_remprop),},
-{"addGroup",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"add group (name)","p",PROCEDURE(p_addgroup),},
-{"removeGroup",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove group (index)","p",PROCEDURE(p_remgroup),},
-{"changedProperty",0,PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY,"last changed property #","d",FIELD(changed),},
-{"changedPropertyId",0,PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY,"last changed property id","s",GETONLY(changedname),},
+ParamEntry MutableParam::pe_tab[] =
+{
+	{ "clear", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove all properties", "p", PROCEDURE(p_clear), },
+	{ "add", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "add property (id,type,name,help)", "p", PROCEDURE(p_addprop), },
+	{ "remove", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove property (index)", "p", PROCEDURE(p_remprop), },
+	{ "addGroup", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "add group (name)", "p", PROCEDURE(p_addgroup), },
+	{ "removeGroup", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove group (index)", "p", PROCEDURE(p_remgroup), },
+	{ "changedProperty", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY, "last changed property #", "d", FIELD(changed), },
+	{ "changedPropertyId", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY, "last changed property id", "s", GETONLY(changedname), },
 };
 #undef FIELDSTRUCT
 
-MutableParam::MutableParam(const char*n,const char*g,int gr0)
-	:SimpleAbstractParam(this,n),persistgroup0(gr0),grprefix(g)
-{
-if (persistgroup0)
-	addGroup(grprefix,1);
-}
-
-int MutableParam::findGroup(const SString name,int ignoreprefix)
-{
-int skipprefix=grprefix.len()?grprefix.len()+2:0;
-for (int i=0;i<groups.size();i++)
-	{
-	if (ignoreprefix)
+MutableParam::MutableParam(const char*n, const char*g, int gr0)
+	:SimpleAbstractParam(this, n), persistgroup0(gr0), grprefix(g)
+{
+	if (persistgroup0)
+		addGroup(grprefix, 1);
+}
+
+int MutableParam::findGroup(const SString name, int ignoreprefix)
+{
+	int skipprefix = grprefix.len() ? grprefix.len() + 2 : 0;
+	for (int i = 0; i < groups.size(); i++)
+	{
+		if (ignoreprefix)
 		{
-      const char *noprefix=groupname(i).c_str();
-      if ((int)strlen(noprefix) < skipprefix) continue;
-		noprefix+=skipprefix;
-		if (!strcmp(noprefix,name.c_str())) return i;
+			const char *noprefix = groupname(i).c_str();
+			if ((int)strlen(noprefix) < skipprefix) continue;
+			noprefix += skipprefix;
+			if (!strcmp(noprefix, name.c_str())) return i;
 		}
 		else
-			if (groupname(i)==name) return i;
-	}
-return -1;
-}
-
-int MutableParam::addGroup(const SString& gname,int noprefix)
-{
-SString tmp;
-if (noprefix)
-	tmp=gname;
-else
-	{
-	tmp=grprefix;
-	if (tmp.len()) tmp+=": ";
-	tmp+=gname;
-	}
-groups+=new SString(tmp);
-int position=groups.size()-1;
-ongroupadd.action(position);
-return position;
+			if (groupname(i) == name) return i;
+	}
+	return -1;
+}
+
+int MutableParam::addGroup(const SString& gname, int noprefix)
+{
+	SString tmp;
+	if (noprefix)
+		tmp = gname;
+	else
+	{
+		tmp = grprefix;
+		if (tmp.len()) tmp += ": ";
+		tmp += gname;
+	}
+	groups += new SString(tmp);
+	int position = groups.size() - 1;
+	ongroupadd.action(position);
+	return position;
 }
 
 void MutableParam::removeGroup(int g)
 {
-if ((g<0)||(g>=MutableParam::getGroupCount())) return;
-ParamEntry *e;
-for (int i=MutableParam::getPropCount()-1;i>=staticprops;i--)
-	{
-	e=entry(i);
-	if (g==e->group)
-		removeProperty(i);
-	}
-SString *s=(SString *)groups(g);
-if (s) delete s;
-groups-=g;
-ongroupdelete.action(g);
-}
-
-int MutableParam::grmember(int g,int a)
-{
-if (g==0)
-	{
-	if (getGroupCount()<2)
-		return (a<getPropCount())?a:-9999;
-	if (a<staticprops) return a;
-	a-=staticprops;
-	}
-ParamEntry *e;
-for (int i=staticprops;e=entry(i);i++)
-	if (g==e->group)
-		if (!a--) return i;
-return -9999;
-}
-
-int MutableParam::addProperty(ParamEntry *pe,int position)
-{
-DB(printf("MutableParam::add(%s)\n",pe->id));
-if (position<0)
-	position=entries.size()+staticprops;
-entries.insert(position-staticprops,pe);
-
-if (pe->offset)
-	pe->flags &= ~MUTPARAM_ALLOCDATA;
-else
-	{
-	pe->flags |= MUTPARAM_ALLOCDATA;
-	void *d=0;
-	switch(pe->type[0])
+	if ((g < 0) || (g >= MutableParam::getGroupCount())) return;
+	ParamEntry *e;
+	for (int i = MutableParam::getPropCount() - 1; i >= staticprops; i--)
+	{
+		e = entry(i);
+		if (g == e->group)
+			removeProperty(i);
+	}
+	SString *s = (SString *)groups(g);
+	if (s) delete s;
+	groups -= g;
+	ongroupdelete.action(g);
+}
+
+int MutableParam::grmember(int g, int a)
+{
+	if (g == 0)
+	{
+		if (getGroupCount() < 2)
+			return (a < getPropCount()) ? a : -9999;
+		if (a < staticprops) return a;
+		a -= staticprops;
+	}
+	ParamEntry *e;
+	for (int i = staticprops; e = entry(i); i++)
+		if (g == e->group)
+			if (!a--) return i;
+	return -9999;
+}
+
+int MutableParam::addProperty(ParamEntry *pe, int position)
+{
+	DB(printf("MutableParam::add(%s)\n", pe->id));
+	if (position < 0)
+		position = entries.size() + staticprops;
+	entries.insert(position - staticprops, pe);
+
+	if (pe->offset)
+		pe->flags &= ~MUTPARAM_ALLOCDATA;
+	else
+	{
+		pe->flags |= MUTPARAM_ALLOCDATA;
+		void *d = 0;
+		switch (pe->type[0])
 		{
-		case 'd': d=new paInt(); *((paInt*)d)=0; break;
-		case 'f': d=new double(); *((double*)d)=0; break;
-		case 's': d=new SString(); break;
-		case 'x': d=new ExtValue(); break;
-		case 'o': d=new ExtObject(); break;
+		case 'd': d = new paInt(); *((paInt*)d) = 0; break;
+		case 'f': d = new double(); *((double*)d) = 0; break;
+		case 's': d = new SString(); break;
+		case 'x': d = new ExtValue(); break;
+		case 'o': d = new ExtObject(); break;
 		}
-	pe->offset=(intptr_t)d;
-	}
-onadd.action(position);
-return position;
+		pe->offset = (intptr_t)d;
+	}
+	onadd.action(position);
+	return position;
 }
 
 ParamEntry * MutableParam::removeProperty(ParamEntry *pe)
 {
-   int index=entries.find(pe);
-   if (index>=0) return removeProperty(index); else return pe;
+	int index = entries.find(pe);
+	if (index >= 0) return removeProperty(index); else return pe;
 }
 
 ParamEntry * MutableParam::removeProperty(int i)
 {
-ParamEntry *pe=(ParamEntry *)entries(i-staticprops);
-DB(printf("MutableParam::remove(%d)\n",i));
-void *d=(void*)pe->offset;
-if (d && (pe->flags & MUTPARAM_ALLOCDATA))
-	switch(pe->type[0])
-		{
+	ParamEntry *pe = (ParamEntry *)entries(i - staticprops);
+	DB(printf("MutableParam::remove(%d)\n", i));
+	void *d = (void*)pe->offset;
+	if (d && (pe->flags & MUTPARAM_ALLOCDATA))
+		switch (pe->type[0])
+	{
 		case 'd': delete (paInt*)d; break;
 		case 'f': delete (double*)d; break;
@@ -139,142 +139,144 @@
 		case 'x': delete (ExtValue*)d; break;
 		case 'o': delete (ExtObject*)d; break;
+	}
+	entries -= i - staticprops;
+	if (pe->flags & MUTPARAM_ALLOCENTRY)
+	{
+		if (pe->name) free((void*)pe->name);
+		if (pe->id) free((void*)pe->id);
+		if (pe->help) free((void*)pe->help);
+		if (pe->type) free((void*)pe->type);
+		delete pe;
+	}
+	ondelete.action(i);
+	return pe;
+}
+
+void MutableParam::clear(int everything)
+{
+	DB(printf("MutableParam::clear\n"));
+	for (int i = entries.size() - 1; i >= 0; i--)
+		removeProperty(i + staticprops);
+	int lastgroup = (everything || (persistgroup0 == 0)) ? 0 : 1;
+	for (int i = groups.size() - 1; i >= lastgroup; i--)
+		removeGroup(i);
+}
+
+void MutableParam::p_clear(ExtValue *args, ExtValue *ret)
+{
+	clear();
+}
+
+int MutableParam::addProperty(void* data, const char* id, const char* type, const char* name, const char* help, int flags, int group, int position)
+{
+	if ((!id) && (!type)) return -1;
+	if (!isValidTypeDescription(type)) return -1;
+	ParamEntry *pe = new ParamEntry();
+	pe->fun1 = 0; pe->fun2 = 0;
+	pe->group = (paInt)group;
+	pe->flags = (paInt)(flags | MUTPARAM_ALLOCENTRY);
+	pe->offset = (intptr_t)data;
+	pe->id = strdup(id);
+	pe->type = strdup(type);
+	pe->name = name ? strdup(name) : 0;
+	pe->help = help ? strdup(help) : 0;
+	return addProperty(pe, position);
+}
+
+void MutableParam::p_addprop(ExtValue *args, ExtValue *ret)
+{
+	int i = addProperty(0, args[2].getString().c_str(), args[1].getString().c_str(), args[0].getString().c_str());
+	ret->setInt(i);
+}
+
+void MutableParam::p_remprop(ExtValue *args, ExtValue *ret)
+{
+	removeProperty(args[0].getInt());
+}
+
+void MutableParam::p_addgroup(ExtValue *args, ExtValue *ret)
+{
+	int i = addGroup(args[0].getString());
+	ret->setInt(i);
+}
+
+void MutableParam::p_remgroup(ExtValue *args, ExtValue *ret)
+{
+	removeGroup(args[0].getInt());
+}
+
+void MutableParam::notify(int id)
+{
+	changed = id;
+	onactivate.action(id);
+}
+
+int MutableParam::setInt(int i, paInt v)
+{
+	int ret = SimpleAbstractParam::setInt(i, v);
+	if (ret & PSET_CHANGED) notify(i);
+	return ret;
+}
+
+int MutableParam::setDouble(int i, double v)
+{
+	int ret = SimpleAbstractParam::setDouble(i, v);
+	if (ret & PSET_CHANGED) notify(i);
+	return ret;
+}
+
+int MutableParam::setString(int i, const SString &v)
+{
+	int ret = SimpleAbstractParam::setString(i, v);
+	if (ret & PSET_CHANGED) notify(i);
+	return ret;
+}
+
+int MutableParam::setObject(int i, const ExtObject &v)
+{
+	int ret = SimpleAbstractParam::setObject(i, v);
+	if (ret & PSET_CHANGED) notify(i);
+	return ret;
+}
+
+int MutableParam::setExtValue(int i, const ExtValue &v)
+{
+	int ret = SimpleAbstractParam::setExtValue(i, v);
+	if (ret & PSET_CHANGED) notify(i);
+	return ret;
+}
+
+void MutableParam::call(int i, ExtValue* args, ExtValue *ret)
+{
+	if (i < staticprops) return SimpleAbstractParam::call(i, args, ret);
+	notify(i);
+}
+
+///////////////////
+
+void ParamSaver::clear()
+{
+	for (int i = 0; i < store.size(); i += 2)
+	{
+		SString *n = (SString*)store(i);
+		ExtValue *v = (ExtValue*)store(i + 1);
+		delete n;
+		delete v;
+	}
+	store.clear();
+}
+
+void ParamSaver::loadFrom(ParamInterface& p)
+{
+	int N = p.getPropCount();
+	for (int i = 0; i < N; i++)
+	{
+		if (shouldLoad(p, i))
+		{
+			ExtValue v;
+			p.get(i, v);
+			store += new SString(p.id(i));
+			store += new ExtValue(v);
 		}
-entries-=i-staticprops;
-if (pe->flags & MUTPARAM_ALLOCENTRY)
-	{
-	if (pe->name) free((void*)pe->name);
-	if (pe->id) free((void*)pe->id);
-	if (pe->help) free((void*)pe->help);
-	if (pe->type) free((void*)pe->type);
-	delete pe;
-	}
-ondelete.action(i);
-return pe;
-}
-
-void MutableParam::clear(int everything)
-{
-DB(printf("MutableParam::clear\n"));
-for (int i=entries.size()-1;i>=0;i--)
-	removeProperty(i+staticprops);
-int lastgroup=(everything || (persistgroup0==0))?0:1;
-for (int i=groups.size()-1;i>=lastgroup;i--)
-	removeGroup(i);
-}
-
-void MutableParam::p_clear(ExtValue *args,ExtValue *ret)
-{ clear(); }
-
-int MutableParam::addProperty(void* data,const char* id,const char* type,const char* name,const char* help,int flags,int group,int position)
-{
-if ((!id)&&(!type)) return -1;
-if (!isValidTypeDescription(type)) return -1;
-ParamEntry *pe=new ParamEntry();
-pe->fun1=0; pe->fun2=0;
-pe->group=(paInt)group;
-pe->flags=(paInt)(flags | MUTPARAM_ALLOCENTRY);
-pe->offset=(intptr_t)data;
-pe->id=strdup(id);
-pe->type=strdup(type);
-pe->name=name?strdup(name):0;
-pe->help=help?strdup(help):0;
-return addProperty(pe,position);
-}
-
-void MutableParam::p_addprop(ExtValue *args,ExtValue *ret)
-{
-int i=addProperty(0,args[2].getString().c_str(),args[1].getString().c_str(),args[0].getString().c_str());
-ret->setInt(i);
-}
-
-void MutableParam::p_remprop(ExtValue *args,ExtValue *ret)
-{
-removeProperty(args[0].getInt());
-}
-
-void MutableParam::p_addgroup(ExtValue *args,ExtValue *ret)
-{
-int i=addGroup(args[0].getString());
-ret->setInt(i);
-}
-
-void MutableParam::p_remgroup(ExtValue *args,ExtValue *ret)
-{
-removeGroup(args[0].getInt());
-}
-
-void MutableParam::notify(int id)
-{
-changed=id;
-onactivate.action(id);
-}
-
-int MutableParam::setInt(int i,paInt v)
-{
-int ret=SimpleAbstractParam::setInt(i,v);
-if (ret & PSET_CHANGED) notify(i);
-return ret;
-}
-
-int MutableParam::setDouble(int i,double v)
-{
-int ret=SimpleAbstractParam::setDouble(i,v);
-if (ret & PSET_CHANGED) notify(i);
-return ret;
-}
-
-int MutableParam::setString(int i,const SString &v)
-{
-int ret=SimpleAbstractParam::setString(i,v);
-if (ret & PSET_CHANGED) notify(i);
-return ret;
-}
-
-int MutableParam::setObject(int i,const ExtObject &v)
-{
-int ret=SimpleAbstractParam::setObject(i,v);
-if (ret & PSET_CHANGED) notify(i);
-return ret;
-}
-
-int MutableParam::setExtValue(int i,const ExtValue &v)
-{
-int ret=SimpleAbstractParam::setExtValue(i,v);
-if (ret & PSET_CHANGED) notify(i);
-return ret;
-}
-
-void MutableParam::call(int i,ExtValue* args,ExtValue *ret)
-{
-if (i<staticprops) return SimpleAbstractParam::call(i,args,ret);
-notify(i);
-}
-
-///////////////////
-
-void ParamSaver::clear()
-{
-for(int i=0;i<store.size();i+=2)
-	{
-	SString *n=(SString*)store(i);
-	ExtValue *v=(ExtValue*)store(i+1);
-	delete n;
-	delete v;
-	}	
-store.clear();
-}
-
-void ParamSaver::loadFrom(ParamInterface& p)
-{
-int N=p.getPropCount();
-for(int i=0;i<N;i++)
-	{
-	if (shouldLoad(p,i))
-		{
-		ExtValue v;
-		p.get(i,v);
-		store+=new SString(p.id(i));
-		store+=new ExtValue(v);
-		}
 	}
 }
@@ -282,11 +284,11 @@
 void ParamSaver::saveTo(MutableParam& p)
 {
-for(int i=0;i<store.size();i+=2)
-	{
-	SString *n=(SString*)store(i);
-	int prop=p.findId(n->c_str());
-	if (prop<0)
-		prop=p.addProperty(0,n->c_str(),"x",0,0,0,0,-1);
-	p.setExtValue(prop,*(ExtValue*)store(i+1));
-	}
-}
+	for (int i = 0; i < store.size(); i += 2)
+	{
+		SString *n = (SString*)store(i);
+		int prop = p.findId(n->c_str());
+		if (prop < 0)
+			prop = p.addProperty(0, n->c_str(), "x", 0, 0, 0, 0, -1);
+		p.setExtValue(prop, *(ExtValue*)store(i + 1));
+	}
+}
Index: cpp/frams/param/mutparamiface.h
===================================================================
--- cpp/frams/param/mutparamiface.h	(revision 791)
+++ cpp/frams/param/mutparamiface.h	(revision 792)
@@ -9,14 +9,14 @@
 #include "param.h"
 
-class MutableParamInterface: public virtual ParamInterface
+class MutableParamInterface : public virtual ParamInterface
 {
 public:
-Callback onadd;
-Callback ondelete;
-Callback onchange;
-Callback ongroupadd;
-Callback ongroupdelete;
-Callback ongroupchange;
-Callback onactivate;
+	Callback onadd;
+	Callback ondelete;
+	Callback onchange;
+	Callback ongroupadd;
+	Callback ongroupdelete;
+	Callback ongroupchange;
+	Callback onactivate;
 };
 
Index: cpp/frams/param/mutparamlist.cpp
===================================================================
--- cpp/frams/param/mutparamlist.cpp	(revision 791)
+++ cpp/frams/param/mutparamlist.cpp	(revision 792)
@@ -8,52 +8,55 @@
 struct ParamInfo
 {
-ParamInterface *pi;
-MutableParamInterface *mpi;
-CallbackNode *anode,*dnode,*ganode,*gdnode,*cnode,*gcnode,*panode;
-int firstprop, firstgroup;
-int propcount, groupcount;
+	ParamInterface *pi;
+	MutableParamInterface *mpi;
+	CallbackNode *anode, *dnode, *ganode, *gdnode, *cnode, *gcnode, *panode;
+	int firstprop, firstgroup;
+	int propcount, groupcount;
 };
 
 ParamInfo* MutableParamList::getParamInfo(int i)
 {
-return (ParamInfo*)list(i);
-}
-
-void MutableParamList::addPI(int pos,ParamInfo *pi)
-{
-int propcount=pi->propcount;
-int groupcount=pi->groupcount;
-if (pos==0)
-	{ pi->firstprop=0; pi->firstgroup=0; }
-else
-	{
-	ParamInfo *prev_pi=getParamInfo(pos-1);
-	pi->firstprop=prev_pi->firstprop+prev_pi->propcount;
-	pi->firstgroup=prev_pi->firstgroup+prev_pi->groupcount;
-	}
-list.insert(pos,pi);
-pi->propcount=0;
-pi->groupcount=0;
-for (int i=0;i<groupcount;i++)
-	{
-	pi->groupcount=i+1;
-	adjustPI(pos+1,0,1);
-	ongroupadd.action(pi->firstgroup+i);
-	}
-for (int i=0;i<propcount;i++)
-	{
-	pi->propcount=i+1;
-	adjustPI(pos+1,1,0);
-	onadd.action(pi->firstprop+i);
-	}
-if (pi->mpi)
-	{
-	pi->anode=pi->mpi->onadd.add(STATRICKCALLBACK(this,&MutableParamList::onPropAdd,pi));
-	pi->ganode=pi->mpi->ongroupadd.add(STATRICKCALLBACK(this,&MutableParamList::onGroupAdd,pi));
-	pi->dnode=pi->mpi->ondelete.add(STATRICKCALLBACK(this,&MutableParamList::onPropDelete,pi));
-	pi->gdnode=pi->mpi->ongroupdelete.add(STATRICKCALLBACK(this,&MutableParamList::onGroupDelete,pi));
-	pi->cnode=pi->mpi->onchange.add(STATRICKCALLBACK(this,&MutableParamList::onPropChange,pi));
-	pi->gcnode=pi->mpi->ongroupchange.add(STATRICKCALLBACK(this,&MutableParamList::onGroupChange,pi));
-	pi->panode=pi->mpi->onactivate.add(STATRICKCALLBACK(this,&MutableParamList::onPropActivate,pi));
+	return (ParamInfo*)list(i);
+}
+
+void MutableParamList::addPI(int pos, ParamInfo *pi)
+{
+	int propcount = pi->propcount;
+	int groupcount = pi->groupcount;
+	if (pos == 0)
+	{
+		pi->firstprop = 0;
+		pi->firstgroup = 0;
+	}
+	else
+	{
+		ParamInfo *prev_pi = getParamInfo(pos - 1);
+		pi->firstprop = prev_pi->firstprop + prev_pi->propcount;
+		pi->firstgroup = prev_pi->firstgroup + prev_pi->groupcount;
+	}
+	list.insert(pos, pi);
+	pi->propcount = 0;
+	pi->groupcount = 0;
+	for (int i = 0; i < groupcount; i++)
+	{
+		pi->groupcount = i + 1;
+		adjustPI(pos + 1, 0, 1);
+		ongroupadd.action(pi->firstgroup + i);
+	}
+	for (int i = 0; i < propcount; i++)
+	{
+		pi->propcount = i + 1;
+		adjustPI(pos + 1, 1, 0);
+		onadd.action(pi->firstprop + i);
+	}
+	if (pi->mpi)
+	{
+		pi->anode = pi->mpi->onadd.add(STATRICKCALLBACK(this, &MutableParamList::onPropAdd, pi));
+		pi->ganode = pi->mpi->ongroupadd.add(STATRICKCALLBACK(this, &MutableParamList::onGroupAdd, pi));
+		pi->dnode = pi->mpi->ondelete.add(STATRICKCALLBACK(this, &MutableParamList::onPropDelete, pi));
+		pi->gdnode = pi->mpi->ongroupdelete.add(STATRICKCALLBACK(this, &MutableParamList::onGroupDelete, pi));
+		pi->cnode = pi->mpi->onchange.add(STATRICKCALLBACK(this, &MutableParamList::onPropChange, pi));
+		pi->gcnode = pi->mpi->ongroupchange.add(STATRICKCALLBACK(this, &MutableParamList::onGroupChange, pi));
+		pi->panode = pi->mpi->onactivate.add(STATRICKCALLBACK(this, &MutableParamList::onPropActivate, pi));
 	}
 }
@@ -61,30 +64,30 @@
 int MutableParamList::findPI(ParamInfo *pi)
 {
-return list.find((void*)pi);
+	return list.find((void*)pi);
 }
 
 int MutableParamList::findPI(ParamInterface *p)
 {
-ParamInfo *pi;
-for(int i=0;pi=(ParamInfo*)list(i);i++)
-	if ((!pi->mpi)&&(pi->pi==p)) return i;
-return -1;
+	ParamInfo *pi;
+	for (int i = 0; pi = (ParamInfo*)list(i); i++)
+		if ((!pi->mpi) && (pi->pi == p)) return i;
+	return -1;
 }
 
 int MutableParamList::findPI(MutableParamInterface *p)
 {
-ParamInfo *pi;
-for(int i=0;pi=(ParamInfo*)list(i);i++)
-	if ((pi->mpi)&&(pi->mpi==p)) return i;
-return -1;
-}
-
-void MutableParamList::adjustPI(int firstPI,int addprop,int addgroup)
-{
-ParamInfo *pi;
-for (int i=firstPI;pi=getParamInfo(i);i++)
-	{
-	pi->firstprop+=addprop;
-	pi->firstgroup+=addgroup;
+	ParamInfo *pi;
+	for (int i = 0; pi = (ParamInfo*)list(i); i++)
+		if ((pi->mpi) && (pi->mpi == p)) return i;
+	return -1;
+}
+
+void MutableParamList::adjustPI(int firstPI, int addprop, int addgroup)
+{
+	ParamInfo *pi;
+	for (int i = firstPI; pi = getParamInfo(i); i++)
+	{
+		pi->firstprop += addprop;
+		pi->firstgroup += addgroup;
 	}
 }
@@ -92,191 +95,191 @@
 void MutableParamList::removePI(int pi_index)
 {
-if (pi_index<0) return;
-ParamInfo *pi=getParamInfo(pi_index);
-for (int i=pi->propcount-1;i>=0;i--)
-	{
-	pi->propcount=i;
-	adjustPI(pi_index+1,-1,0);
-	ondelete.action(i);
-	}
-for (int i=pi->groupcount-1;i>=0;i--)
-	{
-	pi->groupcount=i;
-	adjustPI(pi_index+1,0,-1);
-	ongroupdelete.action(i);
-	}
-list-=(pi_index);
-if (pi->mpi)
-	{
-	pi->mpi->onadd.remove(pi->anode);
-	pi->mpi->ongroupadd.remove(pi->ganode);
-	pi->mpi->ondelete.remove(pi->dnode);
-	pi->mpi->ongroupdelete.remove(pi->gdnode);
-	pi->mpi->onchange.remove(pi->cnode);
-	pi->mpi->ongroupchange.remove(pi->gcnode);
-	pi->mpi->onactivate.remove(pi->panode);
-	}
-delete pi;
+	if (pi_index < 0) return;
+	ParamInfo *pi = getParamInfo(pi_index);
+	for (int i = pi->propcount - 1; i >= 0; i--)
+	{
+		pi->propcount = i;
+		adjustPI(pi_index + 1, -1, 0);
+		ondelete.action(i);
+	}
+	for (int i = pi->groupcount - 1; i >= 0; i--)
+	{
+		pi->groupcount = i;
+		adjustPI(pi_index + 1, 0, -1);
+		ongroupdelete.action(i);
+	}
+	list -= (pi_index);
+	if (pi->mpi)
+	{
+		pi->mpi->onadd.remove(pi->anode);
+		pi->mpi->ongroupadd.remove(pi->ganode);
+		pi->mpi->ondelete.remove(pi->dnode);
+		pi->mpi->ongroupdelete.remove(pi->gdnode);
+		pi->mpi->onchange.remove(pi->cnode);
+		pi->mpi->ongroupchange.remove(pi->gcnode);
+		pi->mpi->onactivate.remove(pi->panode);
+	}
+	delete pi;
 }
 
 MutableParamList::~MutableParamList()
 {
-for (int i=list.size()-1;i>=0;i--)
+	for (int i = list.size() - 1; i >= 0; i--)
+		removePI(i);
+}
+
+void MutableParamList::onPropAdd(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	pi->propcount++;
+	int j = findPI(pi);
+	if (j >= 0)
+		adjustPI(j + 1, 1, 0);
+	onadd.action(pi->firstprop + i);
+}
+
+void MutableParamList::onPropDelete(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	pi->propcount--;
+	int j = findPI(pi);
+	if (j >= 0)
+		adjustPI(j + 1, -1, 0);
+	ondelete.action(pi->firstprop + i);
+}
+
+void MutableParamList::onPropChange(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	onchange.action(pi->firstprop + i);
+}
+
+void MutableParamList::onPropActivate(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	onactivate.action(pi->firstprop + i);
+}
+
+void MutableParamList::onGroupAdd(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	pi->groupcount++;
+	int j = findPI(pi);
+	if (j >= 0)
+		adjustPI(j + 1, 0, 1);
+	ongroupadd.action(pi->firstgroup + i);
+}
+
+void MutableParamList::onGroupDelete(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	pi->groupcount--;
+	int j = findPI(pi);
+	if (j >= 0)
+		adjustPI(j + 1, 0, -1);
+	ongroupdelete.action(pi->firstgroup + i);
+}
+
+void MutableParamList::onGroupChange(void* data, intptr_t i)
+{
+	ParamInfo *pi = (ParamInfo*)data;
+	ongroupchange.action(pi->firstgroup + i);
+}
+
+void MutableParamList::insert(int pos, MutableParamInterface *p)
+{
+	ParamInfo *pi = new ParamInfo();
+	pi->pi = (ParamInterface*)p;
+	pi->mpi = p;
+	pi->propcount = p->getPropCount();
+	pi->groupcount = p->getGroupCount();
+	addPI(pos, pi);
+}
+
+void MutableParamList::insert(int pos, ParamInterface *p)
+{
+	ParamInfo *pi = new ParamInfo();
+	pi->pi = p;
+	pi->mpi = 0;
+	pi->propcount = p->getPropCount();
+	pi->groupcount = p->getGroupCount();
+	addPI(pos, pi);
+}
+
+
+void MutableParamList::operator+=(ParamInterface *p)
+{
+	insert(list.size(), p);
+}
+
+void MutableParamList::operator+=(MutableParamInterface *p)
+{
+	insert(list.size(), p);
+}
+
+
+void MutableParamList::operator-=(ParamInterface *p)
+{
+	int i = findPI(p);
 	removePI(i);
 }
 
-void MutableParamList::onPropAdd(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-pi->propcount++;
-int j=findPI(pi);
-if (j>=0)
-	adjustPI(j+1,1,0);
-onadd.action(pi->firstprop+i);
-}
-
-void MutableParamList::onPropDelete(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-pi->propcount--;
-int j=findPI(pi);
-if (j>=0)
-	adjustPI(j+1,-1,0);
-ondelete.action(pi->firstprop+i);
-}
-
-void MutableParamList::onPropChange(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-onchange.action(pi->firstprop+i);
-}
-
-void MutableParamList::onPropActivate(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-onactivate.action(pi->firstprop+i);
-}
-
-void MutableParamList::onGroupAdd(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-pi->groupcount++;
-int j=findPI(pi);
-if (j>=0)
-	adjustPI(j+1,0,1);
-ongroupadd.action(pi->firstgroup+i);
-}
-
-void MutableParamList::onGroupDelete(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-pi->groupcount--;
-int j=findPI(pi);
-if (j>=0)
-	adjustPI(j+1,0,-1);
-ongroupdelete.action(pi->firstgroup+i);
-}
-
-void MutableParamList::onGroupChange(void* data,intptr_t i)
-{
-ParamInfo *pi=(ParamInfo*)data;
-ongroupchange.action(pi->firstgroup+i);
-}
-
-void MutableParamList::insert(int pos,MutableParamInterface *p)
-{
-ParamInfo *pi=new ParamInfo();
-pi->pi=(ParamInterface*)p;
-pi->mpi=p;
-pi->propcount=p->getPropCount();
-pi->groupcount=p->getGroupCount();
-addPI(pos,pi);
-}
-
-void MutableParamList::insert(int pos,ParamInterface *p)
-{
-ParamInfo *pi=new ParamInfo();
-pi->pi=p;
-pi->mpi=0;
-pi->propcount=p->getPropCount();
-pi->groupcount=p->getGroupCount();
-addPI(pos,pi);
-}
-
-
-void MutableParamList::operator+=(ParamInterface *p)
-{
-insert(list.size(),p);
-}
-
-void MutableParamList::operator+=(MutableParamInterface *p)
-{
-insert(list.size(),p);
-}
-
-
-void MutableParamList::operator-=(ParamInterface *p)
-{
-int i=findPI(p);
-removePI(i);
-}
-
 void MutableParamList::operator-=(MutableParamInterface *p)
 {
-int i=findPI(p);
-removePI(i);
+	int i = findPI(p);
+	removePI(i);
 }
 
 void MutableParamList::operator-=(int i)
 {
-removePI(i);
+	removePI(i);
 }
 
 int MutableParamList::getGroupCount()
 {
-int count=0;
-FOREACH(ParamInfo*,pi,list)
-	count+=pi->groupcount;
-return count;
+	int count = 0;
+	FOREACH(ParamInfo*, pi, list)
+		count += pi->groupcount;
+	return count;
 }
 
 int MutableParamList::getPropCount()
 {
-int count=0;
-FOREACH(ParamInfo*,pi,list)
-	count+=pi->propcount;
-return count;
-}
-
-int MutableParamList::getSubParam(int i,ParamInterface **sub_p,int *sub_i)
-{
-int n;
-FOREACH(ParamInfo*,pi,list)
-	{
-	if (i<(n=pi->propcount))
+	int count = 0;
+	FOREACH(ParamInfo*, pi, list)
+		count += pi->propcount;
+	return count;
+}
+
+int MutableParamList::getSubParam(int i, ParamInterface **sub_p, int *sub_i)
+{
+	int n;
+	FOREACH(ParamInfo*, pi, list)
+	{
+		if (i < (n = pi->propcount))
 		{
-		*sub_p=pi->pi;
-		*sub_i=i;
-		return 1;
+			*sub_p = pi->pi;
+			*sub_i = i;
+			return 1;
 		}
-	i-=n;
-	}
-return 0;
-}
-
-int MutableParamList::getSubGroup(int i,ParamInterface **sub_p,int *sub_i)
-{
-int n;
-FOREACH(ParamInfo*,pi,list)
-	{
-	if (i<(n=pi->groupcount))
+		i -= n;
+	}
+	return 0;
+}
+
+int MutableParamList::getSubGroup(int i, ParamInterface **sub_p, int *sub_i)
+{
+	int n;
+	FOREACH(ParamInfo*, pi, list)
+	{
+		if (i < (n = pi->groupcount))
 		{
-		*sub_p=pi->pi;
-		*sub_i=i;
-		return 1;
+			*sub_p = pi->pi;
+			*sub_i = i;
+			return 1;
 		}
-	i-=n;
-	}
-return 0;
+		i -= n;
+	}
+	return 0;
 }
 
@@ -289,27 +292,27 @@
 }
 
-FUN(const char*,id,0)
-FUN(const char*,name,0)
-FUN(const char*,type,0)
-FUN(const char*,help,0)
-FUN(int,flags,0)
-FUN(SString,getString,SString())
-FUN(paInt,getInt,0)
-FUN(double,getDouble,0)
-FUN(ExtValue,getExtValue,ExtValue((paInt)0))
-FUN(ExtObject,getObject,ExtObject())
+FUN(const char*, id, 0)
+FUN(const char*, name, 0)
+FUN(const char*, type, 0)
+FUN(const char*, help, 0)
+FUN(int, flags, 0)
+FUN(SString, getString, SString())
+FUN(paInt, getInt, 0)
+FUN(double, getDouble, 0)
+FUN(ExtValue, getExtValue, ExtValue((paInt)0))
+FUN(ExtObject, getObject, ExtObject())
 
 int MutableParamList::group(int i)
 {
-int n;
-int g=0;
-FOREACH(ParamInfo*,pi,list)
-	{
-	if (i<(n=pi->propcount))
-		return g + pi->pi->group(i);
-	g+=pi->groupcount;
-	i-=n;
-	}
-return 0;
+	int n;
+	int g = 0;
+	FOREACH(ParamInfo*, pi, list)
+	{
+		if (i < (n = pi->propcount))
+			return g + pi->pi->group(i);
+		g += pi->groupcount;
+		i -= n;
+	}
+	return 0;
 }
 
@@ -322,45 +325,45 @@
 }
 
-FUN2(int,setInt,paInt)
-FUN2(int,setDouble,double)
-FUN2(int,setString,const SString &)
-FUN2(int,setObject,const ExtObject &)
-FUN2(int,setExtValue,const ExtValue &)
-
-void MutableParamList::call(int i,ExtValue* args,ExtValue *ret)
-{
-int j; ParamInterface *pi;
-if (!getSubParam(i,&pi,&j)) return;
-pi->call(j,args,ret);
+FUN2(int, setInt, paInt)
+FUN2(int, setDouble, double)
+FUN2(int, setString, const SString &)
+FUN2(int, setObject, const ExtObject &)
+FUN2(int, setExtValue, const ExtValue &)
+
+void MutableParamList::call(int i, ExtValue* args, ExtValue *ret)
+{
+	int j; ParamInterface *pi;
+	if (!getSubParam(i, &pi, &j)) return;
+	pi->call(j, args, ret);
 }
 
 const char *MutableParamList::grname(int i)
 {
-int j; ParamInterface *pi;
-if (!getSubGroup(i,&pi,&j)) return 0;
-return pi->grname(j);
-}
-
-int MutableParamList::grmember(int gi,int i)
-{
-int n;
-int count=0;
-FOREACH(ParamInfo*,pi,list)
-	{
-	if (gi<(n=pi->groupcount))
+	int j; ParamInterface *pi;
+	if (!getSubGroup(i, &pi, &j)) return 0;
+	return pi->grname(j);
+}
+
+int MutableParamList::grmember(int gi, int i)
+{
+	int n;
+	int count = 0;
+	FOREACH(ParamInfo*, pi, list)
+	{
+		if (gi < (n = pi->groupcount))
 		{
-		int prop=pi->pi->grmember(gi,i);
-		if (prop>=pi->propcount) return -9999;
-		return count+prop;
+			int prop = pi->pi->grmember(gi, i);
+			if (prop >= pi->propcount) return -9999;
+			return count + prop;
 		}
-	count+=pi->propcount;
-	gi-=n;
-	}
-return -9999;
+		count += pi->propcount;
+		gi -= n;
+	}
+	return -9999;
 }
 
 void MutableParamList::clear()
 {
-for (int i=list.size()-1;i>=0;i--)
-	operator-=(i);
-}
+	for (int i = list.size() - 1; i >= 0; i--)
+		operator-=(i);
+}
Index: cpp/frams/param/mutparamlist.h
===================================================================
--- cpp/frams/param/mutparamlist.h	(revision 791)
+++ cpp/frams/param/mutparamlist.h	(revision 792)
@@ -12,86 +12,78 @@
 struct ParamInfo;
 
-class MutableParamList: public virtual ParamInterface, public MutableParamInterface
+class MutableParamList : public virtual ParamInterface, public MutableParamInterface
 {
-SList list;
-const char *objname;
-int getSubParam(int i,ParamInterface **sub_p,int *sub_i);
-int getSubGroup(int i,ParamInterface **sub_p,int *sub_i);
+	SList list;
+	const char *objname;
+	int getSubParam(int i, ParamInterface **sub_p, int *sub_i);
+	int getSubGroup(int i, ParamInterface **sub_p, int *sub_i);
 
-ParamInfo* getParamInfo(int i);
-void addPI(int pos,ParamInfo *pi);
-int findPI(ParamInfo *pi);
-int findPI(ParamInterface *p);
-int findPI(MutableParamInterface *p);
-void adjustPI(int firstPI,int addprop,int addgroup);
-void removePI(int pi_index);
+	ParamInfo* getParamInfo(int i);
+	void addPI(int pos, ParamInfo *pi);
+	int findPI(ParamInfo *pi);
+	int findPI(ParamInterface *p);
+	int findPI(MutableParamInterface *p);
+	void adjustPI(int firstPI, int addprop, int addgroup);
+	void removePI(int pi_index);
 
 #define STATRICKCLASS MutableParamList
-STCALLBACKDEF(onPropAdd);
-STCALLBACKDEF(onPropDelete);
-STCALLBACKDEF(onGroupAdd);
-STCALLBACKDEF(onGroupDelete);
-STCALLBACKDEF(onPropChange);
-STCALLBACKDEF(onGroupChange);
-STCALLBACKDEF(onPropActivate);
+	STCALLBACKDEF(onPropAdd);
+	STCALLBACKDEF(onPropDelete);
+	STCALLBACKDEF(onGroupAdd);
+	STCALLBACKDEF(onGroupDelete);
+	STCALLBACKDEF(onPropChange);
+	STCALLBACKDEF(onGroupChange);
+	STCALLBACKDEF(onPropActivate);
 #undef STATRICKCLASS
 
 public:
 
-void firePropChange(int i) {onchange.action(i);}
-void fireGroupChange(int i) {ongroupchange.action(i);}
+	void firePropChange(int i) { onchange.action(i); }
+	void fireGroupChange(int i) { ongroupchange.action(i); }
 
-MutableParamList(const char* n=0,const char* d=0):objname(n),description(d) {}
-~MutableParamList();
+	MutableParamList(const char* n = 0, const char* d = 0) :objname(n), description(d) {}
+	~MutableParamList();
 
-void operator+=(ParamInterface *p);
-void operator-=(ParamInterface *p);
-void operator+=(MutableParamInterface *p);
-void operator-=(MutableParamInterface *p);
-void insert(int i,ParamInterface *p);
-void insert(int i,MutableParamInterface *p);
-void operator-=(int i);
+	void operator+=(ParamInterface *p);
+	void operator-=(ParamInterface *p);
+	void operator+=(MutableParamInterface *p);
+	void operator-=(MutableParamInterface *p);
+	void insert(int i, ParamInterface *p);
+	void insert(int i, MutableParamInterface *p);
+	void operator-=(int i);
 
-/** remove all sub params */
-void clear();
+	/** remove all sub params */
+	void clear();
 
-const char* getName() {return objname;}
-const char* description;
-const char* getDescription() {return description;}
+	const char* getName() { return objname; }
+	const char* description;
+	const char* getDescription() { return description; }
 
-int getGroupCount();
-int getPropCount();
+	int getGroupCount();
+	int getPropCount();
 
-const char *id(int i);
-const char *name(int i);
-const char *type(int i);
-const char *help(int i);
-int flags(int i);
-int group(int i);
-void call(int i,ExtValue* args,ExtValue *ret);
-const char *grname(int i);
+	const char *id(int i);
+	const char *name(int i);
+	const char *type(int i);
+	const char *help(int i);
+	int flags(int i);
+	int group(int i);
+	void call(int i, ExtValue* args, ExtValue *ret);
+	const char *grname(int i);
 
-int grmember(int gi,int n);
+	int grmember(int gi, int n);
 
-SString getString(int);
-paInt getInt(int);
-double getDouble(int);
-ExtValue getExtValue(int);
-ExtObject getObject(int);
+	SString getString(int);
+	paInt getInt(int);
+	double getDouble(int);
+	ExtValue getExtValue(int);
+	ExtObject getObject(int);
 
-int setInt(int,paInt);
-int setDouble(int,double);
-int setString(int,const SString &);
-int setObject(int,const ExtObject&);
-int setExtValue(int,const ExtValue&);
+	int setInt(int, paInt);
+	int setDouble(int, double);
+	int setString(int, const SString &);
+	int setObject(int, const ExtObject&);
+	int setExtValue(int, const ExtValue&);
 };
 
 #endif
-
-
-
-
-
-
-
-
Index: cpp/frams/param/paramobj.cpp
===================================================================
--- cpp/frams/param/paramobj.cpp	(revision 791)
+++ cpp/frams/param/paramobj.cpp	(revision 792)
@@ -23,9 +23,9 @@
 
 ParamEntry* ParamObject::makeParamTab(ParamInterface *pi, bool stripgroups, bool stripproc,
-				      int firstprop, int maxprops, bool dupentries, int flagsexclude_data, int flagsexclude_tab, bool addnew, const char* rename, bool readonly_into_userreadonly)
-{
-// flagsexclude_data - skip while calculating data offsets
-// flagsexclude_tab - skip while creating paramtab
-// usually _data==_tab, but vmneuron public properties need _data=0 and _tab=PARAM_USERHIDDEN (data object has all fields, paramtab skips private fields)
+	int firstprop, int maxprops, bool dupentries, int flagsexclude_data, int flagsexclude_tab, bool addnew, const char* rename, bool readonly_into_userreadonly)
+{
+	// flagsexclude_data - skip while calculating data offsets
+	// flagsexclude_tab - skip while creating paramtab
+	// usually _data==_tab, but vmneuron public properties need _data=0 and _tab=PARAM_USERHIDDEN (data object has all fields, paramtab skips private fields)
 	ParamEntry *tab, *t;
 	int i, n, offset;
@@ -72,28 +72,28 @@
 	for (i = firstprop; i < pi->getPropCount(); i++)
 	{
-		const char* type=pi->type(i);
+		const char* type = pi->type(i);
 		if ((!stripproc) || (strchr("dfsox", type[0])))
 		{
-			paInt flag=pi->flags(i);
+			paInt flag = pi->flags(i);
 			int tmp_offset;
 			if ((!flagsexclude_data) || (!(flag&flagsexclude_data)))
 			{
-				if (type[0]=='p')
-					tmp_offset=0;
+				if (type[0] == 'p')
+					tmp_offset = 0;
 				else
-					{
+				{
 					tmp_offset = offset;
 					if (type[0] != 'x') tmp_offset += (((char*)&ex.data[0]) - ((char*)&ex));
 					offset += sizeof(ExtValue);
-					}
+				}
 			}
 
 			if ((!flagsexclude_tab) || (!(flag&flagsexclude_tab)))
 			{
-				t->offset=tmp_offset;
+				t->offset = tmp_offset;
 				t->group = (paInt)(stripgroups ? 0 : pi->group(i));
 				t->flags = (paInt)flag;
 				if (readonly_into_userreadonly && (t->flags & PARAM_READONLY))
-					t->flags=(t->flags & ~PARAM_READONLY) | PARAM_USERREADONLY;
+					t->flags = (t->flags & ~PARAM_READONLY) | PARAM_USERREADONLY;
 				t->fun1 = 0;
 				t->fun2 = 0;
@@ -185,14 +185,14 @@
 {
 	if (!tab) return NULL;
-	int n=tab->flags, used_fields=0;
-	for (ParamEntry *t=tab+tab->group; n > 0; n--, t++)
-		if (strchr("dfsox",t->type[0]))
+	int n = tab->flags, used_fields = 0;
+	for (ParamEntry *t = tab + tab->group; n > 0; n--, t++)
+		if (strchr("dfsox", t->type[0]))
 			used_fields++;
 
-	if (used_fields==0) return NULL;
+	if (used_fields == 0) return NULL;
 	ParamObject *obj = new(used_fields)ParamObject(used_fields, tab); // new(n): allocate n fields ; ParamObject(n,...): tell the object it has n fields
 	ExtValue *v = &obj->fields[0];
-	n=tab->flags;
-	for (ParamEntry *t=tab+tab->group; n > 0; n--, t++)
+	n = tab->flags;
+	for (ParamEntry *t = tab + tab->group; n > 0; n--, t++)
 		switch (*t->type)
 	{
@@ -201,23 +201,23 @@
 		case 's': v->setString(SString::empty()); v++; break;
 		case 'o':
-			{
+		{
 			ExtObject new_obj;
 			if (t->flags & PARAM_OBJECTSET)
+			{
+				ParamInterface *cls = ExtValue::findDeserializableClass(t->type + 1);
+				if (cls)
 				{
-				ParamInterface *cls=ExtValue::findDeserializableClass(t->type+1);
-				if (cls)
+					int new_fun = cls->findId("new");
+					if (new_fun >= 0)
 					{
-					int new_fun = cls->findId("new");
-					if (new_fun>=0)
-						{
-						ExtValue dummy,new_value;
+						ExtValue dummy, new_value;
 						cls->call(new_fun, &dummy, &new_value);
-						new_obj=new_value.getObject();
-						}
+						new_obj = new_value.getObject();
 					}
 				}
+			}
 			v->setObject(new_obj);
 			v++;
-			}
+		}
 			break;
 		case 'x': v++; break;
Index: cpp/frams/param/paramobj.h
===================================================================
--- cpp/frams/param/paramobj.h	(revision 791)
+++ cpp/frams/param/paramobj.h	(revision 792)
@@ -53,5 +53,5 @@
 		ParamObject::freeObject(obj2);
 		*/
-	static ParamEntry* makeParamTab(ParamInterface *pi, bool stripgroups = 0, bool stripproc = 0, int firstprop = 0, int maxprops = 9999, bool dupentries = false, int flagsexclude_data = 0, int flagsexclude_tab = 0, bool addnew = false, const char* rename = NULL,bool readonly_into_userreadonly=false);
+	static ParamEntry* makeParamTab(ParamInterface *pi, bool stripgroups = 0, bool stripproc = 0, int firstprop = 0, int maxprops = 9999, bool dupentries = false, int flagsexclude_data = 0, int flagsexclude_tab = 0, bool addnew = false, const char* rename = NULL, bool readonly_into_userreadonly = false);
 
 	/** deallocate paramtab obtained from makeParamTab() */
Index: cpp/frams/param/paramtabobj.cpp
===================================================================
--- cpp/frams/param/paramtabobj.cpp	(revision 791)
+++ cpp/frams/param/paramtabobj.cpp	(revision 792)
@@ -7,32 +7,31 @@
 int ParamTab::measureTab(const ParamEntry *pe)
 {
-int i=0;
-while(pe->id) {i++;pe++;}
-return i;
+	int i = 0;
+	while (pe->id) { i++; pe++; }
+	return i;
 }
 
 void ParamTab::resize(int s)
 {
-if (s==siz) return;
-tab=(ParamEntry*)realloc(tab,sizeof(ParamEntry)*(s+1));
-siz=s;
+	if (s == siz) return;
+	tab = (ParamEntry*)realloc(tab, sizeof(ParamEntry)*(s + 1));
+	siz = s;
 }
 
-int ParamTab::add(const ParamEntry* p,int count)
+int ParamTab::add(const ParamEntry* p, int count)
 {
-if (count<0) count=measureTab(p);
-resize(siz+count);
-memmove(tab+siz-count,p,sizeof(ParamEntry)*count);
-memset(tab+siz,0,sizeof(ParamEntry));
-if (siz>0) tab[0].flags=(paInt)(siz-tab[0].group);
-return siz-1;
+	if (count < 0) count = measureTab(p);
+	resize(siz + count);
+	memmove(tab + siz - count, p, sizeof(ParamEntry)*count);
+	memset(tab + siz, 0, sizeof(ParamEntry));
+	if (siz > 0) tab[0].flags = (paInt)(siz - tab[0].group);
+	return siz - 1;
 }
 
-void ParamTab::remove(int i,int count)
+void ParamTab::remove(int i, int count)
 {
-memmove(tab+i,tab+i+count,sizeof(ParamEntry)*count);
-resize(siz-count);
-memset(tab+siz,0,sizeof(ParamEntry));
-if (siz>0) tab[0].flags=(paInt)(siz-tab[0].group);
+	memmove(tab + i, tab + i + count, sizeof(ParamEntry)*count);
+	resize(siz - count);
+	memset(tab + siz, 0, sizeof(ParamEntry));
+	if (siz > 0) tab[0].flags = (paInt)(siz - tab[0].group);
 }
-
Index: cpp/frams/param/paramtabobj.h
===================================================================
--- cpp/frams/param/paramtabobj.h	(revision 791)
+++ cpp/frams/param/paramtabobj.h	(revision 792)
@@ -10,24 +10,24 @@
 class ParamTab
 {
-ParamEntry *tab;
-int siz;
-void init() {siz=0; tab=(ParamEntry*)calloc(sizeof(ParamEntry),1);}
-void resize(int s);
-int measureTab(const ParamEntry *pe);
+	ParamEntry *tab;
+	int siz;
+	void init() { siz = 0; tab = (ParamEntry*)calloc(sizeof(ParamEntry), 1); }
+	void resize(int s);
+	int measureTab(const ParamEntry *pe);
 
-  public:
-ParamTab(const ParamEntry* pe=0,int maxcount=-1) {init(); if (pe) add(pe,maxcount);}
-ParamTab(const ParamTab& src) {init(); add(src);}
-~ParamTab() {clear();}
+public:
+	ParamTab(const ParamEntry* pe = 0, int maxcount = -1) { init(); if (pe) add(pe, maxcount); }
+	ParamTab(const ParamTab& src) { init(); add(src); }
+	~ParamTab() { clear(); }
 
-int size() const {return siz;}
-ParamEntry* getParamTab() const {return tab;}
-ParamEntry* operator()() const {return tab;}
+	int size() const { return siz; }
+	ParamEntry* getParamTab() const { return tab; }
+	ParamEntry* operator()() const { return tab; }
 
-/** @return position of the last added entry */
-int add(const ParamEntry*,int count=1);
-int add(const ParamTab& src) {return add(src.getParamTab(), src.size());}
-void remove(int i,int count=1);
-void clear() {resize(-1);}
+	/** @return position of the last added entry */
+	int add(const ParamEntry*, int count = 1);
+	int add(const ParamTab& src) { return add(src.getParamTab(), src.size()); }
+	void remove(int i, int count = 1);
+	void clear() { resize(-1); }
 };
 
