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

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#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, 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);
}

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

#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, 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 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);
}