source: cpp/frams/param/mutparamlist.cpp @ 146

// This file is a part of the Framsticks GDK.
// Copyright (C) 2002-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#include "mutparamlist.h"
#include <frams/util/extvalue.h>

struct ParamInfo
{
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));
        }
}

int MutableParamList::findPI(ParamInfo *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;
}

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

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

MutableParamList::~MutableParamList()
{
for (int i=list.size()-1;i>=0;i--)
        removePI(i);
}

void MutableParamList::onPropAdd(void* data,long 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,long 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,long i)
{
ParamInfo *pi=(ParamInfo*)data;
onchange.action(pi->firstprop+i);
}

void MutableParamList::onPropActivate(void* data,long i)
{
ParamInfo *pi=(ParamInfo*)data;
onactivate.action(pi->firstprop+i);
}

void MutableParamList::onGroupAdd(void* data,long 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,long 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,long 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);
}

void MutableParamList::operator-=(int i)
{
removePI(i);
}

int MutableParamList::getGroupCount()
{
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))
                {
                *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))
                {
                *sub_p=pi->pi;
                *sub_i=i;
                return 1;
                }
        i-=n;
        }
return 0;
}

#define FUN(_type_,_name_,_ret_) \
_type_ MutableParamList:: _name_ (int i) \
{ \
int j; ParamInterface *pi; \
if (!getSubParam(i,&pi,&j)) return _ret_; \
return pi-> _name_ (j); \
}

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(long,getInt,0)
FUN(double,getDouble,0)
FUN(ExtValue,getExtValue,ExtValue((long)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;
}

#define FUN2(_type_,_name_,_argt_) \
_type_ MutableParamList:: _name_ (int i,_argt_ v) \
{ \
int j; ParamInterface *pi; \
if (!getSubParam(i,&pi,&j)) return 0; \
return pi-> _name_ (j,v); \
}

FUN2(int,setInt,long)
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 prop=pi->pi->grmember(gi,i);
                if (prop>=pi->propcount) return -9999;
                return count+prop;
                }
        count+=pi->propcount;
        gi-=n;
        }
return -9999;
}

void MutableParamList::clear()
{
for (int i=list.size()-1;i>=0;i--)
        operator-=(i);
}