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 "rna_internal.h"
  42
  43 /* Global used during defining */
  44
  45 BlenderDefRNA DefRNA = {0, {0, 0}, {0, 0}, 0, 0, 0};
  46
  47 /* Duplicated code since we can't link in blenkernel or blenlib */
  48
  49 #ifndef MIN2
  50 #define MIN2(x,y) ((x)<(y)? (x): (y))
  51 #define MAX2(x,y) ((x)>(y)? (x): (y))
  52 #endif
  53
  54 void rna_addtail(ListBase *listbase, void *vlink)
  55 {
  56         Link *link= vlink;
  57
  58         link->next = NULL;
  59         link->prev = listbase->last;
  60
  61         if (listbase->last) ((Link *)listbase->last)->next = link;
  62         if (listbase->first == 0) listbase->first = link;
  63         listbase->last = link;
  64 }
  65
  66 void rna_remlink(ListBase *listbase, void *vlink)
  67 {
  68         Link *link= vlink;
  69
  70         if (link->next) link->next->prev = link->prev;
  71         if (link->prev) link->prev->next = link->next;
  72
  73         if (listbase->last == link) listbase->last = link->prev;
  74         if (listbase->first == link) listbase->first = link->next;
  75 }
  76
  77 void rna_freelinkN(ListBase *listbase, void *vlink)
  78 {
  79         rna_remlink(listbase, vlink);
  80         MEM_freeN(vlink);
  81 }
  82
  83 void rna_freelistN(ListBase *listbase)
  84 {
  85         Link *link, *next;
  86
  87         for(link=listbase->first; link; link=next) {
  88                 next= link->next;
  89                 MEM_freeN(link);
  90         }
  91
  92         listbase->first= listbase->last= NULL;
  93 }
  94
  95 /* DNA utility function for looking up members */
  96
  97 typedef struct DNAStructMember {
  98         char *type;
  99         char *name;
 100         int arraylength;
 101         int pointerlevel;
 102 } DNAStructMember;
 103
 104 static int rna_member_cmp(const char *name, const char *oname)
 105 {
 106         int a=0;
 107
 108         /* compare without pointer or array part */
 109         while(name[0]=='*')
 110                 name++;
 111         while(oname[0]=='*')
 112                 oname++;
 113
 114         while(1) {
 115                 if(name[a]=='[' && oname[a]==0) return 1;
 116                 if(name[a]==0) break;
 117                 if(name[a] != oname[a]) return 0;
 118                 a++;
 119         }
 120         if(name[a]==0 && oname[a] == '.') return 2;
 121         if(name[a]==0 && oname[a] == '-' && oname[a+1] == '>') return 3;
 122
 123         return (name[a] == oname[a]);
 124 }
 125
 126 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
 127 {
 128         char *dnaname;
 129         short *sp;
 130         int a, b, structnr, totmember, cmp;
 131
 132         structnr= DNA_struct_find_nr(sdna, structname);
 133         if(structnr == -1)
 134                 return 0;
 135
 136         sp= sdna->structs[structnr];
 137         totmember= sp[1];
 138         sp+= 2;
 139
 140         for(a=0; a<totmember; a++, sp+=2) {
 141                 dnaname= sdna->names[sp[1]];
 142
 143                 cmp= rna_member_cmp(dnaname, membername);
 144
 145                 if(cmp == 1) {
 146                         smember->type= sdna->types[sp[0]];
 147                         smember->name= dnaname;
 148                         smember->arraylength= DNA_elem_array_size(smember->name, strlen(smember->name));
 149
 150                         smember->pointerlevel= 0;
 151                         for(b=0; dnaname[b] == '*'; b++)
 152                                 smember->pointerlevel++;
 153
 154                         return 1;
 155                 }
 156                 else if(cmp == 2) {
 157                         membername= strstr(membername, ".") + strlen(".");
 158                         return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 159                 }
 160                 else if(cmp == 3) {
 161                         membername= strstr(membername, "->") + strlen("->");
 162                         return rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 163                 }
 164         }
 165
 166         return 0;
 167 }
 168
 169 static int rna_validate_identifier(const char *identifier, char *error, int property)
 170 {
 171         int a=0;
 172
 173         /*  list from http://docs.python.org/reference/lexical_analysis.html#id5 */
 174         static char *kwlist[] = {
 175                 "and", "as", "assert", "break",
 176                 "class", "continue", "def", "del",
 177                 "elif", "else", "except", "exec",
 178                 "finally", "for", "from", "global",
 179                 "if", "import", "in", "is",
 180                 "lambda", "not", "or", "pass",
 181                 "print", "raise", "return", "try",
 182                 "while", "with", "yield", NULL
 183         };
 184
 185
 186         if (!isalpha(identifier[0])) {
 187                 strcpy(error, "first character failed isalpha() check");
 188                 return 0;
 189         }
 190
 191         for(a=0; identifier[a]; a++) {
 192                 if(DefRNA.preprocess && property) {
 193                         if(isalpha(identifier[a]) && isupper(identifier[a])) {
 194                                 strcpy(error, "property names must contain lower case characters only");
 195                                 return 0;
 196                         }
 197                 }
 198
 199                 if (identifier[a]=='_') {
 200                         continue;
 201                 }
 202
 203                 if (identifier[a]==' ') {
 204                         strcpy(error, "spaces are not ok in identifier names");
 205                         return 0;
 206                 }
 207
 208                 if (isalnum(identifier[a])==0) {
 209                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
 210                         return 0;
 211                 }
 212         }
 213
 214         for(a=0; kwlist[a]; a++) {
 215                 if (strcmp(identifier, kwlist[a]) == 0) {
 216                         strcpy(error, "this keyword is reserved by python");
 217                         return 0;
 218                 }
 219         }
 220
 221         return 1;
 222 }
 223
 224 /* Blender Data Definition */
 225
 226 BlenderRNA *RNA_create()
 227 {
 228         BlenderRNA *brna;
 229
 230         brna= MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
 231
 232         DefRNA.sdna= DNA_sdna_from_data(DNAstr,  DNAlen, 0);
 233         DefRNA.structs.first= DefRNA.structs.last= NULL;
 234         DefRNA.error= 0;
 235         DefRNA.preprocess= 1;
 236
 237         return brna;
 238 }
 239
 240 void RNA_define_free(BlenderRNA *brna)
 241 {
 242         StructDefRNA *srna;
 243         AllocDefRNA *alloc;
 244
 245         for(alloc=DefRNA.allocs.first; alloc; alloc=alloc->next)
 246                 MEM_freeN(alloc->mem);
 247         rna_freelistN(&DefRNA.allocs);
 248
 249         for(srna=DefRNA.structs.first; srna; srna=srna->next)
 250                 rna_freelistN(&srna->properties);
 251
 252         rna_freelistN(&DefRNA.structs);
 253
 254         if(DefRNA.sdna) {
 255                 DNA_sdna_free(DefRNA.sdna);
 256                 DefRNA.sdna= NULL;
 257         }
 258
 259         DefRNA.error= 0;
 260 }
 261
 262 void RNA_free(BlenderRNA *brna)
 263 {
 264         StructRNA *srna, *nextsrna;
 265         PropertyRNA *prop, *nextprop;
 266
 267         if(DefRNA.preprocess) {
 268                 RNA_define_free(brna);
 269
 270                 for(srna=brna->structs.first; srna; srna=srna->next)
 271                         rna_freelistN(&srna->properties);
 272
 273                 rna_freelistN(&brna->structs);
 274
 275                 MEM_freeN(brna);
 276         }
 277         else {
 278                 for(srna=brna->structs.first; srna; srna=nextsrna) {
 279                         nextsrna= srna->next;
 280
 281                         for(prop=srna->properties.first; prop; prop=nextprop) {
 282                                 nextprop= prop->next;
 283
 284                                 if(prop->flag & PROP_RUNTIME)
 285                                         rna_freelinkN(&srna->properties, prop);
 286                         }
 287
 288                         if(srna->flag & STRUCT_RUNTIME)
 289                                 rna_freelinkN(&brna->structs, srna);
 290                 }
 291         }
 292 }
 293
 294 static size_t rna_property_type_sizeof(PropertyType type)
 295 {
 296         switch(type) {
 297                 case PROP_BOOLEAN: return sizeof(BooleanPropertyRNA);
 298                 case PROP_INT: return sizeof(IntPropertyRNA);
 299                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
 300                 case PROP_STRING: return sizeof(StringPropertyRNA);
 301                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
 302                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
 303                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
 304                 default: return 0;
 305         }
 306 }
 307
 308 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
 309 {
 310         StructDefRNA *ds;
 311
 312         for(ds=DefRNA.structs.first; ds; ds=ds->next)
 313                 if(ds->srna == srna)
 314                         return ds;
 315
 316         return NULL;
 317 }
 318
 319 /* Struct Definition */
 320
 321 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
 322 {
 323         StructRNA *srna, *srnafrom= NULL;
 324         StructDefRNA *ds= NULL, *dsfrom= NULL;
 325         PropertyRNA *prop;
 326
 327         if(DefRNA.preprocess) {
 328                 char error[512];
 329
 330                 if (rna_validate_identifier(identifier, error, 0) == 0) {
 331                         fprintf(stderr, "RNA_def_struct: struct identifier \"%s\" error - %s\n", identifier, error);
 332                         DefRNA.error= 1;
 333                 }
 334         }
 335
 336         if(from) {
 337                 /* find struct to derive from */
 338                 for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
 339                         if(strcmp(srnafrom->identifier, from) == 0)
 340                                 break;
 341
 342                 if(!srnafrom) {
 343                         fprintf(stderr, "RNA_def_struct: struct %s not found to define %s.\n", from, identifier);
 344                         DefRNA.error= 1;
 345                 }
 346         }
 347
 348         srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
 349         DefRNA.laststruct= srna;
 350
 351         if(srnafrom) {
 352                 /* copy from struct to derive stuff, a bit clumsy since we can't
 353                  * use MEM_dupallocN, data structs may not be alloced but builtin */
 354                 memcpy(srna, srnafrom, sizeof(StructRNA));
 355                 srna->properties.first= srna->properties.last= NULL;
 356
 357                 if(DefRNA.preprocess) {
 358                         srna->base= srnafrom;
 359                         dsfrom= rna_find_def_struct(srnafrom);
 360                 }
 361                 else
 362                         srna->base= srnafrom;
 363         }
 364
 365         srna->identifier= identifier;
 366         srna->name= identifier; /* may be overwritten later RNA_def_struct_ui_text */
 367         srna->description= "";
 368
 369         rna_addtail(&brna->structs, srna);
 370
 371         if(DefRNA.preprocess) {
 372                 ds= MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
 373                 ds->srna= srna;
 374                 rna_addtail(&DefRNA.structs, ds);
 375
 376                 if(dsfrom)
 377                         ds->dnafromname= dsfrom->dnaname;
 378         }
 379
 380         /* in preprocess, try to find sdna */
 381         if(DefRNA.preprocess)
 382                 RNA_def_struct_sdna(srna, srna->identifier);
 383         else
 384                 srna->flag |= STRUCT_RUNTIME;
 385
 386         if(srnafrom) {
 387                 srna->nameproperty= srnafrom->nameproperty;
 388                 srna->iteratorproperty= srnafrom->iteratorproperty;
 389         }
 390         else {
 391                 /* define some builtin properties */
 392                 prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE);
 393                 RNA_def_property_flag(prop, PROP_BUILTIN);
 394                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection.");
 395
 396                 if(DefRNA.preprocess) {
 397                         RNA_def_property_struct_type(prop, "Property");
 398                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", 0, 0, 0);
 399                 }
 400                 else {
 401 #ifdef RNA_RUNTIME
 402                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 403                         cprop->begin= rna_builtin_properties_begin;
 404                         cprop->next= rna_builtin_properties_next;
 405                         cprop->get= rna_builtin_properties_get;
 406                         cprop->type= &RNA_Property;
 407 #endif
 408                 }
 409
 410                 prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
 411                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition.");
 412
 413                 if(DefRNA.preprocess) {
 414                         RNA_def_property_struct_type(prop, "Struct");
 415                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL);
 416                 }
 417                 else {
 418 #ifdef RNA_RUNTIME
 419                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 420                         pprop->get= rna_builtin_type_get;
 421                         pprop->type= &RNA_Struct;
 422 #endif
 423                 }
 424         }
 425
 426         return srna;
 427 }
 428
 429 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
 430 {
 431         StructDefRNA *ds= DefRNA.structs.last;
 432
 433         if(!DefRNA.preprocess) {
 434                 fprintf(stderr, "RNA_def_struct_sdna: only during preprocessing.\n");
 435                 return;
 436         }
 437
 438         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
 439                 if(!DefRNA.silent) {
 440                         fprintf(stderr, "RNA_def_struct_sdna: %s not found.\n", structname);
 441                         DefRNA.error= 1;
 442                 }
 443                 return;
 444         }
 445
 446         ds->dnaname= structname;
 447 }
 448
 449 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
 450 {
 451         StructDefRNA *ds= DefRNA.structs.last;
 452
 453         if(!DefRNA.preprocess) {
 454                 fprintf(stderr, "RNA_def_struct_sdna_from: only during preprocessing.\n");
 455                 return;
 456         }
 457
 458         if(!ds->dnaname) {
 459                 fprintf(stderr, "RNA_def_struct_sdna_from: %s base struct must know DNA already.\n", structname);
 460                 return;
 461         }
 462
 463         if(!DNA_struct_find_nr(DefRNA.sdna, structname)) {
 464                 if(!DefRNA.silent) {
 465                         fprintf(stderr, "RNA_def_struct_sdna_from: %s not found.\n", structname);
 466                         DefRNA.error= 1;
 467                 }
 468                 return;
 469         }
 470
 471         ds->dnafromprop= propname;
 472         ds->dnaname= structname;
 473 }
 474
 475 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 476 {
 477         if(prop->type != PROP_STRING) {
 478                 fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
 479                 DefRNA.error= 1;
 480         }
 481         else
 482                 srna->nameproperty= prop;
 483 }
 484
 485 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
 486 {
 487         StructRNA *srnafrom;
 488
 489         /* find struct to derive from */
 490         for(srnafrom= brna->structs.first; srnafrom; srnafrom=srnafrom->next)
 491                 if(strcmp(srnafrom->identifier, structname) == 0)
 492                         break;
 493
 494         if(!srnafrom) {
 495                 fprintf(stderr, "RNA_def_struct_nested: struct %s not found.\n", structname);
 496                 DefRNA.error= 1;
 497         }
 498
 499         srna->nested= srnafrom;
 500 }
 501
 502 void RNA_def_struct_flag(StructRNA *srna, int flag)
 503 {
 504         srna->flag= flag;
 505 }
 506
 507 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
 508 {
 509         if(!DefRNA.preprocess) {
 510                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
 511                 return;
 512         }
 513
 514         if(refine) srna->refine= (StructRefineFunc)refine;
 515 }
 516
 517 void RNA_def_struct_identifier(StructRNA *srna, const char *identifier)
 518 {
 519         if(DefRNA.preprocess) {
 520                 fprintf(stderr, "RNA_def_struct_name_runtime: only at runtime.\n");
 521                 return;
 522         }
 523
 524         srna->identifier= identifier;
 525 }
 526
 527 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
 528 {
 529         srna->name= name;
 530         srna->description= description;
 531 }
 532
 533 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
 534 {
 535         rna_freelistN(&srna->properties);
 536         rna_freelinkN(&brna->structs, srna);
 537 }
 538
 539 /* Property Definition */
 540
 541 PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype)
 542 {
 543         StructDefRNA *ds;
 544         PropertyDefRNA *dp= NULL;
 545         PropertyRNA *prop;
 546
 547         if(DefRNA.preprocess) {
 548                 char error[512];
 549
 550                 if (rna_validate_identifier(identifier, error, 1) == 0) {
 551                         fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
 552                         DefRNA.error= 1;
 553                 }
 554
 555                 ds= DefRNA.structs.last;
 556                 dp= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
 557                 rna_addtail(&ds->properties, dp);
 558         }
 559
 560         prop= MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
 561
 562         switch(type) {
 563                 case PROP_BOOLEAN:
 564                         break;
 565                 case PROP_INT: {
 566                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 567
 568                         iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN;
 569                         iprop->hardmax= INT_MAX;
 570
 571                         iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
 572                         iprop->softmax= 10000;
 573                         iprop->step= 1;
 574                         break;
 575                 }
 576                 case PROP_FLOAT: {
 577                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 578
 579                         fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
 580                         fprop->hardmax= FLT_MAX;
 581
 582                         if(subtype == PROP_COLOR) {
 583                                 fprop->softmin= 0.0f;
 584                                 fprop->softmax= 1.0f;
 585                         }
 586                         else if(subtype == PROP_PERCENTAGE) {
 587                                 fprop->softmin= fprop->hardmin= 0.0f;
 588                                 fprop->softmax= fprop->hardmax= 1.0f;
 589                         }
 590                         else {
 591                                 fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
 592                                 fprop->softmax= 10000.0f;
 593                         }
 594                         fprop->step= 10;
 595                         fprop->precision= 3;
 596                         break;
 597                 }
 598                 case PROP_STRING: {
 599                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 600
 601                         sprop->defaultvalue= "";
 602                         sprop->maxlength= 0;
 603                         break;
 604                 }
 605                 case PROP_ENUM:
 606                 case PROP_POINTER:
 607                 case PROP_COLLECTION:
 608                         break;
 609                 default:
 610                         fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
 611                         DefRNA.error= 1;
 612                         return NULL;
 613         }
 614
 615         if(DefRNA.preprocess) {
 616                 dp->srna= srna;
 617                 dp->prop= prop;
 618         }
 619
 620         prop->magic= RNA_MAGIC;
 621         prop->identifier= identifier;
 622         prop->type= type;
 623         prop->subtype= subtype;
 624         prop->name= identifier;
 625         prop->description= "";
 626
 627         if(type != PROP_COLLECTION && type != PROP_POINTER)
 628                 prop->flag= PROP_EDITABLE|PROP_ANIMATEABLE;
 629
 630         if(DefRNA.preprocess) {
 631                 switch(type) {
 632                         case PROP_BOOLEAN:
 633                                 DefRNA.silent= 1;
 634                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
 635                                 DefRNA.silent= 0;
 636                                 break;
 637                         case PROP_INT: {
 638                                 DefRNA.silent= 1;
 639                                 RNA_def_property_int_sdna(prop, NULL, identifier);
 640                                 DefRNA.silent= 0;
 641                                 break;
 642                         }
 643                         case PROP_FLOAT: {
 644                                 DefRNA.silent= 1;
 645                                 RNA_def_property_float_sdna(prop, NULL, identifier);
 646                                 DefRNA.silent= 0;
 647                                 break;
 648                         }
 649                         case PROP_STRING: {
 650                                 DefRNA.silent= 1;
 651                                 RNA_def_property_string_sdna(prop, NULL, identifier);
 652                                 DefRNA.silent= 0;
 653                                 break;
 654                         }
 655                         case PROP_ENUM:
 656                                 DefRNA.silent= 1;
 657                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
 658                                 DefRNA.silent= 0;
 659                                 break;
 660                         case PROP_POINTER:
 661                                 DefRNA.silent= 1;
 662                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
 663                                 DefRNA.silent= 0;
 664                                 break;
 665                         case PROP_COLLECTION:
 666                                 DefRNA.silent= 1;
 667                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
 668                                 DefRNA.silent= 0;
 669                                 break;
 670                 }
 671         }
 672         else
 673                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
 674
 675         rna_addtail(&srna->properties, prop);
 676
 677         return prop;
 678 }
 679
 680 void RNA_def_property_flag(PropertyRNA *prop, int flag)
 681 {
 682         prop->flag |= flag;
 683 }
 684
 685 void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
 686 {
 687         prop->flag &= ~flag;
 688 }
 689
 690 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
 691 {
 692         StructRNA *srna= DefRNA.laststruct;
 693
 694         if(arraylength<0) {
 695                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be zero of greater.\n", srna->identifier, prop->identifier);
 696                 DefRNA.error= 1;
 697                 return;
 698         }
 699
 700         if(arraylength>RNA_MAX_ARRAY) {
 701                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY);
 702                 DefRNA.error= 1;
 703                 return;
 704         }
 705
 706         switch(prop->type) {
 707                 case PROP_BOOLEAN:
 708                 case PROP_INT:
 709                 case PROP_FLOAT:
 710                         prop->arraylength= arraylength;
 711                         break;
 712                 default:
 713                         fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
 714                         DefRNA.error= 1;
 715                         break;
 716         }
 717 }
 718
 719 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
 720 {
 721         prop->name= name;
 722         prop->description= description;
 723 }
 724
 725 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
 726 {
 727         StructRNA *srna= DefRNA.laststruct;
 728
 729         switch(prop->type) {
 730                 case PROP_INT: {
 731                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 732                         iprop->softmin= (int)min;
 733                         iprop->softmax= (int)max;
 734                         iprop->step= (int)step;
 735                         break;
 736                 }
 737                 case PROP_FLOAT: {
 738                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 739                         fprop->softmin= (float)min;
 740                         fprop->softmax= (float)max;
 741                         fprop->step= (float)step;
 742                         fprop->precision= (int)precision;
 743                         break;
 744                 }
 745                 default:
 746                         fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
 747                         DefRNA.error= 1;
 748                         break;
 749         }
 750 }
 751
 752 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
 753 {
 754         StructRNA *srna= DefRNA.laststruct;
 755
 756         switch(prop->type) {
 757                 case PROP_INT: {
 758                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 759                         iprop->hardmin= (int)min;
 760                         iprop->hardmax= (int)max;
 761                         iprop->softmin= MAX2((int)min, iprop->hardmin);
 762                         iprop->softmax= MIN2((int)max, iprop->hardmax);
 763                         break;
 764                 }
 765                 case PROP_FLOAT: {
 766                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 767                         fprop->hardmin= (float)min;
 768                         fprop->hardmax= (float)max;
 769                         fprop->softmin= MAX2((float)min, fprop->hardmin);
 770                         fprop->softmax= MIN2((float)max, fprop->hardmax);
 771                         break;
 772                 }
 773                 default:
 774                         fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
 775                         DefRNA.error= 1;
 776                         break;
 777         }
 778 }
 779
 780 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
 781 {
 782         StructRNA *srna= DefRNA.laststruct;
 783
 784         if(!DefRNA.preprocess) {
 785                 fprintf(stderr, "RNA_def_property_struct_type: only during preprocessing.\n");
 786                 return;
 787         }
 788
 789         switch(prop->type) {
 790                 case PROP_POINTER: {
 791                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 792                         pprop->type = (StructRNA*)type;
 793                         break;
 794                 }
 795                 case PROP_COLLECTION: {
 796                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 797                         cprop->type = (StructRNA*)type;
 798                         break;
 799                 }
 800                 default:
 801                         fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 802                         DefRNA.error= 1;
 803                         break;
 804         }
 805 }
 806
 807 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
 808 {
 809         StructRNA *srna= DefRNA.laststruct;
 810
 811         if(DefRNA.preprocess) {
 812                 fprintf(stderr, "RNA_def_property_struct_runtime: only at runtime.\n");
 813                 return;
 814         }
 815
 816         switch(prop->type) {
 817                 case PROP_POINTER: {
 818                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 819                         pprop->type = type;
 820                         break;
 821                 }
 822                 case PROP_COLLECTION: {
 823                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 824                         cprop->type = type;
 825                         break;
 826                 }
 827                 default:
 828                         fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 829                         DefRNA.error= 1;
 830                         break;
 831         }
 832 }
 833
 834 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
 835 {
 836         StructRNA *srna= DefRNA.laststruct;
 837         int i, defaultfound= 0;
 838
 839         switch(prop->type) {
 840                 case PROP_ENUM: {
 841                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 842                         eprop->item= item;
 843                         eprop->totitem= 0;
 844                         for(i=0; item[i].identifier; i++) {
 845                                 eprop->totitem++;
 846
 847                                 if(item[i].value == eprop->defaultvalue)
 848                                         defaultfound= 1;
 849                         }
 850
 851                         if(!defaultfound)
 852                                 eprop->defaultvalue= item[0].value;
 853
 854                         break;
 855                 }
 856                 default:
 857                         fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 858                         DefRNA.error= 1;
 859                         break;
 860         }
 861 }
 862
 863 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
 864 {
 865         StructRNA *srna= DefRNA.laststruct;
 866
 867         switch(prop->type) {
 868                 case PROP_STRING: {
 869                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 870                         sprop->maxlength= maxlength;
 871                         break;
 872                 }
 873                 default:
 874                         fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
 875                         DefRNA.error= 1;
 876                         break;
 877         }
 878 }
 879
 880 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
 881 {
 882         StructRNA *srna= DefRNA.laststruct;
 883
 884         switch(prop->type) {
 885                 case PROP_BOOLEAN: {
 886                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 887                         bprop->defaultvalue= value;
 888                         break;
 889                 }
 890                 default:
 891                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
 892                         DefRNA.error= 1;
 893                         break;
 894         }
 895 }
 896
 897 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
 898 {
 899         StructRNA *srna= DefRNA.laststruct;
 900
 901         switch(prop->type) {
 902                 case PROP_BOOLEAN: {
 903                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 904                         bprop->defaultarray= array;
 905                         break;
 906                 }
 907                 default:
 908                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
 909                         DefRNA.error= 1;
 910                         break;
 911         }
 912 }
 913
 914 void RNA_def_property_int_default(PropertyRNA *prop, int value)
 915 {
 916         StructRNA *srna= DefRNA.laststruct;
 917
 918         switch(prop->type) {
 919                 case PROP_INT: {
 920                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 921                         iprop->defaultvalue= value;
 922                         break;
 923                 }
 924                 default:
 925                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
 926                         DefRNA.error= 1;
 927                         break;
 928         }
 929 }
 930
 931 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
 932 {
 933         StructRNA *srna= DefRNA.laststruct;
 934
 935         switch(prop->type) {
 936                 case PROP_INT: {
 937                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 938                         iprop->defaultarray= array;
 939                         break;
 940                 }
 941                 default:
 942                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
 943                         DefRNA.error= 1;
 944                         break;
 945         }
 946 }
 947
 948 void RNA_def_property_float_default(PropertyRNA *prop, float value)
 949 {
 950         StructRNA *srna= DefRNA.laststruct;
 951
 952         switch(prop->type) {
 953                 case PROP_FLOAT: {
 954                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 955                         fprop->defaultvalue= value;
 956                         break;
 957                 }
 958                 default:
 959                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
 960                         DefRNA.error= 1;
 961                         break;
 962         }
 963 }
 964 /* array must remain valid after this function finishes */
 965 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
 966 {
 967         StructRNA *srna= DefRNA.laststruct;
 968
 969         switch(prop->type) {
 970                 case PROP_FLOAT: {
 971                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 972                         fprop->defaultarray= array; /* WARNING, this array must not come from the stack and lost */
 973                         break;
 974                 }
 975                 default:
 976                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
 977                         DefRNA.error= 1;
 978                         break;
 979         }
 980 }
 981
 982 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
 983 {
 984         StructRNA *srna= DefRNA.laststruct;
 985
 986         switch(prop->type) {
 987                 case PROP_STRING: {
 988                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 989                         sprop->defaultvalue= value;
 990                         break;
 991                 }
 992                 default:
 993                         fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
 994                         DefRNA.error= 1;
 995                         break;
 996         }
 997 }
 998
 999 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1000 {
1001         StructRNA *srna= DefRNA.laststruct;
1002         int i, defaultfound= 0;
1003
1004         switch(prop->type) {
1005                 case PROP_ENUM: {
1006                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1007                         eprop->defaultvalue= value;
1008
1009                         for(i=0; i<eprop->totitem; i++) {
1010                                 if(eprop->item[i].value == eprop->defaultvalue)
1011                                         defaultfound= 1;
1012                         }
1013
1014                         if(!defaultfound && eprop->totitem) {
1015                                 if(value == 0) {
1016                                         eprop->defaultvalue= eprop->item[0].value;
1017                                 }
1018                                 else {
1019                                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, default is not in items.\n", srna->identifier, prop->identifier);
1020                                         DefRNA.error= 1;
1021                                 }
1022                         }
1023
1024                         break;
1025                 }
1026                 default:
1027                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1028                         DefRNA.error= 1;
1029                         break;
1030         }
1031 }
1032
1033 /* SDNA */
1034
1035 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1036 {
1037         DNAStructMember smember;
1038         StructDefRNA *ds= DefRNA.structs.last;
1039         PropertyDefRNA *dp= ds->properties.last;
1040
1041         if(!structname)
1042                 structname= ds->dnaname;
1043         if(!propname)
1044                 propname= prop->identifier;
1045
1046         if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1047                 if(!DefRNA.silent) {
1048                         fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
1049                         DefRNA.error= 1;
1050                 }
1051                 return NULL;
1052         }
1053
1054         if(smember.arraylength > 1)
1055                 prop->arraylength= smember.arraylength;
1056         else
1057                 prop->arraylength= 0;
1058
1059         dp->dnastructname= structname;
1060         dp->dnastructfromname= ds->dnafromname;
1061         dp->dnastructfromprop= ds->dnafromprop;
1062         dp->dnaname= propname;
1063         dp->dnatype= smember.type;
1064         dp->dnaarraylength= smember.arraylength;
1065         dp->dnapointerlevel= smember.pointerlevel;
1066
1067         return dp;
1068 }
1069
1070 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1071 {
1072         PropertyDefRNA *dp;
1073         StructRNA *srna= DefRNA.laststruct;
1074
1075         if(!DefRNA.preprocess) {
1076                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1077                 return;
1078         }
1079
1080         if(prop->type != PROP_BOOLEAN) {
1081                 fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1082                 DefRNA.error= 1;
1083                 return;
1084         }
1085
1086         if((dp=rna_def_property_sdna(prop, structname, propname)))
1087                 dp->booleanbit= bit;
1088 }
1089
1090 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
1091 {
1092         StructDefRNA *ds;
1093         PropertyDefRNA *dp;
1094
1095         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1096
1097         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1098                 dp->booleannegative= 1;
1099 }
1100
1101 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1102 {
1103         PropertyDefRNA *dp;
1104         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1105         StructRNA *srna= DefRNA.laststruct;
1106
1107         if(!DefRNA.preprocess) {
1108                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1109                 return;
1110         }
1111
1112         if(prop->type != PROP_INT) {
1113                 fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1114                 DefRNA.error= 1;
1115                 return;
1116         }
1117
1118         if((dp= rna_def_property_sdna(prop, structname, propname))) {
1119                 /* SDNA doesn't pass us unsigned unfortunately .. */
1120                 if(strcmp(dp->dnatype, "char") == 0) {
1121                         iprop->hardmin= iprop->softmin= CHAR_MIN;
1122                         iprop->hardmax= iprop->softmax= CHAR_MAX;
1123                 }
1124                 else if(strcmp(dp->dnatype, "short") == 0) {
1125                         iprop->hardmin= iprop->softmin= SHRT_MIN;
1126                         iprop->hardmax= iprop->softmax= SHRT_MAX;
1127                 }
1128                 else if(strcmp(dp->dnatype, "int") == 0) {
1129                         iprop->hardmin= INT_MIN;
1130                         iprop->hardmax= INT_MAX;
1131
1132                         iprop->softmin= -10000; /* rather arbitrary .. */
1133                         iprop->softmax= 10000;
1134                 }
1135
1136                 if(prop->subtype == PROP_UNSIGNED)
1137                         iprop->hardmin= iprop->softmin= 0;
1138         }
1139 }
1140
1141 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1142 {
1143         StructRNA *srna= DefRNA.laststruct;
1144
1145         if(!DefRNA.preprocess) {
1146                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1147                 return;
1148         }
1149
1150         if(prop->type != PROP_FLOAT) {
1151                 fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1152                 DefRNA.error= 1;
1153                 return;
1154         }
1155
1156         rna_def_property_sdna(prop, structname, propname);
1157 }
1158
1159 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1160 {
1161         PropertyDefRNA *dp;
1162         StructRNA *srna= DefRNA.laststruct;
1163
1164         if(!DefRNA.preprocess) {
1165                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1166                 return;
1167         }
1168
1169         if(prop->type != PROP_ENUM) {
1170                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1171                 DefRNA.error= 1;
1172                 return;
1173         }
1174
1175         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1176                 if(prop->arraylength) {
1177                         prop->arraylength= 0;
1178                         if(!DefRNA.silent) {
1179                                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
1180                                 DefRNA.error= 1;
1181                         }
1182                 }
1183         }
1184 }
1185
1186 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1187 {
1188         StructDefRNA *ds;
1189         PropertyDefRNA *dp;
1190
1191         RNA_def_property_enum_sdna(prop, structname, propname);
1192
1193         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1194                 dp->enumbitflags= 1;
1195 }
1196
1197 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1198 {
1199         PropertyDefRNA *dp;
1200         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1201         StructRNA *srna= DefRNA.laststruct;
1202
1203         if(!DefRNA.preprocess) {
1204                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1205                 return;
1206         }
1207
1208         if(prop->type != PROP_STRING) {
1209                 fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1210                 DefRNA.error= 1;
1211                 return;
1212         }
1213
1214         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1215                 if(prop->arraylength) {
1216                         sprop->maxlength= prop->arraylength;
1217                         prop->arraylength= 0;
1218                 }
1219         }
1220 }
1221
1222 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1223 {
1224         PropertyDefRNA *dp;
1225         StructRNA *srna= DefRNA.laststruct;
1226
1227         if(!DefRNA.preprocess) {
1228                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1229                 return;
1230         }
1231
1232         if(prop->type != PROP_POINTER) {
1233                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1234                 DefRNA.error= 1;
1235                 return;
1236         }
1237
1238         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1239                 if(prop->arraylength) {
1240                         prop->arraylength= 0;
1241                         if(!DefRNA.silent) {
1242                                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
1243                                 DefRNA.error= 1;
1244                         }
1245                 }
1246         }
1247 }
1248
1249 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
1250 {
1251         PropertyDefRNA *dp;
1252         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1253         StructRNA *srna= DefRNA.laststruct;
1254
1255         if(!DefRNA.preprocess) {
1256                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1257                 return;
1258         }
1259
1260         if(prop->type != PROP_COLLECTION) {
1261                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1262                 DefRNA.error= 1;
1263                 return;
1264         }
1265
1266         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1267                 if(prop->arraylength && !lengthpropname) {
1268                         prop->arraylength= 0;
1269
1270                         if(!DefRNA.silent) {
1271                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
1272                                 DefRNA.error= 1;
1273                         }
1274                 }
1275
1276                 if(strcmp(dp->dnatype, "ListBase") == 0) {
1277                         cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next";
1278                         cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
1279                         cprop->end= (PropCollectionEndFunc)"rna_iterator_listbase_end";
1280                 }
1281         }
1282
1283         if(dp && lengthpropname) {
1284                 DNAStructMember smember;
1285                 StructDefRNA *ds= DefRNA.structs.last;
1286
1287                 if(!structname)
1288                         structname= ds->dnaname;
1289
1290                 if(lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1291                         if(lengthpropname[0] == 0) {
1292                                 dp->dnalengthfixed= prop->arraylength;
1293                                 prop->arraylength= 0;
1294                         }
1295                         else {
1296                                 dp->dnalengthstructname= structname;
1297                                 dp->dnalengthname= lengthpropname;
1298                         }
1299
1300                         cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
1301                         cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
1302
1303                         if(dp->dnapointerlevel >= 2)
1304                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1305                         else
1306                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
1307                 }
1308                 else {
1309                         if(!DefRNA.silent) {
1310                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
1311                                 DefRNA.error= 1;
1312                         }
1313                 }
1314         }
1315 }
1316
1317 /* Functions */
1318
1319 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1320 {
1321         if(!DefRNA.preprocess) {
1322                 fprintf(stderr, "RNA_def_property_editable_func: only during preprocessing.\n");
1323                 return;
1324         }
1325
1326         if(editable) prop->editable= (EditableFunc)editable;
1327 }
1328
1329 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1330 {
1331         if(!DefRNA.preprocess) {
1332                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
1333                 return;
1334         }
1335
1336         prop->noteflag= noteflag;
1337         prop->update= (UpdateFunc)func;
1338 }
1339
1340 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1341 {
1342         StructRNA *srna= DefRNA.laststruct;
1343
1344         if(!DefRNA.preprocess) {
1345                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1346                 return;
1347         }
1348
1349         switch(prop->type) {
1350                 case PROP_BOOLEAN: {
1351                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1352
1353                         if(prop->arraylength) {
1354                                 if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
1355                                 if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
1356                         }
1357                         else {
1358                                 if(get) bprop->get= (PropBooleanGetFunc)get;
1359                                 if(set) bprop->set= (PropBooleanSetFunc)set;
1360                         }
1361                         break;
1362                 }
1363                 default:
1364                         fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1365                         DefRNA.error= 1;
1366                         break;
1367         }
1368 }
1369
1370 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1371 {
1372         StructRNA *srna= DefRNA.laststruct;
1373
1374         if(!DefRNA.preprocess) {
1375                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1376                 return;
1377         }
1378
1379         switch(prop->type) {
1380                 case PROP_INT: {
1381                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1382
1383                         if(prop->arraylength) {
1384                                 if(get) iprop->getarray= (PropIntArrayGetFunc)get;
1385                                 if(set) iprop->setarray= (PropIntArraySetFunc)set;
1386                         }
1387                         else {
1388                                 if(get) iprop->get= (PropIntGetFunc)get;
1389                                 if(set) iprop->set= (PropIntSetFunc)set;
1390                         }
1391                         if(range) iprop->range= (PropIntRangeFunc)range;
1392                         break;
1393                 }
1394                 default:
1395                         fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1396                         DefRNA.error= 1;
1397                         break;
1398         }
1399 }
1400
1401 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1402 {
1403         StructRNA *srna= DefRNA.laststruct;
1404
1405         if(!DefRNA.preprocess) {
1406                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1407                 return;
1408         }
1409
1410         switch(prop->type) {
1411                 case PROP_FLOAT: {
1412                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1413
1414                         if(prop->arraylength) {
1415                                 if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
1416                                 if(set) fprop->setarray= (PropFloatArraySetFunc)set;
1417                         }
1418                         else {
1419                                 if(get) fprop->get= (PropFloatGetFunc)get;
1420                                 if(set) fprop->set= (PropFloatSetFunc)set;
1421                         }
1422                         if(range) fprop->range= (PropFloatRangeFunc)range;
1423                         break;
1424                 }
1425                 default:
1426                         fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1427                         DefRNA.error= 1;
1428                         break;
1429         }
1430 }
1431
1432 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
1433 {
1434         StructRNA *srna= DefRNA.laststruct;
1435
1436         if(!DefRNA.preprocess) {
1437                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1438                 return;
1439         }
1440
1441         switch(prop->type) {
1442                 case PROP_ENUM: {
1443                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1444
1445                         if(get) eprop->get= (PropEnumGetFunc)get;
1446                         if(set) eprop->set= (PropEnumSetFunc)set;
1447                         break;
1448                 }
1449                 default:
1450                         fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1451                         DefRNA.error= 1;
1452                         break;
1453         }
1454 }
1455
1456 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
1457 {
1458         StructRNA *srna= DefRNA.laststruct;
1459
1460         if(!DefRNA.preprocess) {
1461                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1462                 return;
1463         }
1464
1465         switch(prop->type) {
1466                 case PROP_STRING: {
1467                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1468
1469                         if(get) sprop->get= (PropStringGetFunc)get;
1470                         if(length) sprop->length= (PropStringLengthFunc)length;
1471                         if(set) sprop->set= (PropStringSetFunc)set;
1472                         break;
1473                 }
1474                 default:
1475                         fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1476                         DefRNA.error= 1;
1477                         break;
1478         }
1479 }
1480
1481 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set)
1482 {
1483         StructRNA *srna= DefRNA.laststruct;
1484
1485         if(!DefRNA.preprocess) {
1486                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1487                 return;
1488         }
1489
1490         switch(prop->type) {
1491                 case PROP_POINTER: {
1492                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1493
1494                         if(get) pprop->get= (PropPointerGetFunc)get;
1495                         if(set) pprop->set= (PropPointerSetFunc)set;
1496                         break;
1497                 }
1498                 default:
1499                         fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1500                         DefRNA.error= 1;
1501                         break;
1502         }
1503 }
1504
1505 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)
1506 {
1507         StructRNA *srna= DefRNA.laststruct;
1508
1509         if(!DefRNA.preprocess) {
1510                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1511                 return;
1512         }
1513
1514         switch(prop->type) {
1515                 case PROP_COLLECTION: {
1516                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1517
1518                         if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
1519                         if(next) cprop->next= (PropCollectionNextFunc)next;
1520                         if(end) cprop->end= (PropCollectionEndFunc)end;
1521                         if(get) cprop->get= (PropCollectionGetFunc)get;
1522                         if(length) cprop->length= (PropCollectionLengthFunc)length;
1523                         if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
1524                         if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
1525                         break;
1526                 }
1527                 default:
1528                         fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1529                         DefRNA.error= 1;
1530                         break;
1531         }
1532 }
1533
1534 /* Compact definitions */
1535
1536 PropertyRNA *RNA_def_boolean(StructRNA *srna, const char *identifier, int default_value,
1537         const char *ui_name, const char *ui_description)
1538 {
1539         PropertyRNA *prop;
1540
1541         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1542         RNA_def_property_boolean_default(prop, default_value);
1543         RNA_def_property_ui_text(prop, ui_name, ui_description);
1544
1545         return prop;
1546 }
1547
1548 PropertyRNA *RNA_def_boolean_array(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1549 {
1550         PropertyRNA *prop;
1551
1552         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1553         if(len != 0) RNA_def_property_array(prop, len);
1554         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1555         RNA_def_property_ui_text(prop, ui_name, ui_description);
1556
1557         return prop;
1558 }
1559
1560 PropertyRNA *RNA_def_boolean_vector(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1561 {
1562         PropertyRNA *prop;
1563
1564         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_VECTOR);
1565         if(len != 0) RNA_def_property_array(prop, len);
1566         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1567         RNA_def_property_ui_text(prop, ui_name, ui_description);
1568
1569         return prop;
1570 }
1571
1572 PropertyRNA *RNA_def_int(StructRNA *srna, const char *identifier, int default_value, int hardmin, int hardmax,
1573         const char *ui_name, const char *ui_description, int softmin, int softmax)
1574 {
1575         PropertyRNA *prop;
1576
1577         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1578         RNA_def_property_int_default(prop, default_value);
1579         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1580         RNA_def_property_ui_text(prop, ui_name, ui_description);
1581         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1582
1583         return prop;
1584 }
1585
1586 PropertyRNA *RNA_def_int_vector(StructRNA *srna, const char *identifier, int len, const int *default_value,
1587         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1588 {
1589         PropertyRNA *prop;
1590
1591         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_VECTOR);
1592         if(len != 0) RNA_def_property_array(prop, len);
1593         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1594         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1595         RNA_def_property_ui_text(prop, ui_name, ui_description);
1596         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1597
1598         return prop;
1599 }
1600
1601 PropertyRNA *RNA_def_int_array(StructRNA *srna, const char *identifier, int len, const int *default_value,
1602         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1603 {
1604         PropertyRNA *prop;
1605
1606         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1607         if(len != 0) RNA_def_property_array(prop, len);
1608         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1609         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1610         RNA_def_property_ui_text(prop, ui_name, ui_description);
1611         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1612
1613         return prop;
1614 }
1615
1616 PropertyRNA *RNA_def_string(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1617         const char *ui_name, const char *ui_description)
1618 {
1619         PropertyRNA *prop;
1620
1621         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_NONE);
1622         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1623         if(default_value) RNA_def_property_string_default(prop, default_value);
1624         RNA_def_property_ui_text(prop, ui_name, ui_description);
1625
1626         return prop;
1627 }
1628
1629 PropertyRNA *RNA_def_string_file_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1630         const char *ui_name, const char *ui_description)
1631 {
1632         PropertyRNA *prop;
1633
1634         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_FILEPATH);
1635         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1636         if(default_value) RNA_def_property_string_default(prop, default_value);
1637         RNA_def_property_ui_text(prop, ui_name, ui_description);
1638
1639         return prop;
1640 }
1641
1642 PropertyRNA *RNA_def_string_dir_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1643         const char *ui_name, const char *ui_description)
1644 {
1645         PropertyRNA *prop;
1646
1647         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_DIRPATH);
1648         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1649         if(default_value) RNA_def_property_string_default(prop, default_value);
1650         RNA_def_property_ui_text(prop, ui_name, ui_description);
1651
1652         return prop;
1653 }
1654
1655 PropertyRNA *RNA_def_enum(StructRNA *srna, const char *identifier, EnumPropertyItem *items, int default_value,
1656         const char *ui_name, const char *ui_description)
1657 {
1658         PropertyRNA *prop;
1659
1660         prop= RNA_def_property(srna, identifier, PROP_ENUM, PROP_NONE);
1661         if(items) RNA_def_property_enum_items(prop, items);
1662         RNA_def_property_enum_default(prop, default_value);
1663         RNA_def_property_ui_text(prop, ui_name, ui_description);
1664
1665         return prop;
1666 }
1667
1668 PropertyRNA *RNA_def_float(StructRNA *srna, const char *identifier, float default_value,
1669         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1670 {
1671         PropertyRNA *prop;
1672
1673         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1674         RNA_def_property_float_default(prop, default_value);
1675         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1676         RNA_def_property_ui_text(prop, ui_name, ui_description);
1677         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1678
1679         return prop;
1680 }
1681
1682 PropertyRNA *RNA_def_float_vector(StructRNA *srna, const char *identifier, int len, const float *default_value,
1683         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1684 {
1685         PropertyRNA *prop;
1686
1687         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_VECTOR);
1688         if(len != 0) RNA_def_property_array(prop, len);
1689         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1690         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1691         RNA_def_property_ui_text(prop, ui_name, ui_description);
1692         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1693
1694         return prop;
1695 }
1696
1697 PropertyRNA *RNA_def_float_color(StructRNA *srna, const char *identifier, int len, const float *default_value,
1698         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1699 {
1700         PropertyRNA *prop;
1701
1702         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_COLOR);
1703         if(len != 0) RNA_def_property_array(prop, len);
1704         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1705         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1706         RNA_def_property_ui_text(prop, ui_name, ui_description);
1707         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1708
1709         return prop;
1710 }
1711
1712
1713 PropertyRNA *RNA_def_float_matrix(StructRNA *srna, const char *identifier, int len, const float *default_value,
1714         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1715 {
1716         PropertyRNA *prop;
1717
1718         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_MATRIX);
1719         if(len != 0) RNA_def_property_array(prop, len);
1720         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1721         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1722         RNA_def_property_ui_text(prop, ui_name, ui_description);
1723         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1724
1725         return prop;
1726 }
1727
1728 PropertyRNA *RNA_def_float_rotation(StructRNA *srna, const char *identifier, int len, const float *default_value,
1729         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1730 {
1731         PropertyRNA *prop;
1732
1733         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_ROTATION);
1734         if(len != 0) RNA_def_property_array(prop, len);
1735         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1736         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1737         RNA_def_property_ui_text(prop, ui_name, ui_description);
1738         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1739
1740         return prop;
1741 }
1742
1743 PropertyRNA *RNA_def_float_array(StructRNA *srna, const char *identifier, int len, const float *default_value,
1744         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1745 {
1746         PropertyRNA *prop;
1747
1748         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1749         if(len != 0) RNA_def_property_array(prop, len);
1750         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1751         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1752         RNA_def_property_ui_text(prop, ui_name, ui_description);
1753         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1754
1755         return prop;
1756 }
1757
1758 PropertyRNA *RNA_def_float_percentage(StructRNA *srna, const char *identifier, float default_value,
1759         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1760 {
1761         PropertyRNA *prop;
1762
1763         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_PERCENTAGE);
1764         RNA_def_property_float_default(prop, default_value);
1765         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1766         RNA_def_property_ui_text(prop, ui_name, ui_description);
1767         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1768
1769         return prop;
1770 }
1771
1772 PropertyRNA *RNA_def_pointer_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1773         const char *ui_name, const char *ui_description)
1774 {
1775         PropertyRNA *prop;
1776
1777         prop= RNA_def_property(srna, identifier, PROP_POINTER, PROP_NONE);
1778         RNA_def_property_struct_runtime(prop, type);
1779         RNA_def_property_ui_text(prop, ui_name, ui_description);
1780
1781         return prop;
1782 }
1783
1784 PropertyRNA *RNA_def_collection_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1785         const char *ui_name, const char *ui_description)
1786 {
1787         PropertyRNA *prop;
1788
1789         prop= RNA_def_property(srna, identifier, PROP_COLLECTION, PROP_NONE);
1790         RNA_def_property_struct_runtime(prop, type);
1791         RNA_def_property_ui_text(prop, ui_name, ui_description);
1792
1793         return prop;
1794 }
1795