source/blender/makesrna/intern/rna_define.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * Contributor(s): Blender Foundation (2008).
  21  *
  22  * ***** END GPL LICENSE BLOCK *****
  23  */
  24
  25 #include <float.h>
  26 #include <limits.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31
  32 #include "MEM_guardedalloc.h"
  33
  34 #include "DNA_genfile.h"
  35 #include "DNA_sdna_types.h"
  36
  37 #include "RNA_access.h"
  38 #include "RNA_define.h"
  39 #include "RNA_types.h"
  40
  41 #include "BLI_ghash.h"
  42
  43 #include "rna_internal.h"
  44
  45 /* Global used during defining */
  46
  47 BlenderDefRNA DefRNA = {0, {0, 0}, {0, 0}, 0, 0, 0};
  48
  49 /* Duplicated code since we can't link in blenkernel or blenlib */
  50
  51 #ifndef MIN2
  52 #define MIN2(x,y) ((x)<(y)? (x): (y))
  53 #define MAX2(x,y) ((x)>(y)? (x): (y))
  54 #endif
  55
  56 void rna_addtail(ListBase *listbase, void *vlink)
  57 {
  58         Link *link= vlink;
  59
  60         link->next = NULL;
  61         link->prev = listbase->last;
  62
  63         if (listbase->last) ((Link *)listbase->last)->next = link;
  64         if (listbase->first == 0) listbase->first = link;
  65         listbase->last = link;
  66 }
  67
  68 void rna_remlink(ListBase *listbase, void *vlink)
  69 {
  70         Link *link= vlink;
  71
  72         if (link->next) link->next->prev = link->prev;
  73         if (link->prev) link->prev->next = link->next;
  74
  75         if (listbase->last == link) listbase->last = link->prev;
  76         if (listbase->first == link) listbase->first = link->next;
  77 }
  78
  79 void rna_freelinkN(ListBase *listbase, void *vlink)
  80 {
  81         rna_remlink(listbase, vlink);
  82         MEM_freeN(vlink);
  83 }
  84
  85 void rna_freelistN(ListBase *listbase)
  86 {
  87         Link *link, *next;
  88
  89         for(link=listbase->first; link; link=next) {
  90                 next= link->next;
  91                 MEM_freeN(link);
  92         }
  93
  94         listbase->first= listbase->last= NULL;
  95 }
  96
  97 StructDefRNA *rna_find_struct_def(StructRNA *srna)
  98 {
  99         StructDefRNA *dsrna;
 100
 101         if(!DefRNA.preprocess) {
 102                 /* we should never get here */
 103                 fprintf(stderr, "rna_find_struct_def: only at preprocess time.\n");
 104                 return NULL;
 105         }
 106
 107         dsrna= DefRNA.structs.last;
 108         for (; dsrna; dsrna= dsrna->cont.prev)
 109                 if (dsrna->srna==srna)
 110                         return dsrna;
 111
 112         return NULL;
 113 }
 114
 115 PropertyDefRNA *rna_find_struct_property_def(PropertyRNA *prop)
 116 {
 117         StructDefRNA *dsrna;
 118         PropertyDefRNA *dprop;
 119
 120         if(!DefRNA.preprocess) {
 121                 /* we should never get here */
 122                 fprintf(stderr, "rna_find_property_def: only at preprocess time.\n");
 123                 return NULL;
 124         }
 125
 126         dsrna= rna_find_struct_def(DefRNA.laststruct);
 127         dprop= dsrna->cont.properties.last;
 128         for (; dprop; dprop= dprop->prev)
 129                 if (dprop->prop==prop)
 130                         return dprop;
 131
 132         dsrna= DefRNA.structs.last;
 133         for (; dsrna; dsrna= dsrna->cont.prev) {
 134                 dprop= dsrna->cont.properties.last;
 135                 for (; dprop; dprop= dprop->prev)
 136                         if (dprop->prop==prop)
 137                                 return dprop;
 138         }
 139
 140         return NULL;
 141 }
 142
 143 PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
 144 {
 145         PropertyDefRNA *dprop;
 146
 147         if(!DefRNA.preprocess) {
 148                 /* we should never get here */
 149                 fprintf(stderr, "rna_find_property_def: only at preprocess time.\n");
 150                 return NULL;
 151         }
 152
 153         dprop= rna_find_struct_property_def(prop);
 154         if (dprop)
 155                 return dprop;
 156
 157         dprop= rna_find_parameter_def(prop);
 158         if (dprop)
 159                 return dprop;
 160
 161         return NULL;
 162 }
 163
 164 FunctionDefRNA *rna_find_function_def(FunctionRNA *func)
 165 {
 166         StructDefRNA *dsrna;
 167         FunctionDefRNA *dfunc;
 168
 169         if(!DefRNA.preprocess) {
 170                 /* we should never get here */
 171                 fprintf(stderr, "rna_find_function_def: only at preprocess time.\n");
 172                 return NULL;
 173         }
 174
 175         dsrna= rna_find_struct_def(DefRNA.laststruct);
 176         dfunc= dsrna->functions.last;
 177         for (; dfunc; dfunc= dfunc->cont.prev)
 178                 if (dfunc->func==func)
 179                         return dfunc;
 180
 181         dsrna= DefRNA.structs.last;
 182         for (; dsrna; dsrna= dsrna->cont.prev) {
 183                 dfunc= dsrna->functions.last;
 184                 for (; dfunc; dfunc= dfunc->cont.prev)
 185                         if (dfunc->func==func)
 186                                 return dfunc;
 187         }
 188
 189         return NULL;
 190 }
 191
 192 PropertyDefRNA *rna_find_parameter_def(PropertyRNA *parm)
 193 {
 194         StructDefRNA *dsrna;
 195         FunctionDefRNA *dfunc;
 196         PropertyDefRNA *dparm;
 197
 198         if(!DefRNA.preprocess) {
 199                 /* we should never get here */
 200                 fprintf(stderr, "rna_find_parameter_def: only at preprocess time.\n");
 201                 return NULL;
 202         }
 203
 204         dsrna= rna_find_struct_def(DefRNA.laststruct);
 205         dfunc= dsrna->functions.last;
 206         for (; dfunc; dfunc= dfunc->cont.prev) {
 207                 dparm= dfunc->cont.properties.last;
 208                 for (; dparm; dparm= dparm->prev)
 209                         if (dparm->prop==parm)
 210                                 return dparm;
 211         }
 212
 213         dsrna= DefRNA.structs.last;
 214         for (; dsrna; dsrna= dsrna->cont.prev) {
 215                 dfunc= dsrna->functions.last;
 216                 for (; dfunc; dfunc= dfunc->cont.prev) {
 217                         dparm= dfunc->cont.properties.last;
 218                         for (; dparm; dparm= dparm->prev)
 219                                 if (dparm->prop==parm)
 220                                         return dparm;
 221                 }
 222         }
 223
 224         return NULL;
 225 }
 226
 227 ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
 228 {
 229         StructDefRNA *ds;
 230         FunctionDefRNA *dfunc;
 231
 232         if(!DefRNA.preprocess) {
 233                 /* we should never get here */
 234                 fprintf(stderr, "rna_find_container_def: only at preprocess time.\n");
 235                 return NULL;
 236         }
 237
 238         ds= rna_find_struct_def((StructRNA*)cont);
 239         if(ds)
 240                 return &ds->cont;
 241
 242         dfunc= rna_find_function_def((FunctionRNA*)cont);
 243         if(dfunc)
 244                 return &dfunc->cont;
 245
 246         return NULL;
 247 }
 248
 249 /* DNA utility function for looking up members */
 250
 251 typedef struct DNAStructMember {
 252         char *type;
 253         char *name;
 254         int arraylength;
 255         int pointerlevel;
 256 } DNAStructMember;
 257
 258 static int rna_member_cmp(const char *name, const char *oname)
 259 {
 260         int a=0;
 261
 262         /* compare without pointer or array part */
 263         while(name[0]=='*')
 264                 name++;
 265         while(oname[0]=='*')
 266                 oname++;
 267
 268         while(1) {
 269                 if(name[a]=='[' && oname[a]==0) return 1;
 270                 if(name[a]=='[' && oname[a]=='[') return 1;
 271                 if(name[a]==0) break;
 272                 if(name[a] != oname[a]) return 0;
 273                 a++;
 274         }
 275         if(name[a]==0 && oname[a] == '.') return 2;
 276         if(name[a]==0 && oname[a] == '-' && oname[a+1] == '>') return 3;
 277
 278         return (name[a] == oname[a]);
 279 }
 280
 281 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
 282 {
 283         char *dnaname;
 284         short *sp;
 285         int a, b, structnr, totmember, cmp;
 286
 287         structnr= DNA_struct_find_nr(sdna, structname);
 288         if(structnr == -1)
 289                 return 0;
 290
 291         sp= sdna->structs[structnr];
 292         totmember= sp[1];
 293         sp+= 2;
 294
 295         for(a=0; a<totmember; a++, sp+=2) {
 296                 dnaname= sdna->names[sp[1]];
 297
 298                 cmp= rna_member_cmp(dnaname, membername);
 299
 300                 if(cmp == 1) {
 301                         smember->type= sdna->types[sp[0]];
 302                         smember->name= dnaname;
 303
 304                         if(strstr(membername, "["))
 305                                 smember->arraylength= 0;
 306                         else
 307                                 smember->arraylength= DNA_elem_array_size(smember->name, strlen(smember->name));
 308
 309                         smember->pointerlevel= 0;
 310                         for(b=0; dnaname[b] == '*'; b++)
 311                                 smember->pointerlevel++;
 312
 313                         return 1;
 314                 }
 315                 else if(cmp == 2) {
 316                         smember->type= "";
 317                         smember->name= dnaname;
 318                         smember->pointerlevel= 0;
 319                         smember->arraylength= 0;
 320
 321                         membername= strstr(membername, ".") + strlen(".");
 322                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 323
 324                         return 1;
 325                 }
 326                 else if(cmp == 3) {
 327                         smember->type= "";
 328                         smember->name= dnaname;
 329                         smember->pointerlevel= 0;
 330                         smember->arraylength= 0;
 331
 332                         membername= strstr(membername, "->") + strlen("->");
 333                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 334
 335                         return 1;
 336                 }
 337         }
 338
 339         return 0;
 340 }
 341
 342 static int rna_validate_identifier(const char *identifier, char *error, int property)
 343 {
 344         int a=0;
 345
 346         /*  list from http://docs.python.org/reference/lexical_analysis.html#id5 */
 347         static char *kwlist[] = {
 348                 "and", "as", "assert", "break",
 349                 "class", "continue", "def", "del",
 350                 "elif", "else", "except", "exec",
 351                 "finally", "for", "from", "global",
 352                 "if", "import", "in", "is",
 353                 "lambda", "not", "or", "pass",
 354                 "print", "raise", "return", "try",
 355                 "while", "with", "yield", NULL
 356         };
 357
 358
 359         if (!isalpha(identifier[0])) {
 360                 strcpy(error, "first character failed isalpha() check");
 361                 return 0;
 362         }
 363
 364         for(a=0; identifier[a]; a++) {
 365                 if(DefRNA.preprocess && property) {
 366                         if(isalpha(identifier[a]) && isupper(identifier[a])) {
 367                                 strcpy(error, "property names must contain lower case characters only");
 368                                 return 0;
 369                         }
 370                 }
 371
 372                 if (identifier[a]=='_') {
 373                         continue;
 374                 }
 375
 376                 if (identifier[a]==' ') {
 377                         strcpy(error, "spaces are not ok in identifier names");
 378                         return 0;
 379                 }
 380
 381                 if (isalnum(identifier[a])==0) {
 382                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
 383                         return 0;
 384                 }
 385         }
 386
 387         for(a=0; kwlist[a]; a++) {
 388                 if (strcmp(identifier, kwlist[a]) == 0) {
 389                         strcpy(error, "this keyword is reserved by python");
 390                         return 0;
 391                 }
 392         }
 393
 394         return 1;
 395 }
 396
 397 /* Blender Data Definition */
 398
 399 BlenderRNA *RNA_create()
 400 {
 401         BlenderRNA *brna;
 402
 403         brna= MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
 404
 405         DefRNA.sdna= DNA_sdna_from_data(DNAstr,  DNAlen, 0);
 406         DefRNA.structs.first= DefRNA.structs.last= NULL;
 407         DefRNA.error= 0;
 408         DefRNA.preprocess= 1;
 409
 410         return brna;
 411 }
 412
 413 void RNA_define_free(BlenderRNA *brna)
 414 {
 415         StructDefRNA *ds;
 416         FunctionDefRNA *dfunc;
 417         AllocDefRNA *alloc;
 418
 419         for(alloc=DefRNA.allocs.first; alloc; alloc=alloc->next)
 420                 MEM_freeN(alloc->mem);
 421         rna_freelistN(&DefRNA.allocs);
 422
 423         for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
 424                 for (dfunc= ds->functions.first; dfunc; dfunc= dfunc->cont.next)
 425                         rna_freelistN(&dfunc->cont.properties);
 426
 427                 rna_freelistN(&ds->cont.properties);
 428                 rna_freelistN(&ds->functions);
 429         }
 430
 431         rna_freelistN(&DefRNA.structs);
 432
 433         if(DefRNA.sdna) {
 434                 DNA_sdna_free(DefRNA.sdna);
 435                 DefRNA.sdna= NULL;
 436         }
 437
 438         DefRNA.error= 0;
 439 }
 440
 441 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
 442 {
 443         FunctionRNA *func, *nextfunc;
 444         PropertyRNA *prop, *nextprop;
 445         PropertyRNA *parm, *nextparm;
 446
 447         for(prop=srna->cont.properties.first; prop; prop=nextprop) {
 448                 nextprop= prop->next;
 449
 450                 if(prop->flag & PROP_RUNTIME)
 451                         rna_freelinkN(&srna->cont.properties, prop);
 452         }
 453
 454         for(func=srna->functions.first; func; func=nextfunc) {
 455                 nextfunc= func->cont.next;
 456
 457                 for(parm=func->cont.properties.first; parm; parm=nextparm) {
 458                         nextparm= parm->next;
 459
 460                         if(parm->flag & PROP_RUNTIME)
 461                                 rna_freelinkN(&func->cont.properties, parm);
 462                 }
 463
 464                 if(func->flag & FUNC_RUNTIME) {
 465                         rna_freelinkN(&srna->functions, func);
 466                 }
 467         }
 468
 469         if(srna->flag & STRUCT_RUNTIME)
 470                 rna_freelinkN(&brna->structs, srna);
 471 }
 472
 473 void RNA_free(BlenderRNA *brna)
 474 {
 475         StructRNA *srna, *nextsrna;
 476         FunctionRNA *func;
 477
 478         if(DefRNA.preprocess) {
 479                 RNA_define_free(brna);
 480
 481                 for(srna=brna->structs.first; srna; srna=srna->cont.next) {
 482                         for (func= srna->functions.first; func; func= func->cont.next)
 483                                 rna_freelistN(&func->cont.properties);
 484
 485                         rna_freelistN(&srna->cont.properties);
 486                         rna_freelistN(&srna->functions);
 487                 }
 488
 489                 rna_freelistN(&brna->structs);
 490
 491                 MEM_freeN(brna);
 492         }
 493         else {
 494                 for(srna=brna->structs.first; srna; srna=nextsrna) {
 495                         nextsrna= srna->cont.next;
 496                         RNA_struct_free(brna, srna);
 497                 }
 498         }
 499 }
 500
 501 static size_t rna_property_type_sizeof(PropertyType type)
 502 {
 503         switch(type) {
 504                 case PROP_BOOLEAN: return sizeof(BooleanPropertyRNA);
 505                 case PROP_INT: return sizeof(IntPropertyRNA);
 506                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
 507                 case PROP_STRING: return sizeof(StringPropertyRNA);
 508                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
 509                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
 510                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
 511                 default: return 0;
 512         }
 513 }
 514
 515 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
 516 {
 517         StructDefRNA *ds;
 518
 519         for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
 520                 if(ds->srna == srna)
 521                         return ds;
 522
 523         return NULL;
 524 }
 525
 526 /* Struct Definition */
 527
 528 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
 529 {
 530         StructRNA *srna, *srnafrom= NULL;
 531         StructDefRNA *ds= NULL, *dsfrom= NULL;
 532         PropertyRNA *prop;
 533
 534         if(DefRNA.preprocess) {
 535                 char error[512];
 536
 537                 if (rna_validate_identifier(identifier, error, 0) == 0) {
 538                         fprintf(stderr, "RNA_def_struct: struct identifier \"%s\" error - %s\n", identifier, error);
 539                         DefRNA.error= 1;
 540                 }
 541         }
 542
 543         if(from) {
 544                 /* find struct to derive from */
 545                 for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->cont.next)
 546                         if(strcmp(srnafrom->identifier, from) == 0)
 547                                 break;
 548
 549                 if(!srnafrom) {
 550                         fprintf(stderr, "RNA_def_struct: struct %s not found to define %s.\n", from, identifier);
 551                         DefRNA.error= 1;
 552                 }
 553         }
 554
 555         srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
 556         DefRNA.laststruct= srna;
 557
 558         if(srnafrom) {
 559                 /* copy from struct to derive stuff, a bit clumsy since we can't
 560                  * use MEM_dupallocN, data structs may not be alloced but builtin */
 561                 memcpy(srna, srnafrom, sizeof(StructRNA));
 562                 srna->cont.prophash= NULL;
 563                 srna->cont.properties.first= srna->cont.properties.last= NULL;
 564                 srna->functions.first= srna->functions.last= NULL;
 565                 srna->py_type= NULL;
 566
 567                 if(DefRNA.preprocess) {
 568                         srna->base= srnafrom;
 569                         dsfrom= rna_find_def_struct(srnafrom);
 570                 }
 571                 else
 572                         srna->base= srnafrom;
 573         }
 574
 575         srna->identifier= identifier;
 576         srna->name= identifier; /* may be overwritten later RNA_def_struct_ui_text */
 577         srna->description= "";
 578         if(!srnafrom)
 579                 srna->icon= ICON_DOT;
 580
 581         rna_addtail(&brna->structs, srna);
 582
 583         if(DefRNA.preprocess) {
 584                 ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
 585                 ds->srna= srna;
 586                 rna_addtail(&DefRNA.structs, ds);
 587
 588                 if(dsfrom)
 589                         ds->dnafromname= dsfrom->dnaname;
 590         }
 591
 592         /* in preprocess, try to find sdna */
 593         if(DefRNA.preprocess)
 594                 RNA_def_struct_sdna(srna, srna->identifier);
 595         else
 596                 srna->flag |= STRUCT_RUNTIME;
 597
 598         if(srnafrom) {
 599                 srna->nameproperty= srnafrom->nameproperty;
 600                 srna->iteratorproperty= srnafrom->iteratorproperty;
 601         }
 602         else {
 603                 /* define some builtin properties */
 604                 prop= RNA_def_property(&srna->cont, "rna_properties", PROP_COLLECTION, PROP_NONE);
 605                 RNA_def_property_flag(prop, PROP_BUILTIN);
 606                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
 607
 608                 if(DefRNA.preprocess) {
 609                         RNA_def_property_struct_type(prop, "Property");
 610                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", 0, 0, "rna_builtin_properties_lookup_string", 0, 0);
 611                 }
 612                 else {
 613 #ifdef RNA_RUNTIME
 614                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 615                         cprop->begin= rna_builtin_properties_begin;
 616                         cprop->next= rna_builtin_properties_next;
 617                         cprop->get= rna_builtin_properties_get;
 618                         cprop->type= &RNA_Property;
 619 #endif
 620                 }
 621
 622                 prop= RNA_def_property(&srna->cont, "rna_type", PROP_POINTER, PROP_NONE);
 623                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition.");
 624
 625                 if(DefRNA.preprocess) {
 626                         RNA_def_property_struct_type(prop, "Struct");
 627                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
 628                 }
 629                 else {
 630 #ifdef RNA_RUNTIME
 631                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 632                         pprop->get= rna_builtin_type_get;
 633                         pprop->type= &RNA_Struct;
 634 #endif
 635                 }
 636         }
 637
 638         return srna;
 639 }
 640
 641 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
 642 {
 643         StructDefRNA *ds;
 644
 645         if(!DefRNA.preprocess) {
 646                 fprintf(stderr, "RNA_def_struct_sdna: only during preprocessing.\n");
 647                 return;
 648         }
 649
 650         ds= rna_find_def_struct(srna);
 651
 652         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
 653                 if(!DefRNA.silent) {
 654                         fprintf(stderr, "RNA_def_struct_sdna: %s not found.\n", structname);
 655                         DefRNA.error= 1;
 656                 }
 657                 return;
 658         }
 659
 660         ds->dnaname= structname;
 661 }
 662
 663 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
 664 {
 665         StructDefRNA *ds;
 666
 667         if(!DefRNA.preprocess) {
 668                 fprintf(stderr, "RNA_def_struct_sdna_from: only during preprocessing.\n");
 669                 return;
 670         }
 671
 672         ds= rna_find_def_struct(srna);
 673
 674         if(!ds->dnaname) {
 675                 fprintf(stderr, "RNA_def_struct_sdna_from: %s base struct must know DNA already.\n", structname);
 676                 return;
 677         }
 678
 679         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
 680                 if(!DefRNA.silent) {
 681                         fprintf(stderr, "RNA_def_struct_sdna_from: %s not found.\n", structname);
 682                         DefRNA.error= 1;
 683                 }
 684                 return;
 685         }
 686
 687         ds->dnafromprop= propname;
 688         ds->dnaname= structname;
 689 }
 690
 691 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 692 {
 693         if(prop->type != PROP_STRING) {
 694                 fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
 695                 DefRNA.error= 1;
 696         }
 697         else
 698                 srna->nameproperty= prop;
 699 }
 700
 701 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
 702 {
 703         StructRNA *srnafrom;
 704
 705         /* find struct to derive from */
 706         for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->cont.next)
 707                 if(strcmp(srnafrom->identifier, structname) == 0)
 708                         break;
 709
 710         if(!srnafrom) {
 711                 fprintf(stderr, "RNA_def_struct_nested: struct %s not found.\n", structname);
 712                 DefRNA.error= 1;
 713         }
 714
 715         srna->nested= srnafrom;
 716 }
 717
 718 void RNA_def_struct_flag(StructRNA *srna, int flag)
 719 {
 720         srna->flag |= flag;
 721 }
 722
 723 void RNA_def_struct_clear_flag(StructRNA *srna, int flag)
 724 {
 725         srna->flag &= ~flag;
 726 }
 727
 728 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
 729 {
 730         if(!DefRNA.preprocess) {
 731                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
 732                 return;
 733         }
 734
 735         if(refine) srna->refine= (StructRefineFunc)refine;
 736 }
 737
 738 void RNA_def_struct_idproperties_func(StructRNA *srna, const char *idproperties)
 739 {
 740         if(!DefRNA.preprocess) {
 741                 fprintf(stderr, "RNA_def_struct_idproperties_func: only during preprocessing.\n");
 742                 return;
 743         }
 744
 745         if(idproperties) srna->idproperties= (IDPropertiesFunc)idproperties;
 746 }
 747
 748 void RNA_def_struct_register_funcs(StructRNA *srna, const char *reg, const char *unreg)
 749 {
 750         if(!DefRNA.preprocess) {
 751                 fprintf(stderr, "RNA_def_struct_register_funcs: only during preprocessing.\n");
 752                 return;
 753         }
 754
 755         if(reg) srna->reg= (StructRegisterFunc)reg;
 756         if(unreg) srna->unreg= (StructUnregisterFunc)unreg;
 757 }
 758
 759 void RNA_def_struct_path_func(StructRNA *srna, const char *path)
 760 {
 761         if(!DefRNA.preprocess) {
 762                 fprintf(stderr, "RNA_def_struct_path_func: only during preprocessing.\n");
 763                 return;
 764         }
 765
 766         if(path) srna->path= (StructPathFunc)path;
 767 }
 768
 769 void RNA_def_struct_identifier(StructRNA *srna, const char *identifier)
 770 {
 771         if(DefRNA.preprocess) {
 772                 fprintf(stderr, "RNA_def_struct_name_runtime: only at runtime.\n");
 773                 return;
 774         }
 775
 776         srna->identifier= identifier;
 777 }
 778
 779 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
 780 {
 781         srna->name= name;
 782         srna->description= description;
 783 }
 784
 785 void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
 786 {
 787         srna->icon= icon;
 788 }
 789
 790 /* Property Definition */
 791
 792 PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
 793 {
 794         StructRNA *srna= DefRNA.laststruct;
 795         ContainerRNA *cont= cont_;
 796         ContainerDefRNA *dcont;
 797         PropertyDefRNA *dprop= NULL;
 798         PropertyRNA *prop;
 799
 800         if(DefRNA.preprocess) {
 801                 char error[512];
 802
 803                 if (rna_validate_identifier(identifier, error, 1) == 0) {
 804                         fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
 805                         DefRNA.error= 1;
 806                 }
 807
 808                 dcont= rna_find_container_def(cont);
 809                 dprop= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
 810                 rna_addtail(&dcont->properties, dprop);
 811         }
 812
 813         prop= MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
 814
 815         switch(type) {
 816                 case PROP_BOOLEAN:
 817                         break;
 818                 case PROP_INT: {
 819                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 820
 821                         iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN;
 822                         iprop->hardmax= INT_MAX;
 823
 824                         iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
 825                         iprop->softmax= 10000;
 826                         iprop->step= 1;
 827                         break;
 828                 }
 829                 case PROP_FLOAT: {
 830                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 831
 832                         fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
 833                         fprop->hardmax= FLT_MAX;
 834
 835                         if(subtype == PROP_COLOR) {
 836                                 fprop->softmin= 0.0f;
 837                                 fprop->softmax= 1.0f;
 838                         }
 839                         else if(subtype == PROP_PERCENTAGE) {
 840                                 fprop->softmin= fprop->hardmin= 0.0f;
 841                                 fprop->softmax= fprop->hardmax= 1.0f;
 842                         }
 843                         else {
 844                                 fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
 845                                 fprop->softmax= 10000.0f;
 846                         }
 847                         fprop->step= 10;
 848                         fprop->precision= 3;
 849                         break;
 850                 }
 851                 case PROP_STRING: {
 852                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 853
 854                         sprop->defaultvalue= "";
 855                         sprop->maxlength= 0;
 856                         break;
 857                 }
 858                 case PROP_ENUM:
 859                 case PROP_POINTER:
 860                 case PROP_COLLECTION:
 861                         break;
 862                 default:
 863                         fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
 864                         DefRNA.error= 1;
 865                         return NULL;
 866         }
 867
 868         if(DefRNA.preprocess) {
 869                 dprop->cont= cont;
 870                 dprop->prop= prop;
 871         }
 872
 873         prop->magic= RNA_MAGIC;
 874         prop->identifier= identifier;
 875         prop->type= type;
 876         prop->subtype= subtype;
 877         prop->name= identifier;
 878         prop->description= "";
 879
 880         if(type != PROP_COLLECTION && type != PROP_POINTER) {
 881                 prop->flag= PROP_EDITABLE;
 882
 883                 if(type != PROP_STRING)
 884                         prop->flag |= PROP_ANIMATEABLE;
 885         }
 886
 887         if(DefRNA.preprocess) {
 888                 switch(type) {
 889                         case PROP_BOOLEAN:
 890                                 DefRNA.silent= 1;
 891                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
 892                                 DefRNA.silent= 0;
 893                                 break;
 894                         case PROP_INT: {
 895                                 DefRNA.silent= 1;
 896                                 RNA_def_property_int_sdna(prop, NULL, identifier);
 897                                 DefRNA.silent= 0;
 898                                 break;
 899                         }
 900                         case PROP_FLOAT: {
 901                                 DefRNA.silent= 1;
 902                                 RNA_def_property_float_sdna(prop, NULL, identifier);
 903                                 DefRNA.silent= 0;
 904                                 break;
 905                         }
 906                         case PROP_STRING: {
 907                                 DefRNA.silent= 1;
 908                                 RNA_def_property_string_sdna(prop, NULL, identifier);
 909                                 DefRNA.silent= 0;
 910                                 break;
 911                         }
 912                         case PROP_ENUM:
 913                                 DefRNA.silent= 1;
 914                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
 915                                 DefRNA.silent= 0;
 916                                 break;
 917                         case PROP_POINTER:
 918                                 DefRNA.silent= 1;
 919                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
 920                                 DefRNA.silent= 0;
 921                                 break;
 922                         case PROP_COLLECTION:
 923                                 DefRNA.silent= 1;
 924                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
 925                                 DefRNA.silent= 0;
 926                                 break;
 927                 }
 928         }
 929         else {
 930                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
 931 #ifdef RNA_RUNTIME
 932                 if(cont->prophash)
 933                         BLI_ghash_insert(cont->prophash, (void*)prop->identifier, prop);
 934 #endif
 935         }
 936
 937         rna_addtail(&cont->properties, prop);
 938
 939         return prop;
 940 }
 941
 942 void RNA_def_property_flag(PropertyRNA *prop, int flag)
 943 {
 944         prop->flag |= flag;
 945 }
 946
 947 void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
 948 {
 949         prop->flag &= ~flag;
 950 }
 951
 952 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
 953 {
 954         StructRNA *srna= DefRNA.laststruct;
 955
 956         if(arraylength<0) {
 957                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be zero of greater.\n", srna->identifier, prop->identifier);
 958                 DefRNA.error= 1;
 959                 return;
 960         }
 961
 962         if(arraylength>RNA_MAX_ARRAY) {
 963                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY);
 964                 DefRNA.error= 1;
 965                 return;
 966         }
 967
 968         switch(prop->type) {
 969                 case PROP_BOOLEAN:
 970                 case PROP_INT:
 971                 case PROP_FLOAT:
 972                         prop->arraylength= arraylength;
 973                         break;
 974                 default:
 975                         fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
 976                         DefRNA.error= 1;
 977                         break;
 978         }
 979 }
 980
 981 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
 982 {
 983         prop->name= name;
 984         prop->description= description;
 985 }
 986
 987 void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
 988 {
 989         prop->icon= icon;
 990         if(consecutive)
 991                 prop->flag |= PROP_ICONS_CONSECUTIVE;
 992 }
 993
 994 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
 995 {
 996         StructRNA *srna= DefRNA.laststruct;
 997
 998         switch(prop->type) {
 999                 case PROP_INT: {
1000                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1001                         iprop->softmin= (int)min;
1002                         iprop->softmax= (int)max;
1003                         iprop->step= (int)step;
1004                         break;
1005                 }
1006                 case PROP_FLOAT: {
1007                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1008                         fprop->softmin= (float)min;
1009                         fprop->softmax= (float)max;
1010                         fprop->step= (float)step;
1011                         fprop->precision= (int)precision;
1012                         break;
1013                 }
1014                 default:
1015                         fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
1016                         DefRNA.error= 1;
1017                         break;
1018         }
1019 }
1020
1021 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
1022 {
1023         StructRNA *srna= DefRNA.laststruct;
1024
1025         switch(prop->type) {
1026                 case PROP_INT: {
1027                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1028                         iprop->hardmin= (int)min;
1029                         iprop->hardmax= (int)max;
1030                         iprop->softmin= MAX2((int)min, iprop->hardmin);
1031                         iprop->softmax= MIN2((int)max, iprop->hardmax);
1032                         break;
1033                 }
1034                 case PROP_FLOAT: {
1035                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1036                         fprop->hardmin= (float)min;
1037                         fprop->hardmax= (float)max;
1038                         fprop->softmin= MAX2((float)min, fprop->hardmin);
1039                         fprop->softmax= MIN2((float)max, fprop->hardmax);
1040                         break;
1041                 }
1042                 default:
1043                         fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
1044                         DefRNA.error= 1;
1045                         break;
1046         }
1047 }
1048
1049 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
1050 {
1051         StructRNA *srna= DefRNA.laststruct;
1052
1053         if(!DefRNA.preprocess) {
1054                 fprintf(stderr, "RNA_def_property_struct_type: only during preprocessing.\n");
1055                 return;
1056         }
1057
1058         switch(prop->type) {
1059                 case PROP_POINTER: {
1060                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1061                         pprop->type = (StructRNA*)type;
1062                         break;
1063                 }
1064                 case PROP_COLLECTION: {
1065                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1066                         cprop->type = (StructRNA*)type;
1067                         break;
1068                 }
1069                 default:
1070                         fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
1071                         DefRNA.error= 1;
1072                         break;
1073         }
1074 }
1075
1076 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
1077 {
1078         StructRNA *srna= DefRNA.laststruct;
1079
1080         if(DefRNA.preprocess) {
1081                 fprintf(stderr, "RNA_def_property_struct_runtime: only at runtime.\n");
1082                 return;
1083         }
1084
1085         switch(prop->type) {
1086                 case PROP_POINTER: {
1087                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1088                         pprop->type = type;
1089
1090                         if(type && (type->flag & STRUCT_ID_REFCOUNT))
1091                                 prop->flag |= PROP_ID_REFCOUNT;
1092
1093                         break;
1094                 }
1095                 case PROP_COLLECTION: {
1096                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1097                         cprop->type = type;
1098                         break;
1099                 }
1100                 default:
1101                         fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
1102                         DefRNA.error= 1;
1103                         break;
1104         }
1105 }
1106
1107 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
1108 {
1109         StructRNA *srna= DefRNA.laststruct;
1110         int i, defaultfound= 0;
1111
1112         switch(prop->type) {
1113                 case PROP_ENUM: {
1114                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1115                         eprop->item= item;
1116                         eprop->totitem= 0;
1117                         for(i=0; item[i].identifier; i++) {
1118                                 eprop->totitem++;
1119
1120                                 if(item[i].value == eprop->defaultvalue)
1121                                         defaultfound= 1;
1122                         }
1123
1124                         if(!defaultfound)
1125                                 eprop->defaultvalue= item[0].value;
1126
1127                         break;
1128                 }
1129                 default:
1130                         fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
1131                         DefRNA.error= 1;
1132                         break;
1133         }
1134 }
1135
1136 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
1137 {
1138         StructRNA *srna= DefRNA.laststruct;
1139
1140         switch(prop->type) {
1141                 case PROP_STRING: {
1142                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1143                         sprop->maxlength= maxlength;
1144                         break;
1145                 }
1146                 default:
1147                         fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1148                         DefRNA.error= 1;
1149                         break;
1150         }
1151 }
1152
1153 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
1154 {
1155         StructRNA *srna= DefRNA.laststruct;
1156
1157         switch(prop->type) {
1158                 case PROP_BOOLEAN: {
1159                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1160                         bprop->defaultvalue= value;
1161                         break;
1162                 }
1163                 default:
1164                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1165                         DefRNA.error= 1;
1166                         break;
1167         }
1168 }
1169
1170 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
1171 {
1172         StructRNA *srna= DefRNA.laststruct;
1173
1174         switch(prop->type) {
1175                 case PROP_BOOLEAN: {
1176                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1177                         bprop->defaultarray= array;
1178                         break;
1179                 }
1180                 default:
1181                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1182                         DefRNA.error= 1;
1183                         break;
1184         }
1185 }
1186
1187 void RNA_def_property_int_default(PropertyRNA *prop, int value)
1188 {
1189         StructRNA *srna= DefRNA.laststruct;
1190
1191         switch(prop->type) {
1192                 case PROP_INT: {
1193                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1194                         iprop->defaultvalue= value;
1195                         break;
1196                 }
1197                 default:
1198                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1199                         DefRNA.error= 1;
1200                         break;
1201         }
1202 }
1203
1204 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
1205 {
1206         StructRNA *srna= DefRNA.laststruct;
1207
1208         switch(prop->type) {
1209                 case PROP_INT: {
1210                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1211                         iprop->defaultarray= array;
1212                         break;
1213                 }
1214                 default:
1215                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1216                         DefRNA.error= 1;
1217                         break;
1218         }
1219 }
1220
1221 void RNA_def_property_float_default(PropertyRNA *prop, float value)
1222 {
1223         StructRNA *srna= DefRNA.laststruct;
1224
1225         switch(prop->type) {
1226                 case PROP_FLOAT: {
1227                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1228                         fprop->defaultvalue= value;
1229                         break;
1230                 }
1231                 default:
1232                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1233                         DefRNA.error= 1;
1234                         break;
1235         }
1236 }
1237 /* array must remain valid after this function finishes */
1238 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
1239 {
1240         StructRNA *srna= DefRNA.laststruct;
1241
1242         switch(prop->type) {
1243                 case PROP_FLOAT: {
1244                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1245                         fprop->defaultarray= array; /* WARNING, this array must not come from the stack and lost */
1246                         break;
1247                 }
1248                 default:
1249                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1250                         DefRNA.error= 1;
1251                         break;
1252         }
1253 }
1254
1255 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
1256 {
1257         StructRNA *srna= DefRNA.laststruct;
1258
1259         switch(prop->type) {
1260                 case PROP_STRING: {
1261                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1262                         sprop->defaultvalue= value;
1263                         break;
1264                 }
1265                 default:
1266                         fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1267                         DefRNA.error= 1;
1268                         break;
1269         }
1270 }
1271
1272 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1273 {
1274         StructRNA *srna= DefRNA.laststruct;
1275         int i, defaultfound= 0;
1276
1277         switch(prop->type) {
1278                 case PROP_ENUM: {
1279                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1280                         eprop->defaultvalue= value;
1281
1282                         for(i=0; i<eprop->totitem; i++) {
1283                                 if(eprop->item[i].value == eprop->defaultvalue)
1284                                         defaultfound= 1;
1285                         }
1286
1287                         if(!defaultfound && eprop->totitem) {
1288                                 if(value == 0) {
1289                                         eprop->defaultvalue= eprop->item[0].value;
1290                                 }
1291                                 else {
1292                                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, default is not in items.\n", srna->identifier, prop->identifier);
1293                                         DefRNA.error= 1;
1294                                 }
1295                         }
1296
1297                         break;
1298                 }
1299                 default:
1300                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1301                         DefRNA.error= 1;
1302                         break;
1303         }
1304 }
1305
1306 /* SDNA */
1307
1308 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1309 {
1310         DNAStructMember smember;
1311         StructDefRNA *ds;
1312         PropertyDefRNA *dp;
1313
1314         dp= rna_find_struct_property_def(prop);
1315         if (dp==NULL) return NULL;
1316
1317         ds= rna_find_struct_def((StructRNA*)dp->cont);
1318
1319         if(!structname)
1320                 structname= ds->dnaname;
1321         if(!propname)
1322                 propname= prop->identifier;
1323
1324         if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1325                 if(!DefRNA.silent) {
1326                         fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
1327                         DefRNA.error= 1;
1328                 }
1329                 return NULL;
1330         }
1331
1332         if(smember.arraylength > 1)
1333                 prop->arraylength= smember.arraylength;
1334         else
1335                 prop->arraylength= 0;
1336
1337         dp->dnastructname= structname;
1338         dp->dnastructfromname= ds->dnafromname;
1339         dp->dnastructfromprop= ds->dnafromprop;
1340         dp->dnaname= propname;
1341         dp->dnatype= smember.type;
1342         dp->dnaarraylength= smember.arraylength;
1343         dp->dnapointerlevel= smember.pointerlevel;
1344
1345         return dp;
1346 }
1347
1348 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1349 {
1350         PropertyDefRNA *dp;
1351         StructRNA *srna= DefRNA.laststruct;
1352
1353         if(!DefRNA.preprocess) {
1354                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1355                 return;
1356         }
1357
1358         if(prop->type != PROP_BOOLEAN) {
1359                 fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1360                 DefRNA.error= 1;
1361                 return;
1362         }
1363
1364         if((dp=rna_def_property_sdna(prop, structname, propname)))
1365                 dp->booleanbit= bit;
1366 }
1367
1368 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
1369 {
1370         PropertyDefRNA *dp;
1371
1372         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1373
1374         dp= rna_find_struct_property_def(prop);
1375
1376         if(dp)
1377                 dp->booleannegative= 1;
1378 }
1379
1380 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1381 {
1382         PropertyDefRNA *dp;
1383         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1384         StructRNA *srna= DefRNA.laststruct;
1385
1386         if(!DefRNA.preprocess) {
1387                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1388                 return;
1389         }
1390
1391         if(prop->type != PROP_INT) {
1392                 fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1393                 DefRNA.error= 1;
1394                 return;
1395         }
1396
1397         if((dp= rna_def_property_sdna(prop, structname, propname))) {
1398                 /* SDNA doesn't pass us unsigned unfortunately .. */
1399                 if(strcmp(dp->dnatype, "char") == 0) {
1400                         iprop->hardmin= iprop->softmin= CHAR_MIN;
1401                         iprop->hardmax= iprop->softmax= CHAR_MAX;
1402                 }
1403                 else if(strcmp(dp->dnatype, "short") == 0) {
1404                         iprop->hardmin= iprop->softmin= SHRT_MIN;
1405                         iprop->hardmax= iprop->softmax= SHRT_MAX;
1406                 }
1407                 else if(strcmp(dp->dnatype, "int") == 0) {
1408                         iprop->hardmin= INT_MIN;
1409                         iprop->hardmax= INT_MAX;
1410
1411                         iprop->softmin= -10000; /* rather arbitrary .. */
1412                         iprop->softmax= 10000;
1413                 }
1414
1415                 if(prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE)
1416                         iprop->hardmin= iprop->softmin= 0;
1417         }
1418 }
1419
1420 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1421 {
1422         StructRNA *srna= DefRNA.laststruct;
1423
1424         if(!DefRNA.preprocess) {
1425                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1426                 return;
1427         }
1428
1429         if(prop->type != PROP_FLOAT) {
1430                 fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1431                 DefRNA.error= 1;
1432                 return;
1433         }
1434
1435         rna_def_property_sdna(prop, structname, propname);
1436 }
1437
1438 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1439 {
1440         PropertyDefRNA *dp;
1441         StructRNA *srna= DefRNA.laststruct;
1442
1443         if(!DefRNA.preprocess) {
1444                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1445                 return;
1446         }
1447
1448         if(prop->type != PROP_ENUM) {
1449                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1450                 DefRNA.error= 1;
1451                 return;
1452         }
1453
1454         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1455                 if(prop->arraylength) {
1456                         prop->arraylength= 0;
1457                         if(!DefRNA.silent) {
1458                                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
1459                                 DefRNA.error= 1;
1460                         }
1461                 }
1462         }
1463 }
1464
1465 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1466 {
1467         PropertyDefRNA *dp;
1468
1469         RNA_def_property_enum_sdna(prop, structname, propname);
1470
1471         dp= rna_find_struct_property_def(prop);
1472
1473         if(dp)
1474                 dp->enumbitflags= 1;
1475 }
1476
1477 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1478 {
1479         PropertyDefRNA *dp;
1480         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1481         StructRNA *srna= DefRNA.laststruct;
1482
1483         if(!DefRNA.preprocess) {
1484                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1485                 return;
1486         }
1487
1488         if(prop->type != PROP_STRING) {
1489                 fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1490                 DefRNA.error= 1;
1491                 return;
1492         }
1493
1494         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1495                 if(prop->arraylength) {
1496                         sprop->maxlength= prop->arraylength;
1497                         prop->arraylength= 0;
1498                 }
1499         }
1500 }
1501
1502 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1503 {
1504         PropertyDefRNA *dp;
1505         StructRNA *srna= DefRNA.laststruct;
1506
1507         if(!DefRNA.preprocess) {
1508                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1509                 return;
1510         }
1511
1512         if(prop->type != PROP_POINTER) {
1513                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1514                 DefRNA.error= 1;
1515                 return;
1516         }
1517
1518         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1519                 if(prop->arraylength) {
1520                         prop->arraylength= 0;
1521                         if(!DefRNA.silent) {
1522                                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
1523                                 DefRNA.error= 1;
1524                         }
1525                 }
1526         }
1527 }
1528
1529 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
1530 {
1531         PropertyDefRNA *dp;
1532         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1533         StructRNA *srna= DefRNA.laststruct;
1534
1535         if(!DefRNA.preprocess) {
1536                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1537                 return;
1538         }
1539
1540         if(prop->type != PROP_COLLECTION) {
1541                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1542                 DefRNA.error= 1;
1543                 return;
1544         }
1545
1546         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1547                 if(prop->arraylength && !lengthpropname) {
1548                         prop->arraylength= 0;
1549
1550                         if(!DefRNA.silent) {
1551                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
1552                                 DefRNA.error= 1;
1553                         }
1554                 }
1555
1556                 if(strcmp(dp->dnatype, "ListBase") == 0) {
1557                         cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next";
1558                         cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
1559                         cprop->end= (PropCollectionEndFunc)"rna_iterator_listbase_end";
1560                 }
1561         }
1562
1563         if(dp && lengthpropname) {
1564                 DNAStructMember smember;
1565                 StructDefRNA *ds= rna_find_struct_def((StructRNA*)dp->cont);
1566
1567                 if(!structname)
1568                         structname= ds->dnaname;
1569
1570                 if(lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1571                         if(lengthpropname[0] == 0) {
1572                                 dp->dnalengthfixed= prop->arraylength;
1573                                 prop->arraylength= 0;
1574                         }
1575                         else {
1576                                 dp->dnalengthstructname= structname;
1577                                 dp->dnalengthname= lengthpropname;
1578                         }
1579
1580                         cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
1581                         cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
1582
1583                         if(dp->dnapointerlevel >= 2)
1584                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1585                         else
1586                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
1587                 }
1588                 else {
1589                         if(!DefRNA.silent) {
1590                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
1591                                 DefRNA.error= 1;
1592                         }
1593                 }
1594         }
1595 }
1596
1597 /* Functions */
1598
1599 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1600 {
1601         if(!DefRNA.preprocess) {
1602                 fprintf(stderr, "RNA_def_property_editable_func: only during preprocessing.\n");
1603                 return;
1604         }
1605
1606         if(editable) prop->editable= (EditableFunc)editable;
1607 }
1608
1609 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1610 {
1611         if(!DefRNA.preprocess) {
1612                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
1613                 return;
1614         }
1615
1616         prop->noteflag= noteflag;
1617         prop->update= (UpdateFunc)func;
1618 }
1619
1620 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1621 {
1622         StructRNA *srna= DefRNA.laststruct;
1623
1624         if(!DefRNA.preprocess) {
1625                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1626                 return;
1627         }
1628
1629         switch(prop->type) {
1630                 case PROP_BOOLEAN: {
1631                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1632
1633                         if(prop->arraylength) {
1634                                 if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
1635                                 if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
1636                         }
1637                         else {
1638                                 if(get) bprop->get= (PropBooleanGetFunc)get;
1639                                 if(set) bprop->set= (PropBooleanSetFunc)set;
1640                         }
1641                         break;
1642                 }
1643                 default:
1644                         fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1645                         DefRNA.error= 1;
1646                         break;
1647         }
1648 }
1649
1650 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1651 {
1652         StructRNA *srna= DefRNA.laststruct;
1653
1654         if(!DefRNA.preprocess) {
1655                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1656                 return;
1657         }
1658
1659         switch(prop->type) {
1660                 case PROP_INT: {
1661                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1662
1663                         if(prop->arraylength) {
1664                                 if(get) iprop->getarray= (PropIntArrayGetFunc)get;
1665                                 if(set) iprop->setarray= (PropIntArraySetFunc)set;
1666                         }
1667                         else {
1668                                 if(get) iprop->get= (PropIntGetFunc)get;
1669                                 if(set) iprop->set= (PropIntSetFunc)set;
1670                         }
1671                         if(range) iprop->range= (PropIntRangeFunc)range;
1672                         break;
1673                 }
1674                 default:
1675                         fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1676                         DefRNA.error= 1;
1677                         break;
1678         }
1679 }
1680
1681 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1682 {
1683         StructRNA *srna= DefRNA.laststruct;
1684
1685         if(!DefRNA.preprocess) {
1686                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1687                 return;
1688         }
1689
1690         switch(prop->type) {
1691                 case PROP_FLOAT: {
1692                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1693
1694                         if(prop->arraylength) {
1695                                 if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
1696                                 if(set) fprop->setarray= (PropFloatArraySetFunc)set;
1697                         }
1698                         else {
1699                                 if(get) fprop->get= (PropFloatGetFunc)get;
1700                                 if(set) fprop->set= (PropFloatSetFunc)set;
1701                         }
1702                         if(range) fprop->range= (PropFloatRangeFunc)range;
1703                         break;
1704                 }
1705                 default:
1706                         fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1707                         DefRNA.error= 1;
1708                         break;
1709         }
1710 }
1711
1712 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
1713 {
1714         StructRNA *srna= DefRNA.laststruct;
1715
1716         if(!DefRNA.preprocess) {
1717                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1718                 return;
1719         }
1720
1721         switch(prop->type) {
1722                 case PROP_ENUM: {
1723                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1724
1725                         if(get) eprop->get= (PropEnumGetFunc)get;
1726                         if(set) eprop->set= (PropEnumSetFunc)set;
1727                         if(item) eprop->itemf= (PropEnumItemFunc)item;
1728                         break;
1729                 }
1730                 default:
1731                         fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1732                         DefRNA.error= 1;
1733                         break;
1734         }
1735 }
1736
1737 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
1738 {
1739         StructRNA *srna= DefRNA.laststruct;
1740
1741         if(!DefRNA.preprocess) {
1742                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1743                 return;
1744         }
1745
1746         switch(prop->type) {
1747                 case PROP_STRING: {
1748                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1749
1750                         if(get) sprop->get= (PropStringGetFunc)get;
1751                         if(length) sprop->length= (PropStringLengthFunc)length;
1752                         if(set) sprop->set= (PropStringSetFunc)set;
1753                         break;
1754                 }
1755                 default:
1756                         fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1757                         DefRNA.error= 1;
1758                         break;
1759         }
1760 }
1761
1762 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *typef)
1763 {
1764         StructRNA *srna= DefRNA.laststruct;
1765
1766         if(!DefRNA.preprocess) {
1767                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1768                 return;
1769         }
1770
1771         switch(prop->type) {
1772                 case PROP_POINTER: {
1773                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1774
1775                         if(get) pprop->get= (PropPointerGetFunc)get;
1776                         if(set) pprop->set= (PropPointerSetFunc)set;
1777                         if(typef) pprop->typef= (PropPointerTypeFunc)typef;
1778                         break;
1779                 }
1780                 default:
1781                         fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1782                         DefRNA.error= 1;
1783                         break;
1784         }
1785 }
1786
1787 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *add, const char *remove)
1788 {
1789         StructRNA *srna= DefRNA.laststruct;
1790
1791         if(!DefRNA.preprocess) {
1792                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1793                 return;
1794         }
1795
1796         switch(prop->type) {
1797                 case PROP_COLLECTION: {
1798                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1799
1800                         if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
1801                         if(next) cprop->next= (PropCollectionNextFunc)next;
1802                         if(end) cprop->end= (PropCollectionEndFunc)end;
1803                         if(get) cprop->get= (PropCollectionGetFunc)get;
1804                         if(length) cprop->length= (PropCollectionLengthFunc)length;
1805                         if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
1806                         if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
1807                         if(add) cprop->add= (FunctionRNA*)add;
1808                         if(remove) cprop->remove= (FunctionRNA*)remove;
1809                         break;
1810                 }
1811                 default:
1812                         fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1813                         DefRNA.error= 1;
1814                         break;
1815         }
1816 }
1817
1818 /* Compact definitions */
1819
1820 PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value, const char *ui_name, const char *ui_description)
1821 {
1822         ContainerRNA *cont= cont_;
1823         PropertyRNA *prop;
1824
1825         prop= RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
1826         RNA_def_property_boolean_default(prop, default_value);
1827         RNA_def_property_ui_text(prop, ui_name, ui_description);
1828
1829         return prop;
1830 }
1831
1832 PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
1833         const char *ui_name, const char *ui_description)
1834 {
1835         ContainerRNA *cont= cont_;
1836         PropertyRNA *prop;
1837
1838         prop= RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
1839         if(len != 0) RNA_def_property_array(prop, len);
1840         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1841         RNA_def_property_ui_text(prop, ui_name, ui_description);
1842
1843         return prop;
1844 }
1845
1846 PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
1847         const char *ui_name, const char *ui_description)
1848 {
1849         ContainerRNA *cont= cont_;
1850         PropertyRNA *prop;
1851
1852         prop= RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_VECTOR);
1853         if(len != 0) RNA_def_property_array(prop, len);
1854         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1855         RNA_def_property_ui_text(prop, ui_name, ui_description);
1856
1857         return prop;
1858 }
1859
1860 PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin, int hardmax,
1861         const char *ui_name, const char *ui_description, int softmin, int softmax)
1862 {
1863         ContainerRNA *cont= cont_;
1864         PropertyRNA *prop;
1865
1866         prop= RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
1867         RNA_def_property_int_default(prop, default_value);
1868         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1869         RNA_def_property_ui_text(prop, ui_name, ui_description);
1870         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1871
1872         return prop;
1873 }
1874
1875 PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
1876         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1877 {
1878         ContainerRNA *cont= cont_;
1879         PropertyRNA *prop;
1880
1881         prop= RNA_def_property(cont, identifier, PROP_INT, PROP_VECTOR);
1882         if(len != 0) RNA_def_property_array(prop, len);
1883         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1884         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1885         RNA_def_property_ui_text(prop, ui_name, ui_description);
1886         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1887
1888         return prop;
1889 }
1890
1891 PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
1892         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1893 {
1894         ContainerRNA *cont= cont_;
1895         PropertyRNA *prop;
1896
1897         prop= RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
1898         if(len != 0) RNA_def_property_array(prop, len);
1899         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1900         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1901         RNA_def_property_ui_text(prop, ui_name, ui_description);
1902         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1903
1904         return prop;
1905 }
1906
1907 PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
1908         const char *ui_name, const char *ui_description)
1909 {
1910         ContainerRNA *cont= cont_;
1911         PropertyRNA *prop;
1912
1913         prop= RNA_def_property(cont, identifier, PROP_STRING, PROP_NONE);
1914         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1915         if(default_value) RNA_def_property_string_default(prop, default_value);
1916         RNA_def_property_ui_text(prop, ui_name, ui_description);
1917
1918         return prop;
1919 }
1920
1921 PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
1922         const char *ui_name, const char *ui_description)
1923 {
1924         ContainerRNA *cont= cont_;
1925         PropertyRNA *prop;
1926
1927         prop= RNA_def_property(cont, identifier, PROP_STRING, PROP_FILEPATH);
1928         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1929         if(default_value) RNA_def_property_string_default(prop, default_value);
1930         RNA_def_property_ui_text(prop, ui_name, ui_description);
1931
1932         return prop;
1933 }
1934
1935 PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
1936         const char *ui_name, const char *ui_description)
1937 {
1938         ContainerRNA *cont= cont_;
1939         PropertyRNA *prop;
1940
1941         prop= RNA_def_property(cont, identifier, PROP_STRING, PROP_DIRPATH);
1942         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1943         if(default_value) RNA_def_property_string_default(prop, default_value);
1944         RNA_def_property_ui_text(prop, ui_name, ui_description);
1945
1946         return prop;
1947 }
1948
1949 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value,
1950         const char *ui_name, const char *ui_description)
1951 {
1952         ContainerRNA *cont= cont_;
1953         PropertyRNA *prop;
1954
1955         prop= RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
1956         if(items) RNA_def_property_enum_items(prop, items);
1957         RNA_def_property_enum_default(prop, default_value);
1958         RNA_def_property_ui_text(prop, ui_name, ui_description);
1959
1960         return prop;
1961 }
1962
1963 PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
1964         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1965 {
1966         ContainerRNA *cont= cont_;
1967         PropertyRNA *prop;
1968
1969         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
1970         RNA_def_property_float_default(prop, default_value);
1971         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1972         RNA_def_property_ui_text(prop, ui_name, ui_description);
1973         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1974
1975         return prop;
1976 }
1977
1978 PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
1979         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1980 {
1981         ContainerRNA *cont= cont_;
1982         PropertyRNA *prop;
1983
1984         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_VECTOR);
1985         if(len != 0) RNA_def_property_array(prop, len);
1986         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1987         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1988         RNA_def_property_ui_text(prop, ui_name, ui_description);
1989         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1990
1991         return prop;
1992 }
1993
1994 PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
1995         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1996 {
1997         ContainerRNA *cont= cont_;
1998         PropertyRNA *prop;
1999
2000         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_COLOR);
2001         if(len != 0) RNA_def_property_array(prop, len);
2002         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2003         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2004         RNA_def_property_ui_text(prop, ui_name, ui_description);
2005         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2006
2007         return prop;
2008 }
2009
2010
2011 PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
2012         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2013 {
2014         ContainerRNA *cont= cont_;
2015         PropertyRNA *prop;
2016
2017         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
2018         if(len != 0) RNA_def_property_array(prop, len);
2019         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2020         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2021         RNA_def_property_ui_text(prop, ui_name, ui_description);
2022         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2023
2024         return prop;
2025 }
2026
2027 PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
2028         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2029 {
2030         ContainerRNA *cont= cont_;
2031         PropertyRNA *prop;
2032
2033         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_ROTATION);
2034         if(len != 0) RNA_def_property_array(prop, len);
2035         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2036         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2037         RNA_def_property_ui_text(prop, ui_name, ui_description);
2038         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2039
2040         return prop;
2041 }
2042
2043 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
2044         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2045 {
2046         ContainerRNA *cont= cont_;
2047         PropertyRNA *prop;
2048
2049         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2050         if(len != 0) RNA_def_property_array(prop, len);
2051         if(default_value) RNA_def_property_float_array_default(prop, default_value);
2052         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2053         RNA_def_property_ui_text(prop, ui_name, ui_description);
2054         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2055
2056         return prop;
2057 }
2058
2059 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2060         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
2061 {
2062         ContainerRNA *cont= cont_;
2063         PropertyRNA *prop;
2064
2065         prop= RNA_def_property(cont, identifier, PROP_FLOAT, PROP_PERCENTAGE);
2066         RNA_def_property_float_default(prop, default_value);
2067         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2068         RNA_def_property_ui_text(prop, ui_name, ui_description);
2069         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2070
2071         return prop;
2072 }
2073
2074 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2075         const char *ui_name, const char *ui_description)
2076 {
2077         ContainerRNA *cont= cont_;
2078         PropertyRNA *prop;
2079
2080         prop= RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2081         RNA_def_property_struct_type(prop, type);
2082         RNA_def_property_ui_text(prop, ui_name, ui_description);
2083
2084         return prop;
2085 }
2086
2087 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2088         const char *ui_name, const char *ui_description)
2089 {
2090         ContainerRNA *cont= cont_;
2091         PropertyRNA *prop;
2092
2093         prop= RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
2094         RNA_def_property_struct_runtime(prop, type);
2095         RNA_def_property_ui_text(prop, ui_name, ui_description);
2096
2097         return prop;
2098 }
2099
2100 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
2101         const char *ui_name, const char *ui_description)
2102 {
2103         ContainerRNA *cont= cont_;
2104         PropertyRNA *prop;
2105
2106         prop= RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2107         RNA_def_property_struct_type(prop, type);
2108         RNA_def_property_ui_text(prop, ui_name, ui_description);
2109
2110         return prop;
2111 }
2112
2113 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
2114         const char *ui_name, const char *ui_description)
2115 {
2116         ContainerRNA *cont= cont_;
2117         PropertyRNA *prop;
2118
2119         prop= RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
2120         RNA_def_property_struct_runtime(prop, type);
2121         RNA_def_property_ui_text(prop, ui_name, ui_description);
2122
2123         return prop;
2124 }
2125
2126 /* Function */
2127
2128 static FunctionRNA *rna_def_function(StructRNA *srna, const char *identifier)
2129 {
2130         FunctionRNA *func;
2131         StructDefRNA *dsrna;
2132         FunctionDefRNA *dfunc;
2133
2134         if(DefRNA.preprocess) {
2135                 char error[512];
2136
2137                 if (rna_validate_identifier(identifier, error, 0) == 0) {
2138                         fprintf(stderr, "RNA_def_function: function identifier \"%s\" - %s\n", identifier, error);
2139                         DefRNA.error= 1;
2140                 }
2141         }
2142
2143         func= MEM_callocN(sizeof(FunctionRNA), "FunctionRNA");
2144         func->identifier= identifier;
2145         func->description= identifier;
2146
2147         rna_addtail(&srna->functions, func);
2148
2149         if(DefRNA.preprocess) {
2150                 dsrna= rna_find_struct_def(srna);
2151                 dfunc= MEM_callocN(sizeof(FunctionDefRNA), "FunctionDefRNA");
2152                 rna_addtail(&dsrna->functions, dfunc);
2153                 dfunc->func= func;
2154         }
2155         else
2156                 func->flag|= FUNC_RUNTIME;
2157
2158         return func;
2159 }
2160
2161 FunctionRNA *RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
2162 {
2163         FunctionRNA *func;
2164         FunctionDefRNA *dfunc;
2165
2166         func= rna_def_function(srna, identifier);
2167
2168         if(!DefRNA.preprocess) {
2169                 fprintf(stderr, "RNA_def_function: only at preprocess time.\n");
2170                 return func;
2171         }
2172
2173         dfunc= rna_find_function_def(func);
2174         dfunc->call= call;
2175
2176         return func;
2177 }
2178
2179 FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
2180 {
2181         FunctionRNA *func;
2182
2183         func= rna_def_function(srna, identifier);
2184
2185         if(DefRNA.preprocess) {
2186                 fprintf(stderr, "RNA_def_function_call_runtime: only at runtime.\n");
2187                 return func;
2188         }
2189
2190         func->call= call;
2191
2192
2193         return func;
2194 }
2195
2196 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
2197 {
2198         func->ret= ret;
2199         ret->flag|=PROP_RETURN;
2200 }
2201
2202 void RNA_def_function_flag(FunctionRNA *func, int flag)
2203 {
2204         func->flag|= flag;
2205 }
2206
2207 void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
2208 {
2209         func->description= description;
2210 }
2211
2212 int rna_parameter_size(PropertyRNA *parm)
2213 {
2214         PropertyType ptype= parm->type;
2215         int len= parm->arraylength;
2216
2217         if(len > 0) {
2218                 switch (ptype) {
2219                         case PROP_BOOLEAN:
2220                         case PROP_INT:
2221                                 return sizeof(int)*len;
2222                         case PROP_FLOAT:
2223                                 return sizeof(float)*len;
2224                         default:
2225                                 break;
2226                 }
2227         }
2228         else {
2229                 switch (ptype) {
2230                         case PROP_BOOLEAN:
2231                         case PROP_INT:
2232                         case PROP_ENUM:
2233                                 return sizeof(int);
2234                         case PROP_FLOAT:
2235                                 return sizeof(float);
2236                         case PROP_STRING:
2237                                 return sizeof(char *);
2238                         case PROP_POINTER: {
2239 #ifdef RNA_RUNTIME
2240                                 if(parm->flag & PROP_RNAPTR)
2241                                         return sizeof(PointerRNA);
2242                                 else
2243                                         return sizeof(void *);
2244 #else
2245                                 if(parm->flag & PROP_RNAPTR)
2246                                         return sizeof(PointerRNA);
2247                                 else
2248                                         return sizeof(void *);
2249 #endif
2250                         }
2251                         case PROP_COLLECTION:
2252                                 /* XXX does not work yet */
2253                                 return sizeof(ListBase);
2254                 }
2255         }
2256
2257         return sizeof(void *);
2258 }
2259