Ignore:
Timestamp:
05/29/18 16:32:45 (6 years ago)
Author:
Maciej Komosinski
Message:

Code formatting

File:
1 edited

Legend:

Unmodified
Added
Removed

  • cpp/frams/param/mutableparam.cpp

    r535 r792  
    77
    88#define FIELDSTRUCT MutableParam
    9 ParamEntry MutableParam::pe_tab[]=
    10 {
    11 {"clear",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove all properties","p",PROCEDURE(p_clear),},
    12 {"add",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"add property (id,type,name,help)","p",PROCEDURE(p_addprop),},
    13 {"remove",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove property (index)","p",PROCEDURE(p_remprop),},
    14 {"addGroup",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"add group (name)","p",PROCEDURE(p_addgroup),},
    15 {"removeGroup",0,PARAM_DONTSAVE | PARAM_USERHIDDEN,"remove group (index)","p",PROCEDURE(p_remgroup),},
    16 {"changedProperty",0,PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY,"last changed property #","d",FIELD(changed),},
    17 {"changedPropertyId",0,PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY,"last changed property id","s",GETONLY(changedname),},
     9ParamEntry MutableParam::pe_tab[] =
     10{
     11        { "clear", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove all properties", "p", PROCEDURE(p_clear), },
     12        { "add", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "add property (id,type,name,help)", "p", PROCEDURE(p_addprop), },
     13        { "remove", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove property (index)", "p", PROCEDURE(p_remprop), },
     14        { "addGroup", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "add group (name)", "p", PROCEDURE(p_addgroup), },
     15        { "removeGroup", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "remove group (index)", "p", PROCEDURE(p_remgroup), },
     16        { "changedProperty", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY, "last changed property #", "d", FIELD(changed), },
     17        { "changedPropertyId", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN | PARAM_READONLY, "last changed property id", "s", GETONLY(changedname), },
    1818};
    1919#undef FIELDSTRUCT
    2020
    21 MutableParam::MutableParam(const char*n,const char*g,int gr0)
    22         :SimpleAbstractParam(this,n),persistgroup0(gr0),grprefix(g)
    23 {
    24 if (persistgroup0)
    25         addGroup(grprefix,1);
    26 }
    27 
    28 int MutableParam::findGroup(const SString name,int ignoreprefix)
    29 {
    30 int skipprefix=grprefix.len()?grprefix.len()+2:0;
    31 for (int i=0;i<groups.size();i++)
    32         {
    33         if (ignoreprefix)
     21MutableParam::MutableParam(const char*n, const char*g, int gr0)
     22        :SimpleAbstractParam(this, n), persistgroup0(gr0), grprefix(g)
     23{
     24        if (persistgroup0)
     25                addGroup(grprefix, 1);
     26}
     27
     28int MutableParam::findGroup(const SString name, int ignoreprefix)
     29{
     30        int skipprefix = grprefix.len() ? grprefix.len() + 2 : 0;
     31        for (int i = 0; i < groups.size(); i++)
     32        {
     33                if (ignoreprefix)
    3434                {
    35       const char *noprefix=groupname(i).c_str();
    36       if ((int)strlen(noprefix) < skipprefix) continue;
    37                 noprefix+=skipprefix;
    38                 if (!strcmp(noprefix,name.c_str())) return i;
     35                        const char *noprefix = groupname(i).c_str();
     36                        if ((int)strlen(noprefix) < skipprefix) continue;
     37                        noprefix += skipprefix;
     38                        if (!strcmp(noprefix, name.c_str())) return i;
    3939                }
    4040                else
    41                         if (groupname(i)==name) return i;
    42         }
    43 return -1;
    44 }
    45 
    46 int MutableParam::addGroup(const SString& gname,int noprefix)
    47 {
    48 SString tmp;
    49 if (noprefix)
    50         tmp=gname;
    51 else
    52         {
    53         tmp=grprefix;
    54         if (tmp.len()) tmp+=": ";
    55         tmp+=gname;
    56         }
    57 groups+=new SString(tmp);
    58 int position=groups.size()-1;
    59 ongroupadd.action(position);
    60 return position;
     41                        if (groupname(i) == name) return i;
     42        }
     43        return -1;
     44}
     45
     46int MutableParam::addGroup(const SString& gname, int noprefix)
     47{
     48        SString tmp;
     49        if (noprefix)
     50                tmp = gname;
     51        else
     52        {
     53                tmp = grprefix;
     54                if (tmp.len()) tmp += ": ";
     55                tmp += gname;
     56        }
     57        groups += new SString(tmp);
     58        int position = groups.size() - 1;
     59        ongroupadd.action(position);
     60        return position;
    6161}
    6262
    6363void MutableParam::removeGroup(int g)
    6464{
    65 if ((g<0)||(g>=MutableParam::getGroupCount())) return;
    66 ParamEntry *e;
    67 for (int i=MutableParam::getPropCount()-1;i>=staticprops;i--)
    68         {
    69         e=entry(i);
    70         if (g==e->group)
    71                 removeProperty(i);
    72         }
    73 SString *s=(SString *)groups(g);
    74 if (s) delete s;
    75 groups-=g;
    76 ongroupdelete.action(g);
    77 }
    78 
    79 int MutableParam::grmember(int g,int a)
    80 {
    81 if (g==0)
    82         {
    83         if (getGroupCount()<2)
    84                 return (a<getPropCount())?a:-9999;
    85         if (a<staticprops) return a;
    86         a-=staticprops;
    87         }
    88 ParamEntry *e;
    89 for (int i=staticprops;e=entry(i);i++)
    90         if (g==e->group)
    91                 if (!a--) return i;
    92 return -9999;
    93 }
    94 
    95 int MutableParam::addProperty(ParamEntry *pe,int position)
    96 {
    97 DB(printf("MutableParam::add(%s)\n",pe->id));
    98 if (position<0)
    99         position=entries.size()+staticprops;
    100 entries.insert(position-staticprops,pe);
    101 
    102 if (pe->offset)
    103         pe->flags &= ~MUTPARAM_ALLOCDATA;
    104 else
    105         {
    106         pe->flags |= MUTPARAM_ALLOCDATA;
    107         void *d=0;
    108         switch(pe->type[0])
     65        if ((g < 0) || (g >= MutableParam::getGroupCount())) return;
     66        ParamEntry *e;
     67        for (int i = MutableParam::getPropCount() - 1; i >= staticprops; i--)
     68        {
     69                e = entry(i);
     70                if (g == e->group)
     71                        removeProperty(i);
     72        }
     73        SString *s = (SString *)groups(g);
     74        if (s) delete s;
     75        groups -= g;
     76        ongroupdelete.action(g);
     77}
     78
     79int MutableParam::grmember(int g, int a)
     80{
     81        if (g == 0)
     82        {
     83                if (getGroupCount() < 2)
     84                        return (a < getPropCount()) ? a : -9999;
     85                if (a < staticprops) return a;
     86                a -= staticprops;
     87        }
     88        ParamEntry *e;
     89        for (int i = staticprops; e = entry(i); i++)
     90                if (g == e->group)
     91                        if (!a--) return i;
     92        return -9999;
     93}
     94
     95int MutableParam::addProperty(ParamEntry *pe, int position)
     96{
     97        DB(printf("MutableParam::add(%s)\n", pe->id));
     98        if (position < 0)
     99                position = entries.size() + staticprops;
     100        entries.insert(position - staticprops, pe);
     101
     102        if (pe->offset)
     103                pe->flags &= ~MUTPARAM_ALLOCDATA;
     104        else
     105        {
     106                pe->flags |= MUTPARAM_ALLOCDATA;
     107                void *d = 0;
     108                switch (pe->type[0])
    109109                {
    110                 case 'd': d=new paInt(); *((paInt*)d)=0; break;
    111                 case 'f': d=new double(); *((double*)d)=0; break;
    112                 case 's': d=new SString(); break;
    113                 case 'x': d=new ExtValue(); break;
    114                 case 'o': d=new ExtObject(); break;
     110                case 'd': d = new paInt(); *((paInt*)d) = 0; break;
     111                case 'f': d = new double(); *((double*)d) = 0; break;
     112                case 's': d = new SString(); break;
     113                case 'x': d = new ExtValue(); break;
     114                case 'o': d = new ExtObject(); break;
    115115                }
    116         pe->offset=(intptr_t)d;
    117         }
    118 onadd.action(position);
    119 return position;
     116                pe->offset = (intptr_t)d;
     117        }
     118        onadd.action(position);
     119        return position;
    120120}
    121121
    122122ParamEntry * MutableParam::removeProperty(ParamEntry *pe)
    123123{
    124    int index=entries.find(pe);
    125    if (index>=0) return removeProperty(index); else return pe;
     124        int index = entries.find(pe);
     125        if (index >= 0) return removeProperty(index); else return pe;
    126126}
    127127
    128128ParamEntry * MutableParam::removeProperty(int i)
    129129{
    130 ParamEntry *pe=(ParamEntry *)entries(i-staticprops);
    131 DB(printf("MutableParam::remove(%d)\n",i));
    132 void *d=(void*)pe->offset;
    133 if (d && (pe->flags & MUTPARAM_ALLOCDATA))
    134         switch(pe->type[0])
    135                 {
     130        ParamEntry *pe = (ParamEntry *)entries(i - staticprops);
     131        DB(printf("MutableParam::remove(%d)\n", i));
     132        void *d = (void*)pe->offset;
     133        if (d && (pe->flags & MUTPARAM_ALLOCDATA))
     134                switch (pe->type[0])
     135        {
    136136                case 'd': delete (paInt*)d; break;
    137137                case 'f': delete (double*)d; break;
    … …  
    139139                case 'x': delete (ExtValue*)d; break;
    140140                case 'o': delete (ExtObject*)d; break;
     141        }
     142        entries -= i - staticprops;
     143        if (pe->flags & MUTPARAM_ALLOCENTRY)
     144        {
     145                if (pe->name) free((void*)pe->name);
     146                if (pe->id) free((void*)pe->id);
     147                if (pe->help) free((void*)pe->help);
     148                if (pe->type) free((void*)pe->type);
     149                delete pe;
     150        }
     151        ondelete.action(i);
     152        return pe;
     153}
     154
     155void MutableParam::clear(int everything)
     156{
     157        DB(printf("MutableParam::clear\n"));
     158        for (int i = entries.size() - 1; i >= 0; i--)
     159                removeProperty(i + staticprops);
     160        int lastgroup = (everything || (persistgroup0 == 0)) ? 0 : 1;
     161        for (int i = groups.size() - 1; i >= lastgroup; i--)
     162                removeGroup(i);
     163}
     164
     165void MutableParam::p_clear(ExtValue *args, ExtValue *ret)
     166{
     167        clear();
     168}
     169
     170int MutableParam::addProperty(void* data, const char* id, const char* type, const char* name, const char* help, int flags, int group, int position)
     171{
     172        if ((!id) && (!type)) return -1;
     173        if (!isValidTypeDescription(type)) return -1;
     174        ParamEntry *pe = new ParamEntry();
     175        pe->fun1 = 0; pe->fun2 = 0;
     176        pe->group = (paInt)group;
     177        pe->flags = (paInt)(flags | MUTPARAM_ALLOCENTRY);
     178        pe->offset = (intptr_t)data;
     179        pe->id = strdup(id);
     180        pe->type = strdup(type);
     181        pe->name = name ? strdup(name) : 0;
     182        pe->help = help ? strdup(help) : 0;
     183        return addProperty(pe, position);
     184}
     185
     186void MutableParam::p_addprop(ExtValue *args, ExtValue *ret)
     187{
     188        int i = addProperty(0, args[2].getString().c_str(), args[1].getString().c_str(), args[0].getString().c_str());
     189        ret->setInt(i);
     190}
     191
     192void MutableParam::p_remprop(ExtValue *args, ExtValue *ret)
     193{
     194        removeProperty(args[0].getInt());
     195}
     196
     197void MutableParam::p_addgroup(ExtValue *args, ExtValue *ret)
     198{
     199        int i = addGroup(args[0].getString());
     200        ret->setInt(i);
     201}
     202
     203void MutableParam::p_remgroup(ExtValue *args, ExtValue *ret)
     204{
     205        removeGroup(args[0].getInt());
     206}
     207
     208void MutableParam::notify(int id)
     209{
     210        changed = id;
     211        onactivate.action(id);
     212}
     213
     214int MutableParam::setInt(int i, paInt v)
     215{
     216        int ret = SimpleAbstractParam::setInt(i, v);
     217        if (ret & PSET_CHANGED) notify(i);
     218        return ret;
     219}
     220
     221int MutableParam::setDouble(int i, double v)
     222{
     223        int ret = SimpleAbstractParam::setDouble(i, v);
     224        if (ret & PSET_CHANGED) notify(i);
     225        return ret;
     226}
     227
     228int MutableParam::setString(int i, const SString &v)
     229{
     230        int ret = SimpleAbstractParam::setString(i, v);
     231        if (ret & PSET_CHANGED) notify(i);
     232        return ret;
     233}
     234
     235int MutableParam::setObject(int i, const ExtObject &v)
     236{
     237        int ret = SimpleAbstractParam::setObject(i, v);
     238        if (ret & PSET_CHANGED) notify(i);
     239        return ret;
     240}
     241
     242int MutableParam::setExtValue(int i, const ExtValue &v)
     243{
     244        int ret = SimpleAbstractParam::setExtValue(i, v);
     245        if (ret & PSET_CHANGED) notify(i);
     246        return ret;
     247}
     248
     249void MutableParam::call(int i, ExtValue* args, ExtValue *ret)
     250{
     251        if (i < staticprops) return SimpleAbstractParam::call(i, args, ret);
     252        notify(i);
     253}
     254
     255///////////////////
     256
     257void ParamSaver::clear()
     258{
     259        for (int i = 0; i < store.size(); i += 2)
     260        {
     261                SString *n = (SString*)store(i);
     262                ExtValue *v = (ExtValue*)store(i + 1);
     263                delete n;
     264                delete v;
     265        }
     266        store.clear();
     267}
     268
     269void ParamSaver::loadFrom(ParamInterface& p)
     270{
     271        int N = p.getPropCount();
     272        for (int i = 0; i < N; i++)
     273        {
     274                if (shouldLoad(p, i))
     275                {
     276                        ExtValue v;
     277                        p.get(i, v);
     278                        store += new SString(p.id(i));
     279                        store += new ExtValue(v);
    141280                }
    142 entries-=i-staticprops;
    143 if (pe->flags & MUTPARAM_ALLOCENTRY)
    144         {
    145         if (pe->name) free((void*)pe->name);
    146         if (pe->id) free((void*)pe->id);
    147         if (pe->help) free((void*)pe->help);
    148         if (pe->type) free((void*)pe->type);
    149         delete pe;
    150         }
    151 ondelete.action(i);
    152 return pe;
    153 }
    154 
    155 void MutableParam::clear(int everything)
    156 {
    157 DB(printf("MutableParam::clear\n"));
    158 for (int i=entries.size()-1;i>=0;i--)
    159         removeProperty(i+staticprops);
    160 int lastgroup=(everything || (persistgroup0==0))?0:1;
    161 for (int i=groups.size()-1;i>=lastgroup;i--)
    162         removeGroup(i);
    163 }
    164 
    165 void MutableParam::p_clear(ExtValue *args,ExtValue *ret)
    166 { clear(); }
    167 
    168 int MutableParam::addProperty(void* data,const char* id,const char* type,const char* name,const char* help,int flags,int group,int position)
    169 {
    170 if ((!id)&&(!type)) return -1;
    171 if (!isValidTypeDescription(type)) return -1;
    172 ParamEntry *pe=new ParamEntry();
    173 pe->fun1=0; pe->fun2=0;
    174 pe->group=(paInt)group;
    175 pe->flags=(paInt)(flags | MUTPARAM_ALLOCENTRY);
    176 pe->offset=(intptr_t)data;
    177 pe->id=strdup(id);
    178 pe->type=strdup(type);
    179 pe->name=name?strdup(name):0;
    180 pe->help=help?strdup(help):0;
    181 return addProperty(pe,position);
    182 }
    183 
    184 void MutableParam::p_addprop(ExtValue *args,ExtValue *ret)
    185 {
    186 int i=addProperty(0,args[2].getString().c_str(),args[1].getString().c_str(),args[0].getString().c_str());
    187 ret->setInt(i);
    188 }
    189 
    190 void MutableParam::p_remprop(ExtValue *args,ExtValue *ret)
    191 {
    192 removeProperty(args[0].getInt());
    193 }
    194 
    195 void MutableParam::p_addgroup(ExtValue *args,ExtValue *ret)
    196 {
    197 int i=addGroup(args[0].getString());
    198 ret->setInt(i);
    199 }
    200 
    201 void MutableParam::p_remgroup(ExtValue *args,ExtValue *ret)
    202 {
    203 removeGroup(args[0].getInt());
    204 }
    205 
    206 void MutableParam::notify(int id)
    207 {
    208 changed=id;
    209 onactivate.action(id);
    210 }
    211 
    212 int MutableParam::setInt(int i,paInt v)
    213 {
    214 int ret=SimpleAbstractParam::setInt(i,v);
    215 if (ret & PSET_CHANGED) notify(i);
    216 return ret;
    217 }
    218 
    219 int MutableParam::setDouble(int i,double v)
    220 {
    221 int ret=SimpleAbstractParam::setDouble(i,v);
    222 if (ret & PSET_CHANGED) notify(i);
    223 return ret;
    224 }
    225 
    226 int MutableParam::setString(int i,const SString &v)
    227 {
    228 int ret=SimpleAbstractParam::setString(i,v);
    229 if (ret & PSET_CHANGED) notify(i);
    230 return ret;
    231 }
    232 
    233 int MutableParam::setObject(int i,const ExtObject &v)
    234 {
    235 int ret=SimpleAbstractParam::setObject(i,v);
    236 if (ret & PSET_CHANGED) notify(i);
    237 return ret;
    238 }
    239 
    240 int MutableParam::setExtValue(int i,const ExtValue &v)
    241 {
    242 int ret=SimpleAbstractParam::setExtValue(i,v);
    243 if (ret & PSET_CHANGED) notify(i);
    244 return ret;
    245 }
    246 
    247 void MutableParam::call(int i,ExtValue* args,ExtValue *ret)
    248 {
    249 if (i<staticprops) return SimpleAbstractParam::call(i,args,ret);
    250 notify(i);
    251 }
    252 
    253 ///////////////////
    254 
    255 void ParamSaver::clear()
    256 {
    257 for(int i=0;i<store.size();i+=2)
    258         {
    259         SString *n=(SString*)store(i);
    260         ExtValue *v=(ExtValue*)store(i+1);
    261         delete n;
    262         delete v;
    263         }       
    264 store.clear();
    265 }
    266 
    267 void ParamSaver::loadFrom(ParamInterface& p)
    268 {
    269 int N=p.getPropCount();
    270 for(int i=0;i<N;i++)
    271         {
    272         if (shouldLoad(p,i))
    273                 {
    274                 ExtValue v;
    275                 p.get(i,v);
    276                 store+=new SString(p.id(i));
    277                 store+=new ExtValue(v);
    278                 }
    279281        }
    280282}
    … …  
    282284void ParamSaver::saveTo(MutableParam& p)
    283285{
    284 for(int i=0;i<store.size();i+=2)
    285         {
    286         SString *n=(SString*)store(i);
    287         int prop=p.findId(n->c_str());
    288         if (prop<0)
    289                 prop=p.addProperty(0,n->c_str(),"x",0,0,0,0,-1);
    290         p.setExtValue(prop,*(ExtValue*)store(i+1));
    291         }
    292 }
     286        for (int i = 0; i < store.size(); i += 2)
     287        {
     288                SString *n = (SString*)store(i);
     289                int prop = p.findId(n->c_str());
     290                if (prop < 0)
     291                        prop = p.addProperty(0, n->c_str(), "x", 0, 0, 0, 0, -1);
     292                p.setExtValue(prop, *(ExtValue*)store(i + 1));
     293        }
     294}
Note: See TracChangeset for help on using the changeset viewer.