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_path_func(StructRNA *srna, const char *path)
 518 {
 519         if(!DefRNA.preprocess) {
 520                 fprintf(stderr, "RNA_def_struct_path_func: only during preprocessing.\n");
 521                 return;
 522         }
 523
 524         if(path) srna->path= (StructPathFunc)path;
 525 }
 526
 527 void RNA_def_struct_identifier(StructRNA *srna, const char *identifier)
 528 {
 529         if(DefRNA.preprocess) {
 530                 fprintf(stderr, "RNA_def_struct_name_runtime: only at runtime.\n");
 531                 return;
 532         }
 533
 534         srna->identifier= identifier;
 535 }
 536
 537 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
 538 {
 539         srna->name= name;
 540         srna->description= description;
 541 }
 542
 543 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
 544 {
 545         rna_freelistN(&srna->properties);
 546         rna_freelinkN(&brna->structs, srna);
 547 }
 548
 549 /* Property Definition */
 550
 551 PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype)
 552 {
 553         StructDefRNA *ds;
 554         PropertyDefRNA *dp= NULL;
 555         PropertyRNA *prop;
 556
 557         if(DefRNA.preprocess) {
 558                 char error[512];
 559
 560                 if (rna_validate_identifier(identifier, error, 1) == 0) {
 561                         fprintf(stderr, "RNA_def_property: property identifier \"%s\" - %s\n", identifier, error);
 562                         DefRNA.error= 1;
 563                 }
 564
 565                 ds= DefRNA.structs.last;
 566                 dp= MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
 567                 rna_addtail(&ds->properties, dp);
 568         }
 569
 570         prop= MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
 571
 572         switch(type) {
 573                 case PROP_BOOLEAN:
 574                         break;
 575                 case PROP_INT: {
 576                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 577
 578                         iprop->hardmin= (subtype == PROP_UNSIGNED)? 0: INT_MIN;
 579                         iprop->hardmax= INT_MAX;
 580
 581                         iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */
 582                         iprop->softmax= 10000;
 583                         iprop->step= 1;
 584                         break;
 585                 }
 586                 case PROP_FLOAT: {
 587                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 588
 589                         fprop->hardmin= (subtype == PROP_UNSIGNED)? 0.0f: -FLT_MAX;
 590                         fprop->hardmax= FLT_MAX;
 591
 592                         if(subtype == PROP_COLOR) {
 593                                 fprop->softmin= 0.0f;
 594                                 fprop->softmax= 1.0f;
 595                         }
 596                         else if(subtype == PROP_PERCENTAGE) {
 597                                 fprop->softmin= fprop->hardmin= 0.0f;
 598                                 fprop->softmax= fprop->hardmax= 1.0f;
 599                         }
 600                         else {
 601                                 fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */
 602                                 fprop->softmax= 10000.0f;
 603                         }
 604                         fprop->step= 10;
 605                         fprop->precision= 3;
 606                         break;
 607                 }
 608                 case PROP_STRING: {
 609                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 610
 611                         sprop->defaultvalue= "";
 612                         sprop->maxlength= 0;
 613                         break;
 614                 }
 615                 case PROP_ENUM:
 616                 case PROP_POINTER:
 617                 case PROP_COLLECTION:
 618                         break;
 619                 default:
 620                         fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", srna->identifier, identifier);
 621                         DefRNA.error= 1;
 622                         return NULL;
 623         }
 624
 625         if(DefRNA.preprocess) {
 626                 dp->srna= srna;
 627                 dp->prop= prop;
 628         }
 629
 630         prop->magic= RNA_MAGIC;
 631         prop->identifier= identifier;
 632         prop->type= type;
 633         prop->subtype= subtype;
 634         prop->name= identifier;
 635         prop->description= "";
 636
 637         if(type != PROP_COLLECTION && type != PROP_POINTER)
 638                 prop->flag= PROP_EDITABLE|PROP_ANIMATEABLE;
 639
 640         if(DefRNA.preprocess) {
 641                 switch(type) {
 642                         case PROP_BOOLEAN:
 643                                 DefRNA.silent= 1;
 644                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
 645                                 DefRNA.silent= 0;
 646                                 break;
 647                         case PROP_INT: {
 648                                 DefRNA.silent= 1;
 649                                 RNA_def_property_int_sdna(prop, NULL, identifier);
 650                                 DefRNA.silent= 0;
 651                                 break;
 652                         }
 653                         case PROP_FLOAT: {
 654                                 DefRNA.silent= 1;
 655                                 RNA_def_property_float_sdna(prop, NULL, identifier);
 656                                 DefRNA.silent= 0;
 657                                 break;
 658                         }
 659                         case PROP_STRING: {
 660                                 DefRNA.silent= 1;
 661                                 RNA_def_property_string_sdna(prop, NULL, identifier);
 662                                 DefRNA.silent= 0;
 663                                 break;
 664                         }
 665                         case PROP_ENUM:
 666                                 DefRNA.silent= 1;
 667                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
 668                                 DefRNA.silent= 0;
 669                                 break;
 670                         case PROP_POINTER:
 671                                 DefRNA.silent= 1;
 672                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
 673                                 DefRNA.silent= 0;
 674                                 break;
 675                         case PROP_COLLECTION:
 676                                 DefRNA.silent= 1;
 677                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
 678                                 DefRNA.silent= 0;
 679                                 break;
 680                 }
 681         }
 682         else
 683                 prop->flag |= PROP_IDPROPERTY|PROP_RUNTIME;
 684
 685         rna_addtail(&srna->properties, prop);
 686
 687         return prop;
 688 }
 689
 690 void RNA_def_property_flag(PropertyRNA *prop, int flag)
 691 {
 692         prop->flag |= flag;
 693 }
 694
 695 void RNA_def_property_clear_flag(PropertyRNA *prop, int flag)
 696 {
 697         prop->flag &= ~flag;
 698 }
 699
 700 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
 701 {
 702         StructRNA *srna= DefRNA.laststruct;
 703
 704         if(arraylength<0) {
 705                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be zero of greater.\n", srna->identifier, prop->identifier);
 706                 DefRNA.error= 1;
 707                 return;
 708         }
 709
 710         if(arraylength>RNA_MAX_ARRAY) {
 711                 fprintf(stderr, "RNA_def_property_array: %s.%s, array length must be smaller than %d.\n", srna->identifier, prop->identifier, RNA_MAX_ARRAY);
 712                 DefRNA.error= 1;
 713                 return;
 714         }
 715
 716         switch(prop->type) {
 717                 case PROP_BOOLEAN:
 718                 case PROP_INT:
 719                 case PROP_FLOAT:
 720                         prop->arraylength= arraylength;
 721                         break;
 722                 default:
 723                         fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", srna->identifier, prop->identifier);
 724                         DefRNA.error= 1;
 725                         break;
 726         }
 727 }
 728
 729 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
 730 {
 731         prop->name= name;
 732         prop->description= description;
 733 }
 734
 735 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
 736 {
 737         StructRNA *srna= DefRNA.laststruct;
 738
 739         switch(prop->type) {
 740                 case PROP_INT: {
 741                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 742                         iprop->softmin= (int)min;
 743                         iprop->softmax= (int)max;
 744                         iprop->step= (int)step;
 745                         break;
 746                 }
 747                 case PROP_FLOAT: {
 748                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 749                         fprop->softmin= (float)min;
 750                         fprop->softmax= (float)max;
 751                         fprop->step= (float)step;
 752                         fprop->precision= (int)precision;
 753                         break;
 754                 }
 755                 default:
 756                         fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", srna->identifier, prop->identifier);
 757                         DefRNA.error= 1;
 758                         break;
 759         }
 760 }
 761
 762 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
 763 {
 764         StructRNA *srna= DefRNA.laststruct;
 765
 766         switch(prop->type) {
 767                 case PROP_INT: {
 768                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 769                         iprop->hardmin= (int)min;
 770                         iprop->hardmax= (int)max;
 771                         iprop->softmin= MAX2((int)min, iprop->hardmin);
 772                         iprop->softmax= MIN2((int)max, iprop->hardmax);
 773                         break;
 774                 }
 775                 case PROP_FLOAT: {
 776                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 777                         fprop->hardmin= (float)min;
 778                         fprop->hardmax= (float)max;
 779                         fprop->softmin= MAX2((float)min, fprop->hardmin);
 780                         fprop->softmax= MIN2((float)max, fprop->hardmax);
 781                         break;
 782                 }
 783                 default:
 784                         fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", srna->identifier, prop->identifier);
 785                         DefRNA.error= 1;
 786                         break;
 787         }
 788 }
 789
 790 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
 791 {
 792         StructRNA *srna= DefRNA.laststruct;
 793
 794         if(!DefRNA.preprocess) {
 795                 fprintf(stderr, "RNA_def_property_struct_type: only during preprocessing.\n");
 796                 return;
 797         }
 798
 799         switch(prop->type) {
 800                 case PROP_POINTER: {
 801                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 802                         pprop->type = (StructRNA*)type;
 803                         break;
 804                 }
 805                 case PROP_COLLECTION: {
 806                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 807                         cprop->type = (StructRNA*)type;
 808                         break;
 809                 }
 810                 default:
 811                         fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 812                         DefRNA.error= 1;
 813                         break;
 814         }
 815 }
 816
 817 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
 818 {
 819         StructRNA *srna= DefRNA.laststruct;
 820
 821         if(DefRNA.preprocess) {
 822                 fprintf(stderr, "RNA_def_property_struct_runtime: only at runtime.\n");
 823                 return;
 824         }
 825
 826         switch(prop->type) {
 827                 case PROP_POINTER: {
 828                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 829                         pprop->type = type;
 830                         break;
 831                 }
 832                 case PROP_COLLECTION: {
 833                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 834                         cprop->type = type;
 835                         break;
 836                 }
 837                 default:
 838                         fprintf(stderr, "RNA_def_property_struct_runtime: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 839                         DefRNA.error= 1;
 840                         break;
 841         }
 842 }
 843
 844 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
 845 {
 846         StructRNA *srna= DefRNA.laststruct;
 847         int i, defaultfound= 0;
 848
 849         switch(prop->type) {
 850                 case PROP_ENUM: {
 851                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 852                         eprop->item= item;
 853                         eprop->totitem= 0;
 854                         for(i=0; item[i].identifier; i++) {
 855                                 eprop->totitem++;
 856
 857                                 if(item[i].value == eprop->defaultvalue)
 858                                         defaultfound= 1;
 859                         }
 860
 861                         if(!defaultfound)
 862                                 eprop->defaultvalue= item[0].value;
 863
 864                         break;
 865                 }
 866                 default:
 867                         fprintf(stderr, "RNA_def_property_enum_items: %s.%s, invalid type for struct type.\n", srna->identifier, prop->identifier);
 868                         DefRNA.error= 1;
 869                         break;
 870         }
 871 }
 872
 873 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
 874 {
 875         StructRNA *srna= DefRNA.laststruct;
 876
 877         switch(prop->type) {
 878                 case PROP_STRING: {
 879                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 880                         sprop->maxlength= maxlength;
 881                         break;
 882                 }
 883                 default:
 884                         fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
 885                         DefRNA.error= 1;
 886                         break;
 887         }
 888 }
 889
 890 void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
 891 {
 892         StructRNA *srna= DefRNA.laststruct;
 893
 894         switch(prop->type) {
 895                 case PROP_BOOLEAN: {
 896                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 897                         bprop->defaultvalue= value;
 898                         break;
 899                 }
 900                 default:
 901                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
 902                         DefRNA.error= 1;
 903                         break;
 904         }
 905 }
 906
 907 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
 908 {
 909         StructRNA *srna= DefRNA.laststruct;
 910
 911         switch(prop->type) {
 912                 case PROP_BOOLEAN: {
 913                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 914                         bprop->defaultarray= array;
 915                         break;
 916                 }
 917                 default:
 918                         fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
 919                         DefRNA.error= 1;
 920                         break;
 921         }
 922 }
 923
 924 void RNA_def_property_int_default(PropertyRNA *prop, int value)
 925 {
 926         StructRNA *srna= DefRNA.laststruct;
 927
 928         switch(prop->type) {
 929                 case PROP_INT: {
 930                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 931                         iprop->defaultvalue= value;
 932                         break;
 933                 }
 934                 default:
 935                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
 936                         DefRNA.error= 1;
 937                         break;
 938         }
 939 }
 940
 941 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
 942 {
 943         StructRNA *srna= DefRNA.laststruct;
 944
 945         switch(prop->type) {
 946                 case PROP_INT: {
 947                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 948                         iprop->defaultarray= array;
 949                         break;
 950                 }
 951                 default:
 952                         fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
 953                         DefRNA.error= 1;
 954                         break;
 955         }
 956 }
 957
 958 void RNA_def_property_float_default(PropertyRNA *prop, float value)
 959 {
 960         StructRNA *srna= DefRNA.laststruct;
 961
 962         switch(prop->type) {
 963                 case PROP_FLOAT: {
 964                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 965                         fprop->defaultvalue= value;
 966                         break;
 967                 }
 968                 default:
 969                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
 970                         DefRNA.error= 1;
 971                         break;
 972         }
 973 }
 974 /* array must remain valid after this function finishes */
 975 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
 976 {
 977         StructRNA *srna= DefRNA.laststruct;
 978
 979         switch(prop->type) {
 980                 case PROP_FLOAT: {
 981                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 982                         fprop->defaultarray= array; /* WARNING, this array must not come from the stack and lost */
 983                         break;
 984                 }
 985                 default:
 986                         fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
 987                         DefRNA.error= 1;
 988                         break;
 989         }
 990 }
 991
 992 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
 993 {
 994         StructRNA *srna= DefRNA.laststruct;
 995
 996         switch(prop->type) {
 997                 case PROP_STRING: {
 998                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 999                         sprop->defaultvalue= value;
1000                         break;
1001                 }
1002                 default:
1003                         fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1004                         DefRNA.error= 1;
1005                         break;
1006         }
1007 }
1008
1009 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1010 {
1011         StructRNA *srna= DefRNA.laststruct;
1012         int i, defaultfound= 0;
1013
1014         switch(prop->type) {
1015                 case PROP_ENUM: {
1016                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1017                         eprop->defaultvalue= value;
1018
1019                         for(i=0; i<eprop->totitem; i++) {
1020                                 if(eprop->item[i].value == eprop->defaultvalue)
1021                                         defaultfound= 1;
1022                         }
1023
1024                         if(!defaultfound && eprop->totitem) {
1025                                 if(value == 0) {
1026                                         eprop->defaultvalue= eprop->item[0].value;
1027                                 }
1028                                 else {
1029                                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, default is not in items.\n", srna->identifier, prop->identifier);
1030                                         DefRNA.error= 1;
1031                                 }
1032                         }
1033
1034                         break;
1035                 }
1036                 default:
1037                         fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1038                         DefRNA.error= 1;
1039                         break;
1040         }
1041 }
1042
1043 /* SDNA */
1044
1045 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1046 {
1047         DNAStructMember smember;
1048         StructDefRNA *ds= DefRNA.structs.last;
1049         PropertyDefRNA *dp= ds->properties.last;
1050
1051         if(!structname)
1052                 structname= ds->dnaname;
1053         if(!propname)
1054                 propname= prop->identifier;
1055
1056         if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1057                 if(!DefRNA.silent) {
1058                         fprintf(stderr, "rna_def_property_sdna: %s.%s not found.\n", structname, propname);
1059                         DefRNA.error= 1;
1060                 }
1061                 return NULL;
1062         }
1063
1064         if(smember.arraylength > 1)
1065                 prop->arraylength= smember.arraylength;
1066         else
1067                 prop->arraylength= 0;
1068
1069         dp->dnastructname= structname;
1070         dp->dnastructfromname= ds->dnafromname;
1071         dp->dnastructfromprop= ds->dnafromprop;
1072         dp->dnaname= propname;
1073         dp->dnatype= smember.type;
1074         dp->dnaarraylength= smember.arraylength;
1075         dp->dnapointerlevel= smember.pointerlevel;
1076
1077         return dp;
1078 }
1079
1080 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1081 {
1082         PropertyDefRNA *dp;
1083         StructRNA *srna= DefRNA.laststruct;
1084
1085         if(!DefRNA.preprocess) {
1086                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1087                 return;
1088         }
1089
1090         if(prop->type != PROP_BOOLEAN) {
1091                 fprintf(stderr, "RNA_def_property_boolean_sdna: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1092                 DefRNA.error= 1;
1093                 return;
1094         }
1095
1096         if((dp=rna_def_property_sdna(prop, structname, propname)))
1097                 dp->booleanbit= bit;
1098 }
1099
1100 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
1101 {
1102         StructDefRNA *ds;
1103         PropertyDefRNA *dp;
1104
1105         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1106
1107         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1108                 dp->booleannegative= 1;
1109 }
1110
1111 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1112 {
1113         PropertyDefRNA *dp;
1114         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1115         StructRNA *srna= DefRNA.laststruct;
1116
1117         if(!DefRNA.preprocess) {
1118                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1119                 return;
1120         }
1121
1122         if(prop->type != PROP_INT) {
1123                 fprintf(stderr, "RNA_def_property_int_sdna: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1124                 DefRNA.error= 1;
1125                 return;
1126         }
1127
1128         if((dp= rna_def_property_sdna(prop, structname, propname))) {
1129                 /* SDNA doesn't pass us unsigned unfortunately .. */
1130                 if(strcmp(dp->dnatype, "char") == 0) {
1131                         iprop->hardmin= iprop->softmin= CHAR_MIN;
1132                         iprop->hardmax= iprop->softmax= CHAR_MAX;
1133                 }
1134                 else if(strcmp(dp->dnatype, "short") == 0) {
1135                         iprop->hardmin= iprop->softmin= SHRT_MIN;
1136                         iprop->hardmax= iprop->softmax= SHRT_MAX;
1137                 }
1138                 else if(strcmp(dp->dnatype, "int") == 0) {
1139                         iprop->hardmin= INT_MIN;
1140                         iprop->hardmax= INT_MAX;
1141
1142                         iprop->softmin= -10000; /* rather arbitrary .. */
1143                         iprop->softmax= 10000;
1144                 }
1145
1146                 if(prop->subtype == PROP_UNSIGNED)
1147                         iprop->hardmin= iprop->softmin= 0;
1148         }
1149 }
1150
1151 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1152 {
1153         StructRNA *srna= DefRNA.laststruct;
1154
1155         if(!DefRNA.preprocess) {
1156                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1157                 return;
1158         }
1159
1160         if(prop->type != PROP_FLOAT) {
1161                 fprintf(stderr, "RNA_def_property_float_sdna: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1162                 DefRNA.error= 1;
1163                 return;
1164         }
1165
1166         rna_def_property_sdna(prop, structname, propname);
1167 }
1168
1169 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1170 {
1171         PropertyDefRNA *dp;
1172         StructRNA *srna= DefRNA.laststruct;
1173
1174         if(!DefRNA.preprocess) {
1175                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1176                 return;
1177         }
1178
1179         if(prop->type != PROP_ENUM) {
1180                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1181                 DefRNA.error= 1;
1182                 return;
1183         }
1184
1185         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1186                 if(prop->arraylength) {
1187                         prop->arraylength= 0;
1188                         if(!DefRNA.silent) {
1189                                 fprintf(stderr, "RNA_def_property_enum_sdna: %s.%s, array not supported for enum type.\n", structname, propname);
1190                                 DefRNA.error= 1;
1191                         }
1192                 }
1193         }
1194 }
1195
1196 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1197 {
1198         StructDefRNA *ds;
1199         PropertyDefRNA *dp;
1200
1201         RNA_def_property_enum_sdna(prop, structname, propname);
1202
1203         if((ds=DefRNA.structs.last) && (dp=ds->properties.last))
1204                 dp->enumbitflags= 1;
1205 }
1206
1207 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1208 {
1209         PropertyDefRNA *dp;
1210         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1211         StructRNA *srna= DefRNA.laststruct;
1212
1213         if(!DefRNA.preprocess) {
1214                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1215                 return;
1216         }
1217
1218         if(prop->type != PROP_STRING) {
1219                 fprintf(stderr, "RNA_def_property_string_sdna: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1220                 DefRNA.error= 1;
1221                 return;
1222         }
1223
1224         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1225                 if(prop->arraylength) {
1226                         sprop->maxlength= prop->arraylength;
1227                         prop->arraylength= 0;
1228                 }
1229         }
1230 }
1231
1232 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1233 {
1234         PropertyDefRNA *dp;
1235         StructRNA *srna= DefRNA.laststruct;
1236
1237         if(!DefRNA.preprocess) {
1238                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1239                 return;
1240         }
1241
1242         if(prop->type != PROP_POINTER) {
1243                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1244                 DefRNA.error= 1;
1245                 return;
1246         }
1247
1248         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1249                 if(prop->arraylength) {
1250                         prop->arraylength= 0;
1251                         if(!DefRNA.silent) {
1252                                 fprintf(stderr, "RNA_def_property_pointer_sdna: %s.%s, array not supported for pointer type.\n", structname, propname);
1253                                 DefRNA.error= 1;
1254                         }
1255                 }
1256         }
1257 }
1258
1259 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
1260 {
1261         PropertyDefRNA *dp;
1262         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1263         StructRNA *srna= DefRNA.laststruct;
1264
1265         if(!DefRNA.preprocess) {
1266                 fprintf(stderr, "RNA_def_property_*_sdna: only during preprocessing.\n");
1267                 return;
1268         }
1269
1270         if(prop->type != PROP_COLLECTION) {
1271                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1272                 DefRNA.error= 1;
1273                 return;
1274         }
1275
1276         if((dp=rna_def_property_sdna(prop, structname, propname))) {
1277                 if(prop->arraylength && !lengthpropname) {
1278                         prop->arraylength= 0;
1279
1280                         if(!DefRNA.silent) {
1281                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s, array of collections not supported.\n", structname, propname);
1282                                 DefRNA.error= 1;
1283                         }
1284                 }
1285
1286                 if(strcmp(dp->dnatype, "ListBase") == 0) {
1287                         cprop->next= (PropCollectionNextFunc)"rna_iterator_listbase_next";
1288                         cprop->get= (PropCollectionGetFunc)"rna_iterator_listbase_get";
1289                         cprop->end= (PropCollectionEndFunc)"rna_iterator_listbase_end";
1290                 }
1291         }
1292
1293         if(dp && lengthpropname) {
1294                 DNAStructMember smember;
1295                 StructDefRNA *ds= DefRNA.structs.last;
1296
1297                 if(!structname)
1298                         structname= ds->dnaname;
1299
1300                 if(lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
1301                         if(lengthpropname[0] == 0) {
1302                                 dp->dnalengthfixed= prop->arraylength;
1303                                 prop->arraylength= 0;
1304                         }
1305                         else {
1306                                 dp->dnalengthstructname= structname;
1307                                 dp->dnalengthname= lengthpropname;
1308                         }
1309
1310                         cprop->next= (PropCollectionNextFunc)"rna_iterator_array_next";
1311                         cprop->end= (PropCollectionEndFunc)"rna_iterator_array_end";
1312
1313                         if(dp->dnapointerlevel >= 2)
1314                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
1315                         else
1316                                 cprop->get= (PropCollectionGetFunc)"rna_iterator_array_get";
1317                 }
1318                 else {
1319                         if(!DefRNA.silent) {
1320                                 fprintf(stderr, "RNA_def_property_collection_sdna: %s.%s not found.\n", structname, lengthpropname);
1321                                 DefRNA.error= 1;
1322                         }
1323                 }
1324         }
1325 }
1326
1327 /* Functions */
1328
1329 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
1330 {
1331         if(!DefRNA.preprocess) {
1332                 fprintf(stderr, "RNA_def_property_editable_func: only during preprocessing.\n");
1333                 return;
1334         }
1335
1336         if(editable) prop->editable= (EditableFunc)editable;
1337 }
1338
1339 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
1340 {
1341         if(!DefRNA.preprocess) {
1342                 fprintf(stderr, "RNA_def_struct_refine_func: only during preprocessing.\n");
1343                 return;
1344         }
1345
1346         prop->noteflag= noteflag;
1347         prop->update= (UpdateFunc)func;
1348 }
1349
1350 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
1351 {
1352         StructRNA *srna= DefRNA.laststruct;
1353
1354         if(!DefRNA.preprocess) {
1355                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1356                 return;
1357         }
1358
1359         switch(prop->type) {
1360                 case PROP_BOOLEAN: {
1361                         BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
1362
1363                         if(prop->arraylength) {
1364                                 if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
1365                                 if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
1366                         }
1367                         else {
1368                                 if(get) bprop->get= (PropBooleanGetFunc)get;
1369                                 if(set) bprop->set= (PropBooleanSetFunc)set;
1370                         }
1371                         break;
1372                 }
1373                 default:
1374                         fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", srna->identifier, prop->identifier);
1375                         DefRNA.error= 1;
1376                         break;
1377         }
1378 }
1379
1380 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1381 {
1382         StructRNA *srna= DefRNA.laststruct;
1383
1384         if(!DefRNA.preprocess) {
1385                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1386                 return;
1387         }
1388
1389         switch(prop->type) {
1390                 case PROP_INT: {
1391                         IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
1392
1393                         if(prop->arraylength) {
1394                                 if(get) iprop->getarray= (PropIntArrayGetFunc)get;
1395                                 if(set) iprop->setarray= (PropIntArraySetFunc)set;
1396                         }
1397                         else {
1398                                 if(get) iprop->get= (PropIntGetFunc)get;
1399                                 if(set) iprop->set= (PropIntSetFunc)set;
1400                         }
1401                         if(range) iprop->range= (PropIntRangeFunc)range;
1402                         break;
1403                 }
1404                 default:
1405                         fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", srna->identifier, prop->identifier);
1406                         DefRNA.error= 1;
1407                         break;
1408         }
1409 }
1410
1411 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
1412 {
1413         StructRNA *srna= DefRNA.laststruct;
1414
1415         if(!DefRNA.preprocess) {
1416                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1417                 return;
1418         }
1419
1420         switch(prop->type) {
1421                 case PROP_FLOAT: {
1422                         FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
1423
1424                         if(prop->arraylength) {
1425                                 if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
1426                                 if(set) fprop->setarray= (PropFloatArraySetFunc)set;
1427                         }
1428                         else {
1429                                 if(get) fprop->get= (PropFloatGetFunc)get;
1430                                 if(set) fprop->set= (PropFloatSetFunc)set;
1431                         }
1432                         if(range) fprop->range= (PropFloatRangeFunc)range;
1433                         break;
1434                 }
1435                 default:
1436                         fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", srna->identifier, prop->identifier);
1437                         DefRNA.error= 1;
1438                         break;
1439         }
1440 }
1441
1442 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
1443 {
1444         StructRNA *srna= DefRNA.laststruct;
1445
1446         if(!DefRNA.preprocess) {
1447                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1448                 return;
1449         }
1450
1451         switch(prop->type) {
1452                 case PROP_ENUM: {
1453                         EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
1454
1455                         if(get) eprop->get= (PropEnumGetFunc)get;
1456                         if(set) eprop->set= (PropEnumSetFunc)set;
1457                         break;
1458                 }
1459                 default:
1460                         fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", srna->identifier, prop->identifier);
1461                         DefRNA.error= 1;
1462                         break;
1463         }
1464 }
1465
1466 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
1467 {
1468         StructRNA *srna= DefRNA.laststruct;
1469
1470         if(!DefRNA.preprocess) {
1471                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1472                 return;
1473         }
1474
1475         switch(prop->type) {
1476                 case PROP_STRING: {
1477                         StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
1478
1479                         if(get) sprop->get= (PropStringGetFunc)get;
1480                         if(length) sprop->length= (PropStringLengthFunc)length;
1481                         if(set) sprop->set= (PropStringSetFunc)set;
1482                         break;
1483                 }
1484                 default:
1485                         fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", srna->identifier, prop->identifier);
1486                         DefRNA.error= 1;
1487                         break;
1488         }
1489 }
1490
1491 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set)
1492 {
1493         StructRNA *srna= DefRNA.laststruct;
1494
1495         if(!DefRNA.preprocess) {
1496                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1497                 return;
1498         }
1499
1500         switch(prop->type) {
1501                 case PROP_POINTER: {
1502                         PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
1503
1504                         if(get) pprop->get= (PropPointerGetFunc)get;
1505                         if(set) pprop->set= (PropPointerSetFunc)set;
1506                         break;
1507                 }
1508                 default:
1509                         fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", srna->identifier, prop->identifier);
1510                         DefRNA.error= 1;
1511                         break;
1512         }
1513 }
1514
1515 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)
1516 {
1517         StructRNA *srna= DefRNA.laststruct;
1518
1519         if(!DefRNA.preprocess) {
1520                 fprintf(stderr, "RNA_def_property_*_funcs: only during preprocessing.\n");
1521                 return;
1522         }
1523
1524         switch(prop->type) {
1525                 case PROP_COLLECTION: {
1526                         CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
1527
1528                         if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
1529                         if(next) cprop->next= (PropCollectionNextFunc)next;
1530                         if(end) cprop->end= (PropCollectionEndFunc)end;
1531                         if(get) cprop->get= (PropCollectionGetFunc)get;
1532                         if(length) cprop->length= (PropCollectionLengthFunc)length;
1533                         if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
1534                         if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
1535                         break;
1536                 }
1537                 default:
1538                         fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", srna->identifier, prop->identifier);
1539                         DefRNA.error= 1;
1540                         break;
1541         }
1542 }
1543
1544 /* Compact definitions */
1545
1546 PropertyRNA *RNA_def_boolean(StructRNA *srna, const char *identifier, int default_value,
1547         const char *ui_name, const char *ui_description)
1548 {
1549         PropertyRNA *prop;
1550
1551         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1552         RNA_def_property_boolean_default(prop, default_value);
1553         RNA_def_property_ui_text(prop, ui_name, ui_description);
1554
1555         return prop;
1556 }
1557
1558 PropertyRNA *RNA_def_boolean_array(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1559 {
1560         PropertyRNA *prop;
1561
1562         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_NONE);
1563         if(len != 0) RNA_def_property_array(prop, len);
1564         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1565         RNA_def_property_ui_text(prop, ui_name, ui_description);
1566
1567         return prop;
1568 }
1569
1570 PropertyRNA *RNA_def_boolean_vector(StructRNA *srna, const char *identifier, int len, int *default_value, const char *ui_name, const char *ui_description)
1571 {
1572         PropertyRNA *prop;
1573
1574         prop= RNA_def_property(srna, identifier, PROP_BOOLEAN, PROP_VECTOR);
1575         if(len != 0) RNA_def_property_array(prop, len);
1576         if(default_value) RNA_def_property_boolean_array_default(prop, default_value);
1577         RNA_def_property_ui_text(prop, ui_name, ui_description);
1578
1579         return prop;
1580 }
1581
1582 PropertyRNA *RNA_def_int(StructRNA *srna, const char *identifier, int default_value, int hardmin, int hardmax,
1583         const char *ui_name, const char *ui_description, int softmin, int softmax)
1584 {
1585         PropertyRNA *prop;
1586
1587         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1588         RNA_def_property_int_default(prop, default_value);
1589         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1590         RNA_def_property_ui_text(prop, ui_name, ui_description);
1591         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1592
1593         return prop;
1594 }
1595
1596 PropertyRNA *RNA_def_int_vector(StructRNA *srna, const char *identifier, int len, const int *default_value,
1597         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1598 {
1599         PropertyRNA *prop;
1600
1601         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_VECTOR);
1602         if(len != 0) RNA_def_property_array(prop, len);
1603         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1604         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1605         RNA_def_property_ui_text(prop, ui_name, ui_description);
1606         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1607
1608         return prop;
1609 }
1610
1611 PropertyRNA *RNA_def_int_array(StructRNA *srna, const char *identifier, int len, const int *default_value,
1612         int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
1613 {
1614         PropertyRNA *prop;
1615
1616         prop= RNA_def_property(srna, identifier, PROP_INT, PROP_NONE);
1617         if(len != 0) RNA_def_property_array(prop, len);
1618         if(default_value) RNA_def_property_int_array_default(prop, default_value);
1619         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1620         RNA_def_property_ui_text(prop, ui_name, ui_description);
1621         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1622
1623         return prop;
1624 }
1625
1626 PropertyRNA *RNA_def_string(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1627         const char *ui_name, const char *ui_description)
1628 {
1629         PropertyRNA *prop;
1630
1631         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_NONE);
1632         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1633         if(default_value) RNA_def_property_string_default(prop, default_value);
1634         RNA_def_property_ui_text(prop, ui_name, ui_description);
1635
1636         return prop;
1637 }
1638
1639 PropertyRNA *RNA_def_string_file_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1640         const char *ui_name, const char *ui_description)
1641 {
1642         PropertyRNA *prop;
1643
1644         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_FILEPATH);
1645         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1646         if(default_value) RNA_def_property_string_default(prop, default_value);
1647         RNA_def_property_ui_text(prop, ui_name, ui_description);
1648
1649         return prop;
1650 }
1651
1652 PropertyRNA *RNA_def_string_dir_path(StructRNA *srna, const char *identifier, const char *default_value, int maxlen,
1653         const char *ui_name, const char *ui_description)
1654 {
1655         PropertyRNA *prop;
1656
1657         prop= RNA_def_property(srna, identifier, PROP_STRING, PROP_DIRPATH);
1658         if(maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
1659         if(default_value) RNA_def_property_string_default(prop, default_value);
1660         RNA_def_property_ui_text(prop, ui_name, ui_description);
1661
1662         return prop;
1663 }
1664
1665 PropertyRNA *RNA_def_enum(StructRNA *srna, const char *identifier, EnumPropertyItem *items, int default_value,
1666         const char *ui_name, const char *ui_description)
1667 {
1668         PropertyRNA *prop;
1669
1670         prop= RNA_def_property(srna, identifier, PROP_ENUM, PROP_NONE);
1671         if(items) RNA_def_property_enum_items(prop, items);
1672         RNA_def_property_enum_default(prop, default_value);
1673         RNA_def_property_ui_text(prop, ui_name, ui_description);
1674
1675         return prop;
1676 }
1677
1678 PropertyRNA *RNA_def_float(StructRNA *srna, const char *identifier, float default_value,
1679         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1680 {
1681         PropertyRNA *prop;
1682
1683         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1684         RNA_def_property_float_default(prop, default_value);
1685         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1686         RNA_def_property_ui_text(prop, ui_name, ui_description);
1687         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1688
1689         return prop;
1690 }
1691
1692 PropertyRNA *RNA_def_float_vector(StructRNA *srna, const char *identifier, int len, const float *default_value,
1693         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1694 {
1695         PropertyRNA *prop;
1696
1697         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_VECTOR);
1698         if(len != 0) RNA_def_property_array(prop, len);
1699         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1700         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1701         RNA_def_property_ui_text(prop, ui_name, ui_description);
1702         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1703
1704         return prop;
1705 }
1706
1707 PropertyRNA *RNA_def_float_color(StructRNA *srna, const char *identifier, int len, const float *default_value,
1708         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1709 {
1710         PropertyRNA *prop;
1711
1712         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_COLOR);
1713         if(len != 0) RNA_def_property_array(prop, len);
1714         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1715         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1716         RNA_def_property_ui_text(prop, ui_name, ui_description);
1717         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1718
1719         return prop;
1720 }
1721
1722
1723 PropertyRNA *RNA_def_float_matrix(StructRNA *srna, const char *identifier, int len, const float *default_value,
1724         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1725 {
1726         PropertyRNA *prop;
1727
1728         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_MATRIX);
1729         if(len != 0) RNA_def_property_array(prop, len);
1730         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1731         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1732         RNA_def_property_ui_text(prop, ui_name, ui_description);
1733         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1734
1735         return prop;
1736 }
1737
1738 PropertyRNA *RNA_def_float_rotation(StructRNA *srna, const char *identifier, int len, const float *default_value,
1739         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1740 {
1741         PropertyRNA *prop;
1742
1743         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_ROTATION);
1744         if(len != 0) RNA_def_property_array(prop, len);
1745         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1746         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1747         RNA_def_property_ui_text(prop, ui_name, ui_description);
1748         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1749
1750         return prop;
1751 }
1752
1753 PropertyRNA *RNA_def_float_array(StructRNA *srna, const char *identifier, int len, const float *default_value,
1754         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1755 {
1756         PropertyRNA *prop;
1757
1758         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_NONE);
1759         if(len != 0) RNA_def_property_array(prop, len);
1760         if(default_value) RNA_def_property_float_array_default(prop, default_value);
1761         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1762         RNA_def_property_ui_text(prop, ui_name, ui_description);
1763         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1764
1765         return prop;
1766 }
1767
1768 PropertyRNA *RNA_def_float_percentage(StructRNA *srna, const char *identifier, float default_value,
1769         float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
1770 {
1771         PropertyRNA *prop;
1772
1773         prop= RNA_def_property(srna, identifier, PROP_FLOAT, PROP_PERCENTAGE);
1774         RNA_def_property_float_default(prop, default_value);
1775         if(hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
1776         RNA_def_property_ui_text(prop, ui_name, ui_description);
1777         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
1778
1779         return prop;
1780 }
1781
1782 PropertyRNA *RNA_def_pointer_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1783         const char *ui_name, const char *ui_description)
1784 {
1785         PropertyRNA *prop;
1786
1787         prop= RNA_def_property(srna, identifier, PROP_POINTER, PROP_NONE);
1788         RNA_def_property_struct_runtime(prop, type);
1789         RNA_def_property_ui_text(prop, ui_name, ui_description);
1790
1791         return prop;
1792 }
1793
1794 PropertyRNA *RNA_def_collection_runtime(StructRNA *srna, const char *identifier, StructRNA *type,
1795         const char *ui_name, const char *ui_description)
1796 {
1797         PropertyRNA *prop;
1798
1799         prop= RNA_def_property(srna, identifier, PROP_COLLECTION, PROP_NONE);
1800         RNA_def_property_struct_runtime(prop, type);
1801         RNA_def_property_ui_text(prop, ui_name, ui_description);
1802
1803         return prop;
1804 }
1805