source/blender/makesrna/intern/rna_define.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Blender Foundation (2008).
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file blender/makesrna/intern/rna_define.c
  24  *  \ingroup RNA
  25  */
  26
  27
  28 #include <float.h>
  29 #include <limits.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <stddef.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35
  36 #include "BLI_utildefines.h"
  37 #include "MEM_guardedalloc.h"
  38
  39 #include "DNA_genfile.h"
  40 #include "DNA_sdna_types.h"
  41
  42 #include "BLI_listbase.h"
  43 #include "BLI_ghash.h"
  44
  45 #include "BLT_translation.h"
  46
  47 #include "UI_interface.h"  /* For things like UI_PRECISION_FLOAT_MAX... */
  48
  49 #include "RNA_define.h"
  50
  51 #include "rna_internal.h"
  52
  53
  54 #ifdef DEBUG
  55 #  define ASSERT_SOFT_HARD_LIMITS \
  56         if (softmin < hardmin || softmax > hardmax) { \
  57                 fprintf(stderr, "Error with soft/hard limits: %s.%s\n", CONTAINER_RNA_ID(cont), identifier); \
  58                 BLI_assert(!"invalid soft/hard limits"); \
  59         } (void)0
  60 #else
  61 #  define  ASSERT_SOFT_HARD_LIMITS (void)0
  62 #endif
  63
  64 /* Global used during defining */
  65
  66 BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1, 1};
  67
  68 /* Duplicated code since we can't link in blenkernel or blenlib */
  69
  70 /* pedantic check for final '.', note '...' are allowed though. */
  71 #ifndef NDEBUG
  72 #  define DESCR_CHECK(description, id1, id2)                                       \
  73         if (description && (description)[0]) {                                         \
  74                 int i = strlen(description);                                               \
  75                 if (i > 3 && (description)[i - 1] == '.' && (description)[i - 3] != '.') { \
  76                         fprintf(stderr, "%s: '%s' description from '%s' '%s' ends with a '.' !\n",       \
  77                                 __func__, description, id1 ? id1 : "", id2 ? id2 : "");                     \
  78                 }                                                                          \
  79         } (void)0
  80
  81 #else
  82 #  define DESCR_CHECK(description, id1, id2)
  83 #endif
  84
  85 void rna_addtail(ListBase *listbase, void *vlink)
  86 {
  87         Link *link = vlink;
  88
  89         link->next = NULL;
  90         link->prev = listbase->last;
  91
  92         if (listbase->last) ((Link *)listbase->last)->next = link;
  93         if (listbase->first == NULL) listbase->first = link;
  94         listbase->last = link;
  95 }
  96
  97 static void rna_remlink(ListBase *listbase, void *vlink)
  98 {
  99         Link *link = vlink;
 100
 101         if (link->next) link->next->prev = link->prev;
 102         if (link->prev) link->prev->next = link->next;
 103
 104         if (listbase->last == link) listbase->last = link->prev;
 105         if (listbase->first == link) listbase->first = link->next;
 106 }
 107
 108 PropertyDefRNA *rna_findlink(ListBase *listbase, const char *identifier)
 109 {
 110         Link *link;
 111
 112         for (link = listbase->first; link; link = link->next) {
 113                 PropertyRNA *prop = ((PropertyDefRNA *)link)->prop;
 114                 if (prop && (STREQ(prop->identifier, identifier))) {
 115                         return (PropertyDefRNA *)link;
 116                 }
 117         }
 118
 119         return NULL;
 120 }
 121
 122 void rna_freelinkN(ListBase *listbase, void *vlink)
 123 {
 124         rna_remlink(listbase, vlink);
 125         MEM_freeN(vlink);
 126 }
 127
 128 void rna_freelistN(ListBase *listbase)
 129 {
 130         Link *link, *next;
 131
 132         for (link = listbase->first; link; link = next) {
 133                 next = link->next;
 134                 MEM_freeN(link);
 135         }
 136
 137         listbase->first = listbase->last = NULL;
 138 }
 139
 140 static void rna_brna_structs_add(BlenderRNA *brna, StructRNA *srna)
 141 {
 142         rna_addtail(&brna->structs, srna);
 143         brna->structs_len += 1;
 144
 145         /* This exception is only needed for pre-processing.
 146          * otherwise we don't allow empty names. */
 147         if ((srna->flag & STRUCT_PUBLIC_NAMESPACE) &&
 148             (srna->identifier[0] != '\0'))
 149         {
 150                 BLI_ghash_insert(brna->structs_map, (void *)srna->identifier, srna);
 151         }
 152 }
 153
 154 #ifdef RNA_RUNTIME
 155 static void rna_brna_structs_remove_and_free(BlenderRNA *brna, StructRNA *srna)
 156 {
 157         if ((srna->flag & STRUCT_PUBLIC_NAMESPACE) && brna->structs_map) {
 158                 if (srna->identifier[0] != '\0') {
 159                         BLI_ghash_remove(brna->structs_map, (void *)srna->identifier, NULL, NULL);
 160                 }
 161         }
 162
 163         RNA_def_struct_free_pointers(NULL, srna);
 164
 165         if (srna->flag & STRUCT_RUNTIME) {
 166                 rna_freelinkN(&brna->structs, srna);
 167         }
 168         brna->structs_len -= 1;
 169 }
 170 #endif
 171
 172 StructDefRNA *rna_find_struct_def(StructRNA *srna)
 173 {
 174         StructDefRNA *dsrna;
 175
 176         if (!DefRNA.preprocess) {
 177                 /* we should never get here */
 178                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 179                 return NULL;
 180         }
 181
 182         dsrna = DefRNA.structs.last;
 183         for (; dsrna; dsrna = dsrna->cont.prev)
 184                 if (dsrna->srna == srna)
 185                         return dsrna;
 186
 187         return NULL;
 188 }
 189
 190 PropertyDefRNA *rna_find_struct_property_def(StructRNA *srna, PropertyRNA *prop)
 191 {
 192         StructDefRNA *dsrna;
 193         PropertyDefRNA *dprop;
 194
 195         if (!DefRNA.preprocess) {
 196                 /* we should never get here */
 197                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 198                 return NULL;
 199         }
 200
 201         dsrna = rna_find_struct_def(srna);
 202         dprop = dsrna->cont.properties.last;
 203         for (; dprop; dprop = dprop->prev)
 204                 if (dprop->prop == prop)
 205                         return dprop;
 206
 207         dsrna = DefRNA.structs.last;
 208         for (; dsrna; dsrna = dsrna->cont.prev) {
 209                 dprop = dsrna->cont.properties.last;
 210                 for (; dprop; dprop = dprop->prev)
 211                         if (dprop->prop == prop)
 212                                 return dprop;
 213         }
 214
 215         return NULL;
 216 }
 217
 218 #if 0
 219 static PropertyDefRNA *rna_find_property_def(PropertyRNA *prop)
 220 {
 221         PropertyDefRNA *dprop;
 222
 223         if (!DefRNA.preprocess) {
 224                 /* we should never get here */
 225                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 226                 return NULL;
 227         }
 228
 229         dprop = rna_find_struct_property_def(DefRNA.laststruct, prop);
 230         if (dprop)
 231                 return dprop;
 232
 233         dprop = rna_find_parameter_def(prop);
 234         if (dprop)
 235                 return dprop;
 236
 237         return NULL;
 238 }
 239 #endif
 240
 241 FunctionDefRNA *rna_find_function_def(FunctionRNA *func)
 242 {
 243         StructDefRNA *dsrna;
 244         FunctionDefRNA *dfunc;
 245
 246         if (!DefRNA.preprocess) {
 247                 /* we should never get here */
 248                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 249                 return NULL;
 250         }
 251
 252         dsrna = rna_find_struct_def(DefRNA.laststruct);
 253         dfunc = dsrna->functions.last;
 254         for (; dfunc; dfunc = dfunc->cont.prev)
 255                 if (dfunc->func == func)
 256                         return dfunc;
 257
 258         dsrna = DefRNA.structs.last;
 259         for (; dsrna; dsrna = dsrna->cont.prev) {
 260                 dfunc = dsrna->functions.last;
 261                 for (; dfunc; dfunc = dfunc->cont.prev)
 262                         if (dfunc->func == func)
 263                                 return dfunc;
 264         }
 265
 266         return NULL;
 267 }
 268
 269 PropertyDefRNA *rna_find_parameter_def(PropertyRNA *parm)
 270 {
 271         StructDefRNA *dsrna;
 272         FunctionDefRNA *dfunc;
 273         PropertyDefRNA *dparm;
 274
 275         if (!DefRNA.preprocess) {
 276                 /* we should never get here */
 277                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 278                 return NULL;
 279         }
 280
 281         dsrna = rna_find_struct_def(DefRNA.laststruct);
 282         dfunc = dsrna->functions.last;
 283         for (; dfunc; dfunc = dfunc->cont.prev) {
 284                 dparm = dfunc->cont.properties.last;
 285                 for (; dparm; dparm = dparm->prev)
 286                         if (dparm->prop == parm)
 287                                 return dparm;
 288         }
 289
 290         dsrna = DefRNA.structs.last;
 291         for (; dsrna; dsrna = dsrna->cont.prev) {
 292                 dfunc = dsrna->functions.last;
 293                 for (; dfunc; dfunc = dfunc->cont.prev) {
 294                         dparm = dfunc->cont.properties.last;
 295                         for (; dparm; dparm = dparm->prev)
 296                                 if (dparm->prop == parm)
 297                                         return dparm;
 298                 }
 299         }
 300
 301         return NULL;
 302 }
 303
 304 static ContainerDefRNA *rna_find_container_def(ContainerRNA *cont)
 305 {
 306         StructDefRNA *ds;
 307         FunctionDefRNA *dfunc;
 308
 309         if (!DefRNA.preprocess) {
 310                 /* we should never get here */
 311                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
 312                 return NULL;
 313         }
 314
 315         ds = rna_find_struct_def((StructRNA *)cont);
 316         if (ds)
 317                 return &ds->cont;
 318
 319         dfunc = rna_find_function_def((FunctionRNA *)cont);
 320         if (dfunc)
 321                 return &dfunc->cont;
 322
 323         return NULL;
 324 }
 325
 326 /* DNA utility function for looking up members */
 327
 328 typedef struct DNAStructMember {
 329         const char *type;
 330         const char *name;
 331         int arraylength;
 332         int pointerlevel;
 333 } DNAStructMember;
 334
 335 static int rna_member_cmp(const char *name, const char *oname)
 336 {
 337         int a = 0;
 338
 339         /* compare without pointer or array part */
 340         while (name[0] == '*')
 341                 name++;
 342         while (oname[0] == '*')
 343                 oname++;
 344
 345         while (1) {
 346                 if (name[a] == '[' && oname[a] == 0) return 1;
 347                 if (name[a] == '[' && oname[a] == '[') return 1;
 348                 if (name[a] == 0) break;
 349                 if (name[a] != oname[a]) return 0;
 350                 a++;
 351         }
 352         if (name[a] == 0 && oname[a] == '.') return 2;
 353         if (name[a] == 0 && oname[a] == '-' && oname[a + 1] == '>') return 3;
 354
 355         return (name[a] == oname[a]);
 356 }
 357
 358 static int rna_find_sdna_member(SDNA *sdna, const char *structname, const char *membername, DNAStructMember *smember)
 359 {
 360         const char *dnaname;
 361         const short *sp;
 362         int a, b, structnr, totmember, cmp;
 363
 364         structnr = DNA_struct_find_nr(sdna, structname);
 365         if (structnr == -1)
 366                 return 0;
 367
 368         sp = sdna->structs[structnr];
 369         totmember = sp[1];
 370         sp += 2;
 371
 372         for (a = 0; a < totmember; a++, sp += 2) {
 373                 dnaname = sdna->names[sp[1]];
 374
 375                 cmp = rna_member_cmp(dnaname, membername);
 376
 377                 if (cmp == 1) {
 378                         smember->type = sdna->types[sp[0]];
 379                         smember->name = dnaname;
 380
 381                         if (strstr(membername, "["))
 382                                 smember->arraylength = 0;
 383                         else
 384                                 smember->arraylength = DNA_elem_array_size(smember->name);
 385
 386                         smember->pointerlevel = 0;
 387                         for (b = 0; dnaname[b] == '*'; b++)
 388                                 smember->pointerlevel++;
 389
 390                         return 1;
 391                 }
 392                 else if (cmp == 2) {
 393                         smember->type = "";
 394                         smember->name = dnaname;
 395                         smember->pointerlevel = 0;
 396                         smember->arraylength = 0;
 397
 398                         membername = strstr(membername, ".") + strlen(".");
 399                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 400
 401                         return 1;
 402                 }
 403                 else if (cmp == 3) {
 404                         smember->type = "";
 405                         smember->name = dnaname;
 406                         smember->pointerlevel = 0;
 407                         smember->arraylength = 0;
 408
 409                         membername = strstr(membername, "->") + strlen("->");
 410                         rna_find_sdna_member(sdna, sdna->types[sp[0]], membername, smember);
 411
 412                         return 1;
 413                 }
 414         }
 415
 416         return 0;
 417 }
 418
 419 static int rna_validate_identifier(const char *identifier, char *error, bool property)
 420 {
 421         int a = 0;
 422
 423         /* list is from...
 424          * ", ".join(['"%s"' % kw for kw in  __import__("keyword").kwlist if kw not in {"False", "None", "True"}])
 425          */
 426         static const char *kwlist[] = {
 427                 /* "False", "None", "True", */
 428                 "and", "as", "assert", "break",
 429                 "class", "continue", "def", "del", "elif", "else", "except",
 430                 "finally", "for", "from", "global", "if", "import", "in",
 431                 "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
 432                 "return", "try", "while", "with", "yield", NULL
 433         };
 434
 435
 436         if (!isalpha(identifier[0])) {
 437                 strcpy(error, "first character failed isalpha() check");
 438                 return 0;
 439         }
 440
 441         for (a = 0; identifier[a]; a++) {
 442                 if (DefRNA.preprocess && property) {
 443                         if (isalpha(identifier[a]) && isupper(identifier[a])) {
 444                                 strcpy(error, "property names must contain lower case characters only");
 445                                 return 0;
 446                         }
 447                 }
 448
 449                 if (identifier[a] == '_') {
 450                         continue;
 451                 }
 452
 453                 if (identifier[a] == ' ') {
 454                         strcpy(error, "spaces are not okay in identifier names");
 455                         return 0;
 456                 }
 457
 458                 if (isalnum(identifier[a]) == 0) {
 459                         strcpy(error, "one of the characters failed an isalnum() check and is not an underscore");
 460                         return 0;
 461                 }
 462         }
 463
 464         for (a = 0; kwlist[a]; a++) {
 465                 if (STREQ(identifier, kwlist[a])) {
 466                         strcpy(error, "this keyword is reserved by python");
 467                         return 0;
 468                 }
 469         }
 470
 471         if (property) {
 472                 static const char *kwlist_prop[] = {
 473                         /* not keywords but reserved all the same because py uses */
 474                         "keys", "values", "items", "get",
 475                         NULL
 476                 };
 477
 478                 for (a = 0; kwlist_prop[a]; a++) {
 479                         if (STREQ(identifier, kwlist_prop[a])) {
 480                                 strcpy(error, "this keyword is reserved by python");
 481                                 return 0;
 482                         }
 483                 }
 484         }
 485
 486         return 1;
 487 }
 488
 489 void RNA_identifier_sanitize(char *identifier, int property)
 490 {
 491         int a = 0;
 492
 493         /*  list from http://docs.python.org/py3k/reference/lexical_analysis.html#keywords */
 494         static const char *kwlist[] = {
 495                 /* "False", "None", "True", */
 496                 "and", "as", "assert", "break",
 497                 "class", "continue", "def", "del", "elif", "else", "except",
 498                 "finally", "for", "from", "global", "if", "import", "in",
 499                 "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
 500                 "return", "try", "while", "with", "yield", NULL
 501         };
 502
 503
 504         if (!isalpha(identifier[0])) {
 505                 /* first character failed isalpha() check */
 506                 identifier[0] = '_';
 507         }
 508
 509         for (a = 0; identifier[a]; a++) {
 510                 if (DefRNA.preprocess && property) {
 511                         if (isalpha(identifier[a]) && isupper(identifier[a])) {
 512                                 /* property names must contain lower case characters only */
 513                                 identifier[a] = tolower(identifier[a]);
 514                         }
 515                 }
 516
 517                 if (identifier[a] == '_') {
 518                         continue;
 519                 }
 520
 521                 if (identifier[a] == ' ') {
 522                         /* spaces are not okay in identifier names */
 523                         identifier[a] = '_';
 524                 }
 525
 526                 if (isalnum(identifier[a]) == 0) {
 527                         /* one of the characters failed an isalnum() check and is not an underscore */
 528                         identifier[a] = '_';
 529                 }
 530         }
 531
 532         for (a = 0; kwlist[a]; a++) {
 533                 if (STREQ(identifier, kwlist[a])) {
 534                         /* this keyword is reserved by python.
 535                          * just replace the last character by '_' to keep it readable.
 536                          */
 537                         identifier[strlen(identifier) - 1] = '_';
 538                         break;
 539                 }
 540         }
 541
 542         if (property) {
 543                 static const char *kwlist_prop[] = {
 544                         /* not keywords but reserved all the same because py uses */
 545                         "keys", "values", "items", "get",
 546                         NULL
 547                 };
 548
 549                 for (a = 0; kwlist_prop[a]; a++) {
 550                         if (STREQ(identifier, kwlist_prop[a])) {
 551                                 /* this keyword is reserved by python.
 552                                  * just replace the last character by '_' to keep it readable.
 553                                  */
 554                                 identifier[strlen(identifier) - 1] = '_';
 555                                 break;
 556                         }
 557                 }
 558         }
 559 }
 560
 561 /* Blender Data Definition */
 562
 563 BlenderRNA *RNA_create(void)
 564 {
 565         BlenderRNA *brna;
 566
 567         brna = MEM_callocN(sizeof(BlenderRNA), "BlenderRNA");
 568         const char *error_message = NULL;
 569
 570         BLI_listbase_clear(&DefRNA.structs);
 571         brna->structs_map = BLI_ghash_str_new_ex(__func__, 2048);
 572
 573         DefRNA.error = 0;
 574         DefRNA.preprocess = 1;
 575
 576         DefRNA.sdna = DNA_sdna_from_data(DNAstr, DNAlen, false, false, &error_message);
 577         if (DefRNA.sdna == NULL) {
 578                 fprintf(stderr, "Error decoding SDNA: %s\n", error_message);
 579                 DefRNA.error = 1;
 580         }
 581
 582         return brna;
 583 }
 584
 585 void RNA_define_free(BlenderRNA *UNUSED(brna))
 586 {
 587         StructDefRNA *ds;
 588         FunctionDefRNA *dfunc;
 589         AllocDefRNA *alloc;
 590
 591         for (alloc = DefRNA.allocs.first; alloc; alloc = alloc->next)
 592                 MEM_freeN(alloc->mem);
 593         rna_freelistN(&DefRNA.allocs);
 594
 595         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
 596                 for (dfunc = ds->functions.first; dfunc; dfunc = dfunc->cont.next)
 597                         rna_freelistN(&dfunc->cont.properties);
 598
 599                 rna_freelistN(&ds->cont.properties);
 600                 rna_freelistN(&ds->functions);
 601         }
 602
 603         rna_freelistN(&DefRNA.structs);
 604
 605         if (DefRNA.sdna) {
 606                 DNA_sdna_free(DefRNA.sdna);
 607                 DefRNA.sdna = NULL;
 608         }
 609
 610         DefRNA.error = 0;
 611 }
 612
 613 void RNA_define_verify_sdna(bool verify)
 614 {
 615         DefRNA.verify = verify;
 616 }
 617
 618 #ifndef RNA_RUNTIME
 619 void RNA_define_animate_sdna(bool animate)
 620 {
 621         DefRNA.animate = animate;
 622 }
 623 #endif
 624
 625 void RNA_struct_free_extension(StructRNA *srna, ExtensionRNA *ext)
 626 {
 627 #ifdef RNA_RUNTIME
 628         ext->free(ext->data);                     /* decref's the PyObject that the srna owns */
 629         RNA_struct_blender_type_set(srna, NULL);  /* this gets accessed again - XXX fixme */
 630         RNA_struct_py_type_set(srna, NULL);       /* NULL the srna's value so RNA_struct_free wont complain of a leak */
 631 #else
 632         (void)srna;
 633         (void)ext;
 634 #endif
 635 }
 636
 637 void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
 638 {
 639 #ifdef RNA_RUNTIME
 640         FunctionRNA *func, *nextfunc;
 641         PropertyRNA *prop, *nextprop;
 642         PropertyRNA *parm, *nextparm;
 643
 644 #if 0
 645         if (srna->flag & STRUCT_RUNTIME) {
 646                 if (RNA_struct_py_type_get(srna)) {
 647                         fprintf(stderr, "%s '%s' freed while holding a python reference\n", __func__, srna->identifier);
 648                 }
 649         }
 650 #endif
 651
 652         for (prop = srna->cont.properties.first; prop; prop = nextprop) {
 653                 nextprop = prop->next;
 654
 655                 RNA_def_property_free_pointers(prop);
 656
 657                 if (prop->flag_internal & PROP_INTERN_RUNTIME)
 658                         rna_freelinkN(&srna->cont.properties, prop);
 659         }
 660
 661         for (func = srna->functions.first; func; func = nextfunc) {
 662                 nextfunc = func->cont.next;
 663
 664                 for (parm = func->cont.properties.first; parm; parm = nextparm) {
 665                         nextparm = parm->next;
 666
 667                         RNA_def_property_free_pointers(parm);
 668
 669                         if (parm->flag_internal & PROP_INTERN_RUNTIME)
 670                                 rna_freelinkN(&func->cont.properties, parm);
 671                 }
 672
 673                 RNA_def_func_free_pointers(func);
 674
 675                 if (func->flag & FUNC_RUNTIME)
 676                         rna_freelinkN(&srna->functions, func);
 677         }
 678
 679
 680         rna_brna_structs_remove_and_free(brna, srna);
 681 #else
 682         UNUSED_VARS(brna, srna);
 683 #endif
 684 }
 685
 686 void RNA_free(BlenderRNA *brna)
 687 {
 688         StructRNA *srna, *nextsrna;
 689         FunctionRNA *func;
 690
 691         BLI_ghash_free(brna->structs_map, NULL, NULL);
 692         brna->structs_map = NULL;
 693
 694         if (DefRNA.preprocess) {
 695                 RNA_define_free(brna);
 696
 697                 for (srna = brna->structs.first; srna; srna = srna->cont.next) {
 698                         for (func = srna->functions.first; func; func = func->cont.next)
 699                                 rna_freelistN(&func->cont.properties);
 700
 701                         rna_freelistN(&srna->cont.properties);
 702                         rna_freelistN(&srna->functions);
 703                 }
 704
 705                 rna_freelistN(&brna->structs);
 706
 707                 MEM_freeN(brna);
 708         }
 709         else {
 710                 for (srna = brna->structs.first; srna; srna = nextsrna) {
 711                         nextsrna = srna->cont.next;
 712                         RNA_struct_free(brna, srna);
 713                 }
 714         }
 715 }
 716
 717 static size_t rna_property_type_sizeof(PropertyType type)
 718 {
 719         switch (type) {
 720                 case PROP_BOOLEAN: return sizeof(BoolPropertyRNA);
 721                 case PROP_INT: return sizeof(IntPropertyRNA);
 722                 case PROP_FLOAT: return sizeof(FloatPropertyRNA);
 723                 case PROP_STRING: return sizeof(StringPropertyRNA);
 724                 case PROP_ENUM: return sizeof(EnumPropertyRNA);
 725                 case PROP_POINTER: return sizeof(PointerPropertyRNA);
 726                 case PROP_COLLECTION: return sizeof(CollectionPropertyRNA);
 727                 default: return 0;
 728         }
 729 }
 730
 731 static StructDefRNA *rna_find_def_struct(StructRNA *srna)
 732 {
 733         StructDefRNA *ds;
 734
 735         for (ds = DefRNA.structs.first; ds; ds = ds->cont.next)
 736                 if (ds->srna == srna)
 737                         return ds;
 738
 739         return NULL;
 740 }
 741
 742 /* Struct Definition */
 743 StructRNA *RNA_def_struct_ptr(BlenderRNA *brna, const char *identifier, StructRNA *srnafrom)
 744 {
 745         StructRNA *srna;
 746         StructDefRNA *ds = NULL, *dsfrom = NULL;
 747         PropertyRNA *prop;
 748
 749         if (DefRNA.preprocess) {
 750                 char error[512];
 751
 752                 if (rna_validate_identifier(identifier, error, false) == 0) {
 753                         fprintf(stderr, "%s: struct identifier \"%s\" error - %s\n", __func__, identifier, error);
 754                         DefRNA.error = 1;
 755                 }
 756         }
 757
 758         srna = MEM_callocN(sizeof(StructRNA), "StructRNA");
 759         DefRNA.laststruct = srna;
 760
 761         if (srnafrom) {
 762                 /* copy from struct to derive stuff, a bit clumsy since we can't
 763                  * use MEM_dupallocN, data structs may not be alloced but builtin */
 764                 memcpy(srna, srnafrom, sizeof(StructRNA));
 765                 srna->cont.prophash = NULL;
 766                 BLI_listbase_clear(&srna->cont.properties);
 767                 BLI_listbase_clear(&srna->functions);
 768                 srna->py_type = NULL;
 769
 770                 srna->base = srnafrom;
 771
 772                 if (DefRNA.preprocess) {
 773                         dsfrom = rna_find_def_struct(srnafrom);
 774                 }
 775                 else {
 776                         if (srnafrom->flag & STRUCT_PUBLIC_NAMESPACE_INHERIT) {
 777                                 srna->flag |= STRUCT_PUBLIC_NAMESPACE | STRUCT_PUBLIC_NAMESPACE_INHERIT;
 778                         }
 779                         else {
 780                                 srna->flag &= ~(STRUCT_PUBLIC_NAMESPACE | STRUCT_PUBLIC_NAMESPACE_INHERIT);
 781                         }
 782                 }
 783         }
 784
 785         srna->identifier = identifier;
 786         srna->name = identifier; /* may be overwritten later RNA_def_struct_ui_text */
 787         srna->description = "";
 788         /* may be overwritten later RNA_def_struct_translation_context */
 789         srna->translation_context = BLT_I18NCONTEXT_DEFAULT_BPYRNA;
 790         srna->flag |= STRUCT_UNDO;
 791         if (!srnafrom)
 792                 srna->icon = ICON_DOT;
 793
 794         if (DefRNA.preprocess) {
 795                 srna->flag |= STRUCT_PUBLIC_NAMESPACE;
 796         }
 797
 798         rna_brna_structs_add(brna, srna);
 799
 800         if (DefRNA.preprocess) {
 801                 ds = MEM_callocN(sizeof(StructDefRNA), "StructDefRNA");
 802                 ds->srna = srna;
 803                 rna_addtail(&DefRNA.structs, ds);
 804
 805                 if (dsfrom)
 806                         ds->dnafromname = dsfrom->dnaname;
 807         }
 808
 809         /* in preprocess, try to find sdna */
 810         if (DefRNA.preprocess)
 811                 RNA_def_struct_sdna(srna, srna->identifier);
 812         else
 813                 srna->flag |= STRUCT_RUNTIME;
 814
 815         if (srnafrom) {
 816                 srna->nameproperty = srnafrom->nameproperty;
 817                 srna->iteratorproperty = srnafrom->iteratorproperty;
 818         }
 819         else {
 820                 /* define some builtin properties */
 821                 prop = RNA_def_property(&srna->cont, "rna_properties", PROP_COLLECTION, PROP_NONE);
 822                 prop->flag_internal |= PROP_INTERN_BUILTIN;
 823                 RNA_def_property_ui_text(prop, "Properties", "RNA property collection");
 824
 825                 if (DefRNA.preprocess) {
 826                         RNA_def_property_struct_type(prop, "Property");
 827                         RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next",
 828                                                           "rna_iterator_listbase_end", "rna_builtin_properties_get", NULL, NULL,
 829                                                           "rna_builtin_properties_lookup_string", NULL);
 830                 }
 831                 else {
 832 #ifdef RNA_RUNTIME
 833                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
 834                         cprop->begin = rna_builtin_properties_begin;
 835                         cprop->next = rna_builtin_properties_next;
 836                         cprop->get = rna_builtin_properties_get;
 837                         cprop->item_type = &RNA_Property;
 838 #endif
 839                 }
 840
 841                 prop = RNA_def_property(&srna->cont, "rna_type", PROP_POINTER, PROP_NONE);
 842                 RNA_def_property_flag(prop, PROP_HIDDEN);
 843                 RNA_def_property_ui_text(prop, "RNA", "RNA type definition");
 844
 845                 if (DefRNA.preprocess) {
 846                         RNA_def_property_struct_type(prop, "Struct");
 847                         RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL, NULL);
 848                 }
 849                 else {
 850 #ifdef RNA_RUNTIME
 851                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
 852                         pprop->get = rna_builtin_type_get;
 853                         pprop->type = &RNA_Struct;
 854 #endif
 855                 }
 856         }
 857
 858         return srna;
 859 }
 860
 861 StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
 862 {
 863         StructRNA *srnafrom = NULL;
 864
 865         /* only use RNA_def_struct() while pre-processing, otherwise use RNA_def_struct_ptr() */
 866         BLI_assert(DefRNA.preprocess);
 867
 868         if (from) {
 869                 /* find struct to derive from */
 870                 /* Inline RNA_struct_find(...) because it wont link from here. */
 871                 srnafrom = BLI_ghash_lookup(brna->structs_map, from);
 872                 if (!srnafrom) {
 873                         fprintf(stderr, "%s: struct %s not found to define %s.\n", __func__, from, identifier);
 874                         DefRNA.error = 1;
 875                 }
 876         }
 877
 878         return RNA_def_struct_ptr(brna, identifier, srnafrom);
 879 }
 880
 881 void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
 882 {
 883         StructDefRNA *ds;
 884
 885         if (!DefRNA.preprocess) {
 886                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
 887                 return;
 888         }
 889
 890         ds = rna_find_def_struct(srna);
 891
 892         /* there are far too many structs which initialize without valid DNA struct names,
 893          * this can't be checked without adding an option to disable (tested this and it means changes all over - Campbell) */
 894 #if 0
 895         if (DNA_struct_find_nr(DefRNA.sdna, structname) == -1) {
 896                 if (!DefRNA.silent) {
 897                         fprintf(stderr, "%s: %s not found.\n", __func__, structname);
 898                         DefRNA.error = 1;
 899                 }
 900                 return;
 901         }
 902 #endif
 903
 904         ds->dnaname = structname;
 905 }
 906
 907 void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
 908 {
 909         StructDefRNA *ds;
 910
 911         if (!DefRNA.preprocess) {
 912                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
 913                 return;
 914         }
 915
 916         ds = rna_find_def_struct(srna);
 917
 918         if (!ds->dnaname) {
 919                 fprintf(stderr, "%s: %s base struct must know DNA already.\n", __func__, structname);
 920                 return;
 921         }
 922
 923         if (DNA_struct_find_nr(DefRNA.sdna, structname) == -1) {
 924                 if (!DefRNA.silent) {
 925                         fprintf(stderr, "%s: %s not found.\n", __func__, structname);
 926                         DefRNA.error = 1;
 927                 }
 928                 return;
 929         }
 930
 931         ds->dnafromprop = propname;
 932         ds->dnaname = structname;
 933 }
 934
 935 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 936 {
 937         if (prop->type != PROP_STRING) {
 938                 fprintf(stderr, "%s: \"%s.%s\", must be a string property.\n", __func__, srna->identifier, prop->identifier);
 939                 DefRNA.error = 1;
 940         }
 941         else
 942                 srna->nameproperty = prop;
 943 }
 944
 945 void RNA_def_struct_nested(BlenderRNA *brna, StructRNA *srna, const char *structname)
 946 {
 947         StructRNA *srnafrom;
 948
 949         /* find struct to derive from */
 950         srnafrom = BLI_ghash_lookup(brna->structs_map, structname);
 951         if (!srnafrom) {
 952                 fprintf(stderr, "%s: struct %s not found for %s.\n", __func__, structname, srna->identifier);
 953                 DefRNA.error = 1;
 954         }
 955
 956         srna->nested = srnafrom;
 957 }
 958
 959 void RNA_def_struct_flag(StructRNA *srna, int flag)
 960 {
 961         srna->flag |= flag;
 962 }
 963
 964 void RNA_def_struct_clear_flag(StructRNA *srna, int flag)
 965 {
 966         srna->flag &= ~flag;
 967 }
 968
 969 void RNA_def_struct_property_tags(StructRNA *srna, const EnumPropertyItem *prop_tag_defines)
 970 {
 971         srna->prop_tag_defines = prop_tag_defines;
 972 }
 973
 974 void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
 975 {
 976         if (!DefRNA.preprocess) {
 977                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
 978                 return;
 979         }
 980
 981         if (refine) srna->refine = (StructRefineFunc)refine;
 982 }
 983
 984 void RNA_def_struct_idprops_func(StructRNA *srna, const char *idproperties)
 985 {
 986         if (!DefRNA.preprocess) {
 987                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
 988                 return;
 989         }
 990
 991         if (idproperties) srna->idproperties = (IDPropertiesFunc)idproperties;
 992 }
 993
 994 void RNA_def_struct_register_funcs(StructRNA *srna, const char *reg, const char *unreg, const char *instance)
 995 {
 996         if (!DefRNA.preprocess) {
 997                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
 998                 return;
 999         }
1000
1001         if (reg) srna->reg = (StructRegisterFunc)reg;
1002         if (unreg) srna->unreg = (StructUnregisterFunc)unreg;
1003         if (instance) srna->instance = (StructInstanceFunc)instance;
1004 }
1005
1006 void RNA_def_struct_path_func(StructRNA *srna, const char *path)
1007 {
1008         if (!DefRNA.preprocess) {
1009                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1010                 return;
1011         }
1012
1013         if (path) srna->path = (StructPathFunc)path;
1014 }
1015
1016 void RNA_def_struct_identifier(BlenderRNA *brna, StructRNA *srna, const char *identifier)
1017 {
1018         if (DefRNA.preprocess) {
1019                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1020                 return;
1021         }
1022
1023         /* Operator registration may set twice, see: operator_properties_init */
1024         if (srna->flag & STRUCT_PUBLIC_NAMESPACE) {
1025                 if (identifier != srna->identifier) {
1026                         if (srna->identifier[0] != '\0') {
1027                                 BLI_ghash_remove(brna->structs_map, (void *)srna->identifier, NULL, NULL);
1028                         }
1029                         if (identifier[0] != '\0') {
1030                                 BLI_ghash_insert(brna->structs_map, (void *)identifier, srna);
1031                         }
1032                 }
1033         }
1034
1035         srna->identifier = identifier;
1036 }
1037
1038 /**
1039  * Only used in one case when we name the struct for the purpose of useful error messages.
1040  */
1041 void RNA_def_struct_identifier_no_struct_map(StructRNA *srna, const char *identifier)
1042 {
1043         if (DefRNA.preprocess) {
1044                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1045                 return;
1046         }
1047
1048         srna->identifier = identifier;
1049 }
1050
1051 void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
1052 {
1053         DESCR_CHECK(description, srna->identifier, NULL);
1054
1055         srna->name = name;
1056         srna->description = description;
1057 }
1058
1059 void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
1060 {
1061         srna->icon = icon;
1062 }
1063
1064 void RNA_def_struct_translation_context(StructRNA *srna, const char *context)
1065 {
1066         srna->translation_context = context ? context : BLT_I18NCONTEXT_DEFAULT_BPYRNA;
1067 }
1068
1069 /* Property Definition */
1070
1071 PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier, int type, int subtype)
1072 {
1073         /*StructRNA *srna = DefRNA.laststruct;*/ /* invalid for python defined props */
1074         ContainerRNA *cont = cont_;
1075         ContainerDefRNA *dcont;
1076         PropertyDefRNA *dprop = NULL;
1077         PropertyRNA *prop;
1078
1079         if (DefRNA.preprocess) {
1080                 char error[512];
1081
1082                 if (rna_validate_identifier(identifier, error, true) == 0) {
1083                         fprintf(stderr, "%s: property identifier \"%s.%s\" - %s\n", __func__,
1084                                 CONTAINER_RNA_ID(cont), identifier, error);
1085                         DefRNA.error = 1;
1086                 }
1087
1088                 dcont = rna_find_container_def(cont);
1089
1090                 /* XXX - toto, detect supertype collisions */
1091                 if (rna_findlink(&dcont->properties, identifier)) {
1092                         fprintf(stderr, "%s: duplicate identifier \"%s.%s\"\n", __func__, CONTAINER_RNA_ID(cont), identifier);
1093                         DefRNA.error = 1;
1094                 }
1095
1096                 dprop = MEM_callocN(sizeof(PropertyDefRNA), "PropertyDefRNA");
1097                 rna_addtail(&dcont->properties, dprop);
1098         }
1099         else {
1100 #ifdef DEBUG
1101                 char error[512];
1102                 if (rna_validate_identifier(identifier, error, true) == 0) {
1103                         fprintf(stderr, "%s: runtime property identifier \"%s.%s\" - %s\n", __func__,
1104                                 CONTAINER_RNA_ID(cont), identifier, error);
1105                         DefRNA.error = 1;
1106                 }
1107 #endif
1108         }
1109
1110         prop = MEM_callocN(rna_property_type_sizeof(type), "PropertyRNA");
1111
1112         switch (type) {
1113                 case PROP_BOOLEAN:
1114                         if (DefRNA.preprocess) {
1115                                 if ((subtype & ~(PROP_LAYER_MEMBER)) != PROP_NONE) {
1116                                         fprintf(stderr, "%s: subtype does not apply to 'PROP_BOOLEAN' \"%s.%s\"\n", __func__,
1117                                                 CONTAINER_RNA_ID(cont), identifier);
1118                                         DefRNA.error = 1;
1119                                 }
1120                         }
1121                         break;
1122                 case PROP_INT:
1123                 {
1124                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1125
1126 #ifndef RNA_RUNTIME
1127                         if (subtype == PROP_DISTANCE) {
1128                                 fprintf(stderr, "%s: subtype does not apply to 'PROP_INT' \"%s.%s\"\n", __func__,
1129                                         CONTAINER_RNA_ID(cont), identifier);
1130                                 DefRNA.error = 1;
1131                         }
1132 #endif
1133
1134                         iprop->hardmin = (subtype == PROP_UNSIGNED) ? 0 : INT_MIN;
1135                         iprop->hardmax = INT_MAX;
1136
1137                         iprop->softmin = (subtype == PROP_UNSIGNED) ? 0 : -10000; /* rather arbitrary .. */
1138                         iprop->softmax = 10000;
1139                         iprop->step = 1;
1140                         break;
1141                 }
1142                 case PROP_FLOAT:
1143                 {
1144                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1145
1146                         fprop->hardmin = (subtype == PROP_UNSIGNED) ? 0.0f : -FLT_MAX;
1147                         fprop->hardmax = FLT_MAX;
1148
1149                         if (ELEM(subtype, PROP_COLOR, PROP_COLOR_GAMMA)) {
1150                                 fprop->softmin = fprop->hardmin = 0.0f;
1151                                 fprop->softmax = 1.0f;
1152                         }
1153                         else if (subtype == PROP_FACTOR) {
1154                                 fprop->softmin = fprop->hardmin = 0.0f;
1155                                 fprop->softmax = fprop->hardmax = 1.0f;
1156                         }
1157                         else {
1158                                 fprop->softmin = (subtype == PROP_UNSIGNED) ? 0.0f : -10000.0f; /* rather arbitrary .. */
1159                                 fprop->softmax = 10000.0f;
1160                         }
1161                         fprop->step = 10;
1162                         fprop->precision = 3;
1163                         break;
1164                 }
1165                 case PROP_STRING:
1166                 {
1167                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1168                         /* By default don't allow NULL string args, callers may clear. */
1169                         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1170                         sprop->defaultvalue = "";
1171                         break;
1172                 }
1173                 case PROP_POINTER:
1174                         prop->flag |= PROP_THICK_WRAP;  /* needed for default behavior when PARM_RNAPTR is set */
1175                         break;
1176                 case PROP_ENUM:
1177                 case PROP_COLLECTION:
1178                         break;
1179                 default:
1180                         fprintf(stderr, "%s: \"%s.%s\", invalid property type.\n", __func__, CONTAINER_RNA_ID(cont), identifier);
1181                         DefRNA.error = 1;
1182                         return NULL;
1183         }
1184
1185         if (DefRNA.preprocess) {
1186                 dprop->cont = cont;
1187                 dprop->prop = prop;
1188         }
1189
1190         prop->magic = RNA_MAGIC;
1191         prop->identifier = identifier;
1192         prop->type = type;
1193         prop->subtype = subtype;
1194         prop->name = identifier;
1195         prop->description = "";
1196         prop->translation_context = BLT_I18NCONTEXT_DEFAULT_BPYRNA;
1197         /* a priori not raw editable */
1198         prop->rawtype = -1;
1199
1200         if (type != PROP_COLLECTION && type != PROP_POINTER) {
1201                 prop->flag = PROP_EDITABLE;
1202
1203                 if (type != PROP_STRING) {
1204 #ifdef RNA_RUNTIME
1205                         prop->flag |= PROP_ANIMATABLE;
1206 #else
1207                         if (DefRNA.animate) {
1208                                 prop->flag |= PROP_ANIMATABLE;
1209                         }
1210 #endif
1211                 }
1212         }
1213
1214         if (type == PROP_STRING) {
1215                 /* used so generated 'get/length/set' functions skip a NULL check
1216                  * in some cases we want it */
1217                 RNA_def_property_flag(prop, PROP_NEVER_NULL);
1218         }
1219
1220         if (DefRNA.preprocess) {
1221                 switch (type) {
1222                         case PROP_BOOLEAN:
1223                                 DefRNA.silent = 1;
1224                                 RNA_def_property_boolean_sdna(prop, NULL, identifier, 0);
1225                                 DefRNA.silent = 0;
1226                                 break;
1227                         case PROP_INT:
1228                         {
1229                                 DefRNA.silent = 1;
1230                                 RNA_def_property_int_sdna(prop, NULL, identifier);
1231                                 DefRNA.silent = 0;
1232                                 break;
1233                         }
1234                         case PROP_FLOAT:
1235                         {
1236                                 DefRNA.silent = 1;
1237                                 RNA_def_property_float_sdna(prop, NULL, identifier);
1238                                 DefRNA.silent = 0;
1239                                 break;
1240                         }
1241                         case PROP_STRING:
1242                         {
1243                                 DefRNA.silent = 1;
1244                                 RNA_def_property_string_sdna(prop, NULL, identifier);
1245                                 DefRNA.silent = 0;
1246                                 break;
1247                         }
1248                         case PROP_ENUM:
1249                                 DefRNA.silent = 1;
1250                                 RNA_def_property_enum_sdna(prop, NULL, identifier);
1251                                 DefRNA.silent = 0;
1252                                 break;
1253                         case PROP_POINTER:
1254                                 DefRNA.silent = 1;
1255                                 RNA_def_property_pointer_sdna(prop, NULL, identifier);
1256                                 DefRNA.silent = 0;
1257                                 break;
1258                         case PROP_COLLECTION:
1259                                 DefRNA.silent = 1;
1260                                 RNA_def_property_collection_sdna(prop, NULL, identifier, NULL);
1261                                 DefRNA.silent = 0;
1262                                 break;
1263                 }
1264         }
1265         else {
1266                 prop->flag |= PROP_IDPROPERTY;
1267                 prop->flag_internal |= PROP_INTERN_RUNTIME;
1268 #ifdef RNA_RUNTIME
1269                 if (cont->prophash)
1270                         BLI_ghash_insert(cont->prophash, (void *)prop->identifier, prop);
1271 #endif
1272         }
1273
1274         /* Override handling. */
1275         if (DefRNA.preprocess) {
1276                 prop->override_diff = (RNAPropOverrideDiff)"rna_property_override_diff_default";
1277                 prop->override_store = (RNAPropOverrideStore)"rna_property_override_store_default";
1278                 prop->override_apply = (RNAPropOverrideApply)"rna_property_override_apply_default";
1279         }
1280         /* TODO: do we want that for runtime-defined stuff too? I’d say no, but... maybe yes :/ */
1281
1282         rna_addtail(&cont->properties, prop);
1283
1284         return prop;
1285 }
1286
1287 void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
1288 {
1289         prop->flag |= flag;
1290 }
1291
1292 void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
1293 {
1294         prop->flag &= ~flag;
1295 }
1296
1297 void RNA_def_property_override_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
1298 {
1299         prop->flag_override |= flag;
1300 }
1301
1302 void RNA_def_property_override_clear_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
1303 {
1304         prop->flag_override &= ~flag;
1305 }
1306
1307 /**
1308  * Add the property-tags passed as \a tags to \a prop (if valid).
1309  *
1310  * \note Multiple tags can be set by passing them within \a tags (using bitflags).
1311  * \note Doesn't do any type-checking with the tags defined in the parent StructRNA
1312  *       of \a prop. This should be done before (e.g. see #WM_operatortype_prop_tag).
1313  */
1314 void RNA_def_property_tags(PropertyRNA *prop, int tags)
1315 {
1316         prop->tags |= tags;
1317 }
1318
1319 void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
1320 {
1321         prop->flag |= flag_property;
1322         prop->flag_parameter |= flag_parameter;
1323 }
1324
1325 void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
1326 {
1327         prop->flag &= ~flag_property;
1328         prop->flag_parameter &= ~flag_parameter;
1329 }
1330
1331 void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
1332 {
1333         prop->subtype = subtype;
1334 }
1335
1336 void RNA_def_property_array(PropertyRNA *prop, int length)
1337 {
1338         StructRNA *srna = DefRNA.laststruct;
1339
1340         if (length < 0) {
1341                 fprintf(stderr, "%s: \"%s.%s\", array length must be zero of greater.\n", __func__,
1342                         srna->identifier, prop->identifier);
1343                 DefRNA.error = 1;
1344                 return;
1345         }
1346
1347         if (length > RNA_MAX_ARRAY_LENGTH) {
1348                 fprintf(stderr, "%s: \"%s.%s\", array length must be smaller than %d.\n", __func__,
1349                         srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
1350                 DefRNA.error = 1;
1351                 return;
1352         }
1353
1354         if (prop->arraydimension > 1) {
1355                 fprintf(stderr, "%s: \"%s.%s\", array dimensions has been set to %u but would be overwritten as 1.\n",
1356                         __func__, srna->identifier, prop->identifier, prop->arraydimension);
1357                 DefRNA.error = 1;
1358                 return;
1359         }
1360
1361         switch (prop->type) {
1362                 case PROP_BOOLEAN:
1363                 case PROP_INT:
1364                 case PROP_FLOAT:
1365                         prop->arraylength[0] = length;
1366                         prop->totarraylength = length;
1367                         prop->arraydimension = 1;
1368                         break;
1369                 default:
1370                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1371                                 __func__, srna->identifier, prop->identifier);
1372                         DefRNA.error = 1;
1373                         break;
1374         }
1375 }
1376
1377 /* common args for length */
1378 const int rna_matrix_dimsize_3x3[] = {3, 3};
1379 const int rna_matrix_dimsize_4x4[] = {4, 4};
1380 const int rna_matrix_dimsize_4x2[] = {4, 2};
1381
1382 void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
1383 {
1384         StructRNA *srna = DefRNA.laststruct;
1385         int i;
1386
1387         if (dimension < 1 || dimension > RNA_MAX_ARRAY_DIMENSION) {
1388                 fprintf(stderr, "%s: \"%s.%s\", array dimension must be between 1 and %d.\n",
1389                         __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
1390                 DefRNA.error = 1;
1391                 return;
1392         }
1393
1394         switch (prop->type) {
1395                 case PROP_BOOLEAN:
1396                 case PROP_INT:
1397                 case PROP_FLOAT:
1398                         break;
1399                 default:
1400                         fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
1401                                 __func__, srna->identifier, prop->identifier);
1402                         DefRNA.error = 1;
1403                         break;
1404         }
1405
1406         prop->arraydimension = dimension;
1407         prop->totarraylength = 0;
1408
1409         if (length) {
1410                 memcpy(prop->arraylength, length, sizeof(int) * dimension);
1411
1412                 prop->totarraylength = length[0];
1413                 for (i = 1; i < dimension; i++)
1414                         prop->totarraylength *= length[i];
1415         }
1416         else
1417                 memset(prop->arraylength, 0, sizeof(prop->arraylength));
1418
1419         /* TODO make sure arraylength values are sane  */
1420 }
1421
1422 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
1423 {
1424         DESCR_CHECK(description, prop->identifier, NULL);
1425
1426         prop->name = name;
1427         prop->description = description;
1428 }
1429
1430 void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
1431 {
1432         prop->icon = icon;
1433         if (consecutive != 0)
1434                 prop->flag |= PROP_ICONS_CONSECUTIVE;
1435         if (consecutive < 0)
1436                 prop->flag |= PROP_ICONS_REVERSE;
1437 }
1438
1439 /**
1440  * The values hare are a little confusing:
1441  *
1442  * \param step: Used as the value to increase/decrease when clicking on number buttons,
1443  * as well as scaling mouse input for click-dragging number buttons.
1444  * For floats this is (step * UI_PRECISION_FLOAT_SCALE), why? - nobody knows.
1445  * For ints, whole values are used.
1446  *
1447  * \param precision The number of zeros to show
1448  * (as a whole number - common range is 1 - 6), see UI_PRECISION_FLOAT_MAX
1449  */
1450 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
1451 {
1452         StructRNA *srna = DefRNA.laststruct;
1453
1454 #ifndef NDEBUG
1455         if (min > max) {
1456                 fprintf(stderr, "%s: \"%s.%s\", min > max.\n",
1457                         __func__, srna->identifier, prop->identifier);
1458                 DefRNA.error = 1;
1459         }
1460
1461         if (step < 0 || step > 100) {
1462                 fprintf(stderr, "%s: \"%s.%s\", step outside range.\n",
1463                         __func__, srna->identifier, prop->identifier);
1464                 DefRNA.error = 1;
1465         }
1466
1467         if (precision < -1 || precision > UI_PRECISION_FLOAT_MAX) {
1468                 fprintf(stderr, "%s: \"%s.%s\", precision outside range.\n",
1469                         __func__, srna->identifier, prop->identifier);
1470                 DefRNA.error = 1;
1471         }
1472 #endif
1473
1474         switch (prop->type) {
1475                 case PROP_INT:
1476                 {
1477                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1478                         iprop->softmin = (int)min;
1479                         iprop->softmax = (int)max;
1480                         iprop->step = (int)step;
1481                         break;
1482                 }
1483                 case PROP_FLOAT:
1484                 {
1485                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1486                         fprop->softmin = (float)min;
1487                         fprop->softmax = (float)max;
1488                         fprop->step = (float)step;
1489                         fprop->precision = (int)precision;
1490                         break;
1491                 }
1492                 default:
1493                         fprintf(stderr, "%s: \"%s.%s\", invalid type for ui range.\n",
1494                                 __func__, srna->identifier, prop->identifier);
1495                         DefRNA.error = 1;
1496                         break;
1497         }
1498 }
1499
1500 void RNA_def_property_range(PropertyRNA *prop, double min, double max)
1501 {
1502         StructRNA *srna = DefRNA.laststruct;
1503
1504 #ifdef DEBUG
1505         if (min > max) {
1506                 fprintf(stderr, "%s: \"%s.%s\", min > max.\n",
1507                         __func__, srna->identifier, prop->identifier);
1508                 DefRNA.error = 1;
1509         }
1510 #endif
1511
1512         switch (prop->type) {
1513                 case PROP_INT:
1514                 {
1515                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1516                         iprop->hardmin = (int)min;
1517                         iprop->hardmax = (int)max;
1518                         iprop->softmin = MAX2((int)min, iprop->hardmin);
1519                         iprop->softmax = MIN2((int)max, iprop->hardmax);
1520                         break;
1521                 }
1522                 case PROP_FLOAT:
1523                 {
1524                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1525                         fprop->hardmin = (float)min;
1526                         fprop->hardmax = (float)max;
1527                         fprop->softmin = MAX2((float)min, fprop->hardmin);
1528                         fprop->softmax = MIN2((float)max, fprop->hardmax);
1529                         break;
1530                 }
1531                 default:
1532                         fprintf(stderr, "%s: \"%s.%s\", invalid type for range.\n", __func__, srna->identifier, prop->identifier);
1533                         DefRNA.error = 1;
1534                         break;
1535         }
1536 }
1537
1538 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
1539 {
1540         StructRNA *srna = DefRNA.laststruct;
1541
1542         if (!DefRNA.preprocess) {
1543                 fprintf(stderr, "%s \"%s.%s\": only during preprocessing.\n", __func__, srna->identifier, prop->identifier);
1544                 return;
1545         }
1546
1547         switch (prop->type) {
1548                 case PROP_POINTER:
1549                 {
1550                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
1551                         pprop->type = (StructRNA *)type;
1552                         break;
1553                 }
1554                 case PROP_COLLECTION:
1555                 {
1556                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1557                         cprop->item_type = (StructRNA *)type;
1558                         break;
1559                 }
1560                 default:
1561                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1562                                 __func__, srna->identifier, prop->identifier);
1563                         DefRNA.error = 1;
1564                         break;
1565         }
1566 }
1567
1568 void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
1569 {
1570         StructRNA *srna = DefRNA.laststruct;
1571
1572         if (DefRNA.preprocess) {
1573                 fprintf(stderr, "%s: only at runtime.\n", __func__);
1574                 return;
1575         }
1576
1577         switch (prop->type) {
1578                 case PROP_POINTER:
1579                 {
1580                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
1581                         pprop->type = type;
1582
1583                         if (type && (type->flag & STRUCT_ID_REFCOUNT))
1584                                 prop->flag |= PROP_ID_REFCOUNT;
1585
1586                         break;
1587                 }
1588                 case PROP_COLLECTION:
1589                 {
1590                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1591                         cprop->item_type = type;
1592                         break;
1593                 }
1594                 default:
1595                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1596                                 __func__, srna->identifier, prop->identifier);
1597                         DefRNA.error = 1;
1598                         break;
1599         }
1600 }
1601
1602 void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
1603 {
1604         StructRNA *srna = DefRNA.laststruct;
1605         int i, defaultfound = 0;
1606
1607         switch (prop->type) {
1608                 case PROP_ENUM:
1609                 {
1610                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1611                         eprop->item = (EnumPropertyItem *)item;
1612                         eprop->totitem = 0;
1613                         for (i = 0; item[i].identifier; i++) {
1614                                 eprop->totitem++;
1615
1616                                 if (item[i].identifier[0] && item[i].value == eprop->defaultvalue)
1617                                         defaultfound = 1;
1618                         }
1619
1620                         if (!defaultfound) {
1621                                 for (i = 0; item[i].identifier; i++) {
1622                                         if (item[i].identifier[0]) {
1623                                                 eprop->defaultvalue = item[i].value;
1624                                                 break;
1625                                         }
1626                                 }
1627                         }
1628
1629                         break;
1630                 }
1631                 default:
1632                         fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
1633                                 __func__, srna->identifier, prop->identifier);
1634                         DefRNA.error = 1;
1635                         break;
1636         }
1637 }
1638
1639 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
1640 {
1641         StructRNA *srna = DefRNA.laststruct;
1642
1643         switch (prop->type) {
1644                 case PROP_STRING:
1645                 {
1646                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1647                         sprop->maxlength = maxlength;
1648                         break;
1649                 }
1650                 default:
1651                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1652                         DefRNA.error = 1;
1653                         break;
1654         }
1655 }
1656
1657 void RNA_def_property_boolean_default(PropertyRNA *prop, bool value)
1658 {
1659         StructRNA *srna = DefRNA.laststruct;
1660
1661         switch (prop->type) {
1662                 case PROP_BOOLEAN:
1663                 {
1664                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
1665                         BLI_assert(ELEM(value, false, true));
1666                         bprop->defaultvalue = value;
1667                         break;
1668                 }
1669                 default:
1670                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1671                         DefRNA.error = 1;
1672                         break;
1673         }
1674 }
1675
1676 void RNA_def_property_boolean_array_default(PropertyRNA *prop, const bool *array)
1677 {
1678         StructRNA *srna = DefRNA.laststruct;
1679
1680         switch (prop->type) {
1681                 case PROP_BOOLEAN:
1682                 {
1683                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
1684                         bprop->defaultarray = array;
1685                         break;
1686                 }
1687                 default:
1688                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1689                         DefRNA.error = 1;
1690                         break;
1691         }
1692 }
1693
1694 void RNA_def_property_int_default(PropertyRNA *prop, int value)
1695 {
1696         StructRNA *srna = DefRNA.laststruct;
1697
1698         switch (prop->type) {
1699                 case PROP_INT:
1700                 {
1701                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1702                         iprop->defaultvalue = value;
1703                         break;
1704                 }
1705                 default:
1706                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1707                         DefRNA.error = 1;
1708                         break;
1709         }
1710 }
1711
1712 void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
1713 {
1714         StructRNA *srna = DefRNA.laststruct;
1715
1716         switch (prop->type) {
1717                 case PROP_INT:
1718                 {
1719                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1720                         iprop->defaultarray = array;
1721                         break;
1722                 }
1723                 default:
1724                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1725                         DefRNA.error = 1;
1726                         break;
1727         }
1728 }
1729
1730 void RNA_def_property_float_default(PropertyRNA *prop, float value)
1731 {
1732         StructRNA *srna = DefRNA.laststruct;
1733
1734         switch (prop->type) {
1735                 case PROP_FLOAT:
1736                 {
1737                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1738                         fprop->defaultvalue = value;
1739                         break;
1740                 }
1741                 default:
1742                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1743                         DefRNA.error = 1;
1744                         break;
1745         }
1746 }
1747 /* array must remain valid after this function finishes */
1748 void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
1749 {
1750         StructRNA *srna = DefRNA.laststruct;
1751
1752         switch (prop->type) {
1753                 case PROP_FLOAT:
1754                 {
1755                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1756                         fprop->defaultarray = array; /* WARNING, this array must not come from the stack and lost */
1757                         break;
1758                 }
1759                 default:
1760                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
1761                         DefRNA.error = 1;
1762                         break;
1763         }
1764 }
1765
1766 void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
1767 {
1768         StructRNA *srna = DefRNA.laststruct;
1769
1770         switch (prop->type) {
1771                 case PROP_STRING:
1772                 {
1773                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1774
1775                         if (value == NULL) {
1776                                 fprintf(stderr, "%s: \"%s.%s\", NULL string passed (dont call in this case).\n", __func__, srna->identifier, prop->identifier);
1777                                 DefRNA.error = 1;
1778                                 break;
1779                         }
1780
1781                         if (!value[0]) {
1782                                 fprintf(stderr, "%s: \"%s.%s\", empty string passed (dont call in this case).\n", __func__, srna->identifier, prop->identifier);
1783                                 DefRNA.error = 1;
1784                                 // BLI_assert(0);
1785                                 break;
1786                         }
1787
1788                         sprop->defaultvalue = value;
1789                         break;
1790                 }
1791                 default:
1792                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
1793                         DefRNA.error = 1;
1794                         break;
1795         }
1796 }
1797
1798 void RNA_def_property_enum_default(PropertyRNA *prop, int value)
1799 {
1800         StructRNA *srna = DefRNA.laststruct;
1801         int i, defaultfound = 0;
1802
1803         switch (prop->type) {
1804                 case PROP_ENUM:
1805                 {
1806                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1807                         eprop->defaultvalue = value;
1808
1809                         if (prop->flag & PROP_ENUM_FLAG) {
1810                                 /* check all bits are accounted for */
1811                                 int totflag = 0;
1812                                 for (i = 0; i < eprop->totitem; i++) {
1813                                         if (eprop->item[i].identifier[0]) {
1814                                                 totflag |= eprop->item[i].value;
1815                                         }
1816                                 }
1817
1818                                 if (eprop->defaultvalue & ~totflag) {
1819                                         fprintf(stderr, "%s: \"%s.%s\", default includes unused bits (%d).\n",
1820                                                 __func__, srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
1821                                         DefRNA.error = 1;
1822                                 }
1823                         }
1824                         else {
1825                                 for (i = 0; i < eprop->totitem; i++) {
1826                                         if (eprop->item[i].identifier[0] && eprop->item[i].value == eprop->defaultvalue)
1827                                                 defaultfound = 1;
1828                                 }
1829
1830                                 if (!defaultfound && eprop->totitem) {
1831                                         if (value == 0) {
1832                                                 eprop->defaultvalue = eprop->item[0].value;
1833                                         }
1834                                         else {
1835                                                 fprintf(stderr, "%s: \"%s.%s\", default is not in items.\n",
1836                                                         __func__, srna->identifier, prop->identifier);
1837                                                 DefRNA.error = 1;
1838                                         }
1839                                 }
1840                         }
1841
1842                         break;
1843                 }
1844                 default:
1845                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
1846                         DefRNA.error = 1;
1847                         break;
1848         }
1849 }
1850
1851 /* SDNA */
1852
1853 static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1854 {
1855         DNAStructMember smember;
1856         StructDefRNA *ds;
1857         PropertyDefRNA *dp;
1858
1859         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1860         if (dp == NULL) return NULL;
1861
1862         ds = rna_find_struct_def((StructRNA *)dp->cont);
1863
1864         if (!structname)
1865                 structname = ds->dnaname;
1866         if (!propname)
1867                 propname = prop->identifier;
1868
1869         if (!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
1870                 if (DefRNA.silent) {
1871                         return NULL;
1872                 }
1873                 else if (!DefRNA.verify) {
1874                         /* some basic values to survive even with sdna info */
1875                         dp->dnastructname = structname;
1876                         dp->dnaname = propname;
1877                         if (prop->type == PROP_BOOLEAN)
1878                                 dp->dnaarraylength = 1;
1879                         if (prop->type == PROP_POINTER)
1880                                 dp->dnapointerlevel = 1;
1881                         return dp;
1882                 }
1883                 else {
1884                         fprintf(stderr, "%s: \"%s.%s\" (identifier \"%s\") not found. Struct must be in DNA.\n",
1885                                 __func__, structname, propname, prop->identifier);
1886                         DefRNA.error = 1;
1887                         return NULL;
1888                 }
1889         }
1890
1891         if (smember.arraylength > 1) {
1892                 prop->arraylength[0] = smember.arraylength;
1893                 prop->totarraylength = smember.arraylength;
1894                 prop->arraydimension = 1;
1895         }
1896         else {
1897                 prop->arraydimension = 0;
1898                 prop->totarraylength = 0;
1899         }
1900
1901         dp->dnastructname = structname;
1902         dp->dnastructfromname = ds->dnafromname;
1903         dp->dnastructfromprop = ds->dnafromprop;
1904         dp->dnaname = propname;
1905         dp->dnatype = smember.type;
1906         dp->dnaarraylength = smember.arraylength;
1907         dp->dnapointerlevel = smember.pointerlevel;
1908
1909         return dp;
1910 }
1911
1912 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit)
1913 {
1914         PropertyDefRNA *dp;
1915         StructRNA *srna = DefRNA.laststruct;
1916
1917         if (!DefRNA.preprocess) {
1918                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1919                 return;
1920         }
1921
1922         if (prop->type != PROP_BOOLEAN) {
1923                 fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
1924                 DefRNA.error = 1;
1925                 return;
1926         }
1927
1928         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1929
1930                 if (DefRNA.silent == 0) {
1931                         /* error check to ensure floats are not wrapped as ints/bools */
1932                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1933                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1934                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1935                                 DefRNA.error = 1;
1936                                 return;
1937                         }
1938                 }
1939
1940                 dp->booleanbit = bit;
1941         }
1942 }
1943
1944 void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname,
1945                                             const char *propname, int booleanbit)
1946 {
1947         PropertyDefRNA *dp;
1948
1949         RNA_def_property_boolean_sdna(prop, structname, propname, booleanbit);
1950
1951         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
1952
1953         if (dp)
1954                 dp->booleannegative = 1;
1955 }
1956
1957 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
1958 {
1959         PropertyDefRNA *dp;
1960         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1961         StructRNA *srna = DefRNA.laststruct;
1962
1963         if (!DefRNA.preprocess) {
1964                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
1965                 return;
1966         }
1967
1968         if (prop->type != PROP_INT) {
1969                 fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
1970                 DefRNA.error = 1;
1971                 return;
1972         }
1973
1974         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
1975
1976                 /* error check to ensure floats are not wrapped as ints/bools */
1977                 if (DefRNA.silent == 0) {
1978                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
1979                                 fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
1980                                         __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
1981                                 DefRNA.error = 1;
1982                                 return;
1983                         }
1984                 }
1985
1986                 /* SDNA doesn't pass us unsigned unfortunately .. */
1987                 if (dp->dnatype && STREQ(dp->dnatype, "char")) {
1988                         iprop->hardmin = iprop->softmin = CHAR_MIN;
1989                         iprop->hardmax = iprop->softmax = CHAR_MAX;
1990                 }
1991                 else if (dp->dnatype && STREQ(dp->dnatype, "short")) {
1992                         iprop->hardmin = iprop->softmin = SHRT_MIN;
1993                         iprop->hardmax = iprop->softmax = SHRT_MAX;
1994                 }
1995                 else if (dp->dnatype && STREQ(dp->dnatype, "int")) {
1996                         iprop->hardmin = INT_MIN;
1997                         iprop->hardmax = INT_MAX;
1998
1999                         iprop->softmin = -10000; /* rather arbitrary .. */
2000                         iprop->softmax = 10000;
2001                 }
2002
2003                 if (prop->subtype == PROP_UNSIGNED || prop->subtype == PROP_PERCENTAGE || prop->subtype == PROP_FACTOR)
2004                         iprop->hardmin = iprop->softmin = 0;
2005         }
2006 }
2007
2008 void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2009 {
2010         PropertyDefRNA *dp;
2011         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2012         StructRNA *srna = DefRNA.laststruct;
2013
2014         if (!DefRNA.preprocess) {
2015                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2016                 return;
2017         }
2018
2019         if (prop->type != PROP_FLOAT) {
2020                 fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
2021                 DefRNA.error = 1;
2022                 return;
2023         }
2024
2025         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
2026                 /* silent is for internal use */
2027                 if (DefRNA.silent == 0) {
2028                         if (dp->dnatype && *dp->dnatype && IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
2029                                 if (prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
2030                                         fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
2031                                                 __func__, srna->identifier, prop->identifier, dp->dnatype,
2032                                                 RNA_property_typename(prop->type));
2033                                         DefRNA.error = 1;
2034                                         return;
2035                                 }
2036                         }
2037                 }
2038
2039                 if (dp->dnatype && STREQ(dp->dnatype, "char")) {
2040                         fprop->hardmin = fprop->softmin = 0.0f;
2041                         fprop->hardmax = fprop->softmax = 1.0f;
2042                 }
2043         }
2044
2045         rna_def_property_sdna(prop, structname, propname);
2046 }
2047
2048 void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2049 {
2050         /* PropertyDefRNA *dp; */
2051         StructRNA *srna = DefRNA.laststruct;
2052
2053         if (!DefRNA.preprocess) {
2054                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2055                 return;
2056         }
2057
2058         if (prop->type != PROP_ENUM) {
2059                 fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
2060                 DefRNA.error = 1;
2061                 return;
2062         }
2063
2064         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2065                 if (prop->arraydimension) {
2066                         prop->arraydimension = 0;
2067                         prop->totarraylength = 0;
2068
2069                         if (!DefRNA.silent) {
2070                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for enum type.\n",
2071                                         __func__, structname, propname);
2072                                 DefRNA.error = 1;
2073                         }
2074                 }
2075         }
2076 }
2077
2078 void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2079 {
2080         PropertyDefRNA *dp;
2081
2082         RNA_def_property_enum_sdna(prop, structname, propname);
2083
2084         dp = rna_find_struct_property_def(DefRNA.laststruct, prop);
2085
2086         if (dp)
2087                 dp->enumbitflags = 1;
2088 }
2089
2090 void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2091 {
2092         /* PropertyDefRNA *dp; */
2093         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2094         StructRNA *srna = DefRNA.laststruct;
2095
2096         if (!DefRNA.preprocess) {
2097                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2098                 return;
2099         }
2100
2101         if (prop->type != PROP_STRING) {
2102                 fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
2103                 DefRNA.error = 1;
2104                 return;
2105         }
2106
2107         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2108                 if (prop->arraydimension) {
2109                         sprop->maxlength = prop->totarraylength;
2110                         prop->arraydimension = 0;
2111                         prop->totarraylength = 0;
2112                 }
2113         }
2114 }
2115
2116 void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
2117 {
2118         /* PropertyDefRNA *dp; */
2119         StructRNA *srna = DefRNA.laststruct;
2120
2121         if (!DefRNA.preprocess) {
2122                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2123                 return;
2124         }
2125
2126         if (prop->type != PROP_POINTER) {
2127                 fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
2128                 DefRNA.error = 1;
2129                 return;
2130         }
2131
2132         if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
2133                 if (prop->arraydimension) {
2134                         prop->arraydimension = 0;
2135                         prop->totarraylength = 0;
2136
2137                         if (!DefRNA.silent) {
2138                                 fprintf(stderr, "%s: \"%s.%s\", array not supported for pointer type.\n",
2139                                         __func__, structname, propname);
2140                                 DefRNA.error = 1;
2141                         }
2142                 }
2143         }
2144 }
2145
2146 void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname,
2147                                       const char *lengthpropname)
2148 {
2149         PropertyDefRNA *dp;
2150         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
2151         StructRNA *srna = DefRNA.laststruct;
2152
2153         if (!DefRNA.preprocess) {
2154                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2155                 return;
2156         }
2157
2158         if (prop->type != PROP_COLLECTION) {
2159                 fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
2160                 DefRNA.error = 1;
2161                 return;
2162         }
2163
2164         if ((dp = rna_def_property_sdna(prop, structname, propname))) {
2165                 if (prop->arraydimension && !lengthpropname) {
2166                         prop->arraydimension = 0;
2167                         prop->totarraylength = 0;
2168
2169                         if (!DefRNA.silent) {
2170                                 fprintf(stderr, "%s: \"%s.%s\", array of collections not supported.\n",
2171                                         __func__, structname, propname);
2172                                 DefRNA.error = 1;
2173                         }
2174                 }
2175
2176                 if (dp->dnatype && STREQ(dp->dnatype, "ListBase")) {
2177                         cprop->next = (PropCollectionNextFunc)"rna_iterator_listbase_next";
2178                         cprop->get = (PropCollectionGetFunc)"rna_iterator_listbase_get";
2179                         cprop->end = (PropCollectionEndFunc)"rna_iterator_listbase_end";
2180                 }
2181         }
2182
2183         if (dp && lengthpropname) {
2184                 DNAStructMember smember;
2185                 StructDefRNA *ds = rna_find_struct_def((StructRNA *)dp->cont);
2186
2187                 if (!structname)
2188                         structname = ds->dnaname;
2189
2190                 if (lengthpropname[0] == 0 || rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
2191                         if (lengthpropname[0] == 0) {
2192                                 dp->dnalengthfixed = prop->totarraylength;
2193                                 prop->arraydimension = 0;
2194                                 prop->totarraylength = 0;
2195                         }
2196                         else {
2197                                 dp->dnalengthstructname = structname;
2198                                 dp->dnalengthname = lengthpropname;
2199                                 prop->totarraylength = 0;
2200                         }
2201
2202                         cprop->next = (PropCollectionNextFunc)"rna_iterator_array_next";
2203                         cprop->end = (PropCollectionEndFunc)"rna_iterator_array_end";
2204
2205                         if (dp->dnapointerlevel >= 2)
2206                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
2207                         else
2208                                 cprop->get = (PropCollectionGetFunc)"rna_iterator_array_get";
2209                 }
2210                 else {
2211                         if (!DefRNA.silent) {
2212                                 fprintf(stderr, "%s: \"%s.%s\" not found.\n", __func__, structname, lengthpropname);
2213                                 DefRNA.error = 1;
2214                         }
2215                 }
2216         }
2217 }
2218
2219 void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
2220 {
2221         prop->translation_context = context ? context : BLT_I18NCONTEXT_DEFAULT_BPYRNA;
2222 }
2223
2224 /* Functions */
2225
2226 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
2227 {
2228         if (!DefRNA.preprocess) {
2229                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2230                 return;
2231         }
2232
2233         if (editable) prop->editable = (EditableFunc)editable;
2234 }
2235
2236 void RNA_def_property_editable_array_func(PropertyRNA *prop, const char *editable)
2237 {
2238         if (!DefRNA.preprocess) {
2239                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2240                 return;
2241         }
2242
2243         if (editable) prop->itemeditable = (ItemEditableFunc)editable;
2244 }
2245
2246 /**
2247  * Set custom callbacks for override operations handling.
2248  *
2249  * \note \a diff callback will also be used by RNA comparison/equality functions.
2250  */
2251 void RNA_def_property_override_funcs(PropertyRNA *prop, const char *diff, const char *store, const char *apply)
2252 {
2253         if (!DefRNA.preprocess) {
2254                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2255                 return;
2256         }
2257
2258         if (diff) {
2259                 prop->override_diff = (RNAPropOverrideDiff)diff;
2260         }
2261         if (store) {
2262                 prop->override_store = (RNAPropOverrideStore)store;
2263         }
2264         if (apply) {
2265                 prop->override_apply = (RNAPropOverrideApply)apply;
2266         }
2267 }
2268
2269 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
2270 {
2271         if (!DefRNA.preprocess) {
2272                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2273                 return;
2274         }
2275
2276         prop->noteflag = noteflag;
2277         prop->update = (UpdateFunc)func;
2278 }
2279
2280 void RNA_def_property_update_runtime(PropertyRNA *prop, const void *func)
2281 {
2282         prop->update = (void *)func;
2283 }
2284
2285 void RNA_def_property_poll_runtime(PropertyRNA *prop, const void *func)
2286 {
2287         if (prop->type == PROP_POINTER) {
2288                 ((PointerPropertyRNA *)prop)->poll = (void *)func;
2289         }
2290         else {
2291                 fprintf(stderr, "%s: %s is not a Pointer Property.\n", __func__, prop->identifier);
2292         }
2293 }
2294
2295 void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
2296 {
2297         if (!DefRNA.preprocess) {
2298                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2299                 return;
2300         }
2301
2302         if (!(prop->flag & PROP_DYNAMIC)) {
2303                 fprintf(stderr, "%s: property is a not dynamic array.\n", __func__);
2304                 DefRNA.error = 1;
2305                 return;
2306         }
2307
2308         if (getlength) prop->getlength = (PropArrayLengthGetFunc)getlength;
2309 }
2310
2311 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
2312 {
2313         StructRNA *srna = DefRNA.laststruct;
2314
2315         if (!DefRNA.preprocess) {
2316                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2317                 return;
2318         }
2319
2320         switch (prop->type) {
2321                 case PROP_BOOLEAN:
2322                 {
2323                         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2324
2325                         if (prop->arraydimension) {
2326                                 if (get) bprop->getarray = (PropBooleanArrayGetFunc)get;
2327                                 if (set) bprop->setarray = (PropBooleanArraySetFunc)set;
2328                         }
2329                         else {
2330                                 if (get) bprop->get = (PropBooleanGetFunc)get;
2331                                 if (set) bprop->set = (PropBooleanSetFunc)set;
2332                         }
2333                         break;
2334                 }
2335                 default:
2336                         fprintf(stderr, "%s: \"%s.%s\", type is not boolean.\n", __func__, srna->identifier, prop->identifier);
2337                         DefRNA.error = 1;
2338                         break;
2339         }
2340 }
2341
2342 void RNA_def_property_boolean_funcs_runtime(PropertyRNA *prop, BooleanPropertyGetFunc getfunc, BooleanPropertySetFunc setfunc)
2343 {
2344         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2345
2346         if (getfunc) bprop->get_ex = getfunc;
2347         if (setfunc) bprop->set_ex = setfunc;
2348
2349         if (getfunc || setfunc) {
2350                 /* don't save in id properties */
2351                 prop->flag &= ~PROP_IDPROPERTY;
2352
2353                 if (!setfunc)
2354                         prop->flag &= ~PROP_EDITABLE;
2355         }
2356 }
2357
2358 void RNA_def_property_boolean_array_funcs_runtime(PropertyRNA *prop, BooleanArrayPropertyGetFunc getfunc, BooleanArrayPropertySetFunc setfunc)
2359 {
2360         BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
2361
2362         if (getfunc) bprop->getarray_ex = getfunc;
2363         if (setfunc) bprop->setarray_ex = setfunc;
2364
2365         if (getfunc || setfunc) {
2366                 /* don't save in id properties */
2367                 prop->flag &= ~PROP_IDPROPERTY;
2368
2369                 if (!setfunc)
2370                         prop->flag &= ~PROP_EDITABLE;
2371         }
2372 }
2373
2374 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
2375 {
2376         StructRNA *srna = DefRNA.laststruct;
2377
2378         if (!DefRNA.preprocess) {
2379                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2380                 return;
2381         }
2382
2383         switch (prop->type) {
2384                 case PROP_INT:
2385                 {
2386                         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2387
2388                         if (prop->arraydimension) {
2389                                 if (get) iprop->getarray = (PropIntArrayGetFunc)get;
2390                                 if (set) iprop->setarray = (PropIntArraySetFunc)set;
2391                         }
2392                         else {
2393                                 if (get) iprop->get = (PropIntGetFunc)get;
2394                                 if (set) iprop->set = (PropIntSetFunc)set;
2395                         }
2396                         if (range) iprop->range = (PropIntRangeFunc)range;
2397                         break;
2398                 }
2399                 default:
2400                         fprintf(stderr, "%s: \"%s.%s\", type is not int.\n", __func__, srna->identifier, prop->identifier);
2401                         DefRNA.error = 1;
2402                         break;
2403         }
2404 }
2405
2406 void RNA_def_property_int_funcs_runtime(PropertyRNA *prop, IntPropertyGetFunc getfunc, IntPropertySetFunc setfunc, IntPropertyRangeFunc rangefunc)
2407 {
2408         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2409
2410         if (getfunc) iprop->get_ex = getfunc;
2411         if (setfunc) iprop->set_ex = setfunc;
2412         if (rangefunc) iprop->range_ex = rangefunc;
2413
2414         if (getfunc || setfunc) {
2415                 /* don't save in id properties */
2416                 prop->flag &= ~PROP_IDPROPERTY;
2417
2418                 if (!setfunc)
2419                         prop->flag &= ~PROP_EDITABLE;
2420         }
2421 }
2422
2423 void RNA_def_property_int_array_funcs_runtime(PropertyRNA *prop, IntArrayPropertyGetFunc getfunc, IntArrayPropertySetFunc setfunc, IntPropertyRangeFunc rangefunc)
2424 {
2425         IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
2426
2427         if (getfunc) iprop->getarray_ex = getfunc;
2428         if (setfunc) iprop->setarray_ex = setfunc;
2429         if (rangefunc) iprop->range_ex = rangefunc;
2430
2431         if (getfunc || setfunc) {
2432                 /* don't save in id properties */
2433                 prop->flag &= ~PROP_IDPROPERTY;
2434
2435                 if (!setfunc)
2436                         prop->flag &= ~PROP_EDITABLE;
2437         }
2438 }
2439
2440 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
2441 {
2442         StructRNA *srna = DefRNA.laststruct;
2443
2444         if (!DefRNA.preprocess) {
2445                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2446                 return;
2447         }
2448
2449         switch (prop->type) {
2450                 case PROP_FLOAT:
2451                 {
2452                         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2453
2454                         if (prop->arraydimension) {
2455                                 if (get) fprop->getarray = (PropFloatArrayGetFunc)get;
2456                                 if (set) fprop->setarray = (PropFloatArraySetFunc)set;
2457                         }
2458                         else {
2459                                 if (get) fprop->get = (PropFloatGetFunc)get;
2460                                 if (set) fprop->set = (PropFloatSetFunc)set;
2461                         }
2462                         if (range) fprop->range = (PropFloatRangeFunc)range;
2463                         break;
2464                 }
2465                 default:
2466                         fprintf(stderr, "%s: \"%s.%s\", type is not float.\n", __func__, srna->identifier, prop->identifier);
2467                         DefRNA.error = 1;
2468                         break;
2469         }
2470 }
2471
2472 void RNA_def_property_float_funcs_runtime(PropertyRNA *prop, FloatPropertyGetFunc getfunc, FloatPropertySetFunc setfunc, FloatPropertyRangeFunc rangefunc)
2473 {
2474         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2475
2476         if (getfunc) fprop->get_ex = getfunc;
2477         if (setfunc) fprop->set_ex = setfunc;
2478         if (rangefunc) fprop->range_ex = rangefunc;
2479
2480         if (getfunc || setfunc) {
2481                 /* don't save in id properties */
2482                 prop->flag &= ~PROP_IDPROPERTY;
2483
2484                 if (!setfunc)
2485                         prop->flag &= ~PROP_EDITABLE;
2486         }
2487 }
2488
2489 void RNA_def_property_float_array_funcs_runtime(PropertyRNA *prop, FloatArrayPropertyGetFunc getfunc, FloatArrayPropertySetFunc setfunc, FloatPropertyRangeFunc rangefunc)
2490 {
2491         FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
2492
2493         if (getfunc) fprop->getarray_ex = getfunc;
2494         if (setfunc) fprop->setarray_ex = setfunc;
2495         if (rangefunc) fprop->range_ex = rangefunc;
2496
2497         if (getfunc || setfunc) {
2498                 /* don't save in id properties */
2499                 prop->flag &= ~PROP_IDPROPERTY;
2500
2501                 if (!setfunc)
2502                         prop->flag &= ~PROP_EDITABLE;
2503         }
2504 }
2505
2506 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
2507 {
2508         StructRNA *srna = DefRNA.laststruct;
2509
2510         if (!DefRNA.preprocess) {
2511                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2512                 return;
2513         }
2514
2515         switch (prop->type) {
2516                 case PROP_ENUM:
2517                 {
2518                         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2519
2520                         if (get) eprop->get = (PropEnumGetFunc)get;
2521                         if (set) eprop->set = (PropEnumSetFunc)set;
2522                         if (item) eprop->itemf = (PropEnumItemFunc)item;
2523                         break;
2524                 }
2525                 default:
2526                         fprintf(stderr, "%s: \"%s.%s\", type is not enum.\n", __func__, srna->identifier, prop->identifier);
2527                         DefRNA.error = 1;
2528                         break;
2529         }
2530 }
2531
2532 void RNA_def_property_enum_funcs_runtime(PropertyRNA *prop, EnumPropertyGetFunc getfunc, EnumPropertySetFunc setfunc, EnumPropertyItemFunc itemfunc)
2533 {
2534         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2535
2536         if (getfunc) eprop->get_ex = getfunc;
2537         if (setfunc) eprop->set_ex = setfunc;
2538         if (itemfunc) eprop->itemf = itemfunc;
2539
2540         if (getfunc || setfunc) {
2541                 /* don't save in id properties */
2542                 prop->flag &= ~PROP_IDPROPERTY;
2543
2544                 if (!setfunc)
2545                         prop->flag &= ~PROP_EDITABLE;
2546         }
2547 }
2548
2549 void RNA_def_property_enum_py_data(PropertyRNA *prop, void *py_data)
2550 {
2551         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2552         eprop->py_data = py_data;
2553 }
2554
2555 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
2556 {
2557         StructRNA *srna = DefRNA.laststruct;
2558
2559         if (!DefRNA.preprocess) {
2560                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2561                 return;
2562         }
2563
2564         switch (prop->type) {
2565                 case PROP_STRING:
2566                 {
2567                         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2568
2569                         if (get) sprop->get = (PropStringGetFunc)get;
2570                         if (length) sprop->length = (PropStringLengthFunc)length;
2571                         if (set) sprop->set = (PropStringSetFunc)set;
2572                         break;
2573                 }
2574                 default:
2575                         fprintf(stderr, "%s: \"%s.%s\", type is not string.\n", __func__, srna->identifier, prop->identifier);
2576                         DefRNA.error = 1;
2577                         break;
2578         }
2579 }
2580
2581 void RNA_def_property_string_funcs_runtime(PropertyRNA *prop, StringPropertyGetFunc getfunc, StringPropertyLengthFunc lengthfunc, StringPropertySetFunc setfunc)
2582 {
2583         StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
2584
2585         if (getfunc) sprop->get_ex = getfunc;
2586         if (lengthfunc) sprop->length_ex = lengthfunc;
2587         if (setfunc) sprop->set_ex = setfunc;
2588
2589         if (getfunc || setfunc) {
2590                 /* don't save in id properties */
2591                 prop->flag &= ~PROP_IDPROPERTY;
2592
2593                 if (!setfunc)
2594                         prop->flag &= ~PROP_EDITABLE;
2595         }
2596 }
2597
2598 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set,
2599                                     const char *typef, const char *poll)
2600 {
2601         StructRNA *srna = DefRNA.laststruct;
2602
2603         if (!DefRNA.preprocess) {
2604                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2605                 return;
2606         }
2607
2608         switch (prop->type) {
2609                 case PROP_POINTER:
2610                 {
2611                         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
2612
2613                         if (get) pprop->get = (PropPointerGetFunc)get;
2614                         if (set) pprop->set = (PropPointerSetFunc)set;
2615                         if (typef) pprop->typef = (PropPointerTypeFunc)typef;
2616                         if (poll) pprop->poll = (PropPointerPollFunc)poll;
2617                         break;
2618                 }
2619                 default:
2620                         fprintf(stderr, "%s: \"%s.%s\", type is not pointer.\n", __func__, srna->identifier, prop->identifier);
2621                         DefRNA.error = 1;
2622                         break;
2623         }
2624 }
2625
2626 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end,
2627                                        const char *get, const char *length, const char *lookupint,
2628                                        const char *lookupstring, const char *assignint)
2629 {
2630         StructRNA *srna = DefRNA.laststruct;
2631
2632         if (!DefRNA.preprocess) {
2633                 fprintf(stderr, "%s: only during preprocessing.\n", __func__);
2634                 return;
2635         }
2636
2637         switch (prop->type) {
2638                 case PROP_COLLECTION:
2639                 {
2640                         CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
2641
2642                         if (begin) cprop->begin = (PropCollectionBeginFunc)begin;
2643                         if (next) cprop->next = (PropCollectionNextFunc)next;
2644                         if (end) cprop->end = (PropCollectionEndFunc)end;
2645                         if (get) cprop->get = (PropCollectionGetFunc)get;
2646                         if (length) cprop->length = (PropCollectionLengthFunc)length;
2647                         if (lookupint) cprop->lookupint = (PropCollectionLookupIntFunc)lookupint;
2648                         if (lookupstring) cprop->lookupstring = (PropCollectionLookupStringFunc)lookupstring;
2649                         if (assignint) cprop->assignint = (PropCollectionAssignIntFunc)assignint;
2650                         break;
2651                 }
2652                 default:
2653                         fprintf(stderr, "%s: \"%s.%s\", type is not collection.\n", __func__, srna->identifier, prop->identifier);
2654                         DefRNA.error = 1;
2655                         break;
2656         }
2657 }
2658
2659 void RNA_def_property_srna(PropertyRNA *prop, const char *type)
2660 {
2661         prop->srna = (StructRNA *)type;
2662 }
2663
2664 void RNA_def_py_data(PropertyRNA *prop, void *py_data)
2665 {
2666         prop->py_data = py_data;
2667 }
2668
2669 /* Compact definitions */
2670
2671 PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value,
2672                              const char *ui_name, const char *ui_description)
2673 {
2674         ContainerRNA *cont = cont_;
2675         PropertyRNA *prop;
2676
2677         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2678         RNA_def_property_boolean_default(prop, default_value);
2679         RNA_def_property_ui_text(prop, ui_name, ui_description);
2680
2681         return prop;
2682 }
2683
2684 PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, bool *default_value,
2685                                    const char *ui_name, const char *ui_description)
2686 {
2687         ContainerRNA *cont = cont_;
2688         PropertyRNA *prop;
2689
2690         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_NONE);
2691         if (len != 0) RNA_def_property_array(prop, len);
2692         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2693         RNA_def_property_ui_text(prop, ui_name, ui_description);
2694
2695         return prop;
2696 }
2697
2698 PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *identifier, int len, bool *default_value,
2699                                    const char *ui_name, const char *ui_description)
2700 {
2701         ContainerRNA *cont = cont_;
2702         PropertyRNA *prop;
2703
2704         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER);
2705         if (len != 0) RNA_def_property_array(prop, len);
2706         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2707         RNA_def_property_ui_text(prop, ui_name, ui_description);
2708
2709         return prop;
2710 }
2711
2712 PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char *identifier, int len,
2713                                           bool *default_value, const char *ui_name, const char *ui_description)
2714 {
2715         ContainerRNA *cont = cont_;
2716         PropertyRNA *prop;
2717
2718         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_LAYER_MEMBER);
2719         if (len != 0) RNA_def_property_array(prop, len);
2720         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2721         RNA_def_property_ui_text(prop, ui_name, ui_description);
2722
2723         return prop;
2724 }
2725
2726 PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, bool *default_value,
2727                                     const char *ui_name, const char *ui_description)
2728 {
2729         ContainerRNA *cont = cont_;
2730         PropertyRNA *prop;
2731
2732         prop = RNA_def_property(cont, identifier, PROP_BOOLEAN, PROP_XYZ); /* XXX */
2733         if (len != 0) RNA_def_property_array(prop, len);
2734         if (default_value) RNA_def_property_boolean_array_default(prop, default_value);
2735         RNA_def_property_ui_text(prop, ui_name, ui_description);
2736
2737         return prop;
2738 }
2739
2740 PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value,
2741                          int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2742                          int softmin, int softmax)
2743 {
2744         ContainerRNA *cont = cont_;
2745         PropertyRNA *prop;
2746
2747         ASSERT_SOFT_HARD_LIMITS;
2748
2749         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2750         RNA_def_property_int_default(prop, default_value);
2751         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2752         RNA_def_property_ui_text(prop, ui_name, ui_description);
2753         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2754
2755         return prop;
2756 }
2757
2758 PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2759                                 int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2760                                 int softmin, int softmax)
2761 {
2762         ContainerRNA *cont = cont_;
2763         PropertyRNA *prop;
2764
2765         ASSERT_SOFT_HARD_LIMITS;
2766
2767         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_XYZ); /* XXX */
2768         if (len != 0) RNA_def_property_array(prop, len);
2769         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2770         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2771         RNA_def_property_ui_text(prop, ui_name, ui_description);
2772         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2773
2774         return prop;
2775 }
2776
2777 PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
2778                                int hardmin, int hardmax, const char *ui_name, const char *ui_description,
2779                                int softmin, int softmax)
2780 {
2781         ContainerRNA *cont = cont_;
2782         PropertyRNA *prop;
2783
2784         ASSERT_SOFT_HARD_LIMITS;
2785
2786         prop = RNA_def_property(cont, identifier, PROP_INT, PROP_NONE);
2787         if (len != 0) RNA_def_property_array(prop, len);
2788         if (default_value) RNA_def_property_int_array_default(prop, default_value);
2789         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2790         RNA_def_property_ui_text(prop, ui_name, ui_description);
2791         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2792
2793         return prop;
2794 }
2795
2796 PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
2797                             const char *ui_name, const char *ui_description)
2798 {
2799         ContainerRNA *cont = cont_;
2800         PropertyRNA *prop;
2801
2802         BLI_assert(default_value == NULL || default_value[0]);
2803
2804         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_NONE);
2805         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2806         if (default_value) RNA_def_property_string_default(prop, default_value);
2807         RNA_def_property_ui_text(prop, ui_name, ui_description);
2808
2809         return prop;
2810 }
2811
2812 PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2813                                       int maxlen, const char *ui_name, const char *ui_description)
2814 {
2815         ContainerRNA *cont = cont_;
2816         PropertyRNA *prop;
2817
2818         BLI_assert(default_value == NULL || default_value[0]);
2819
2820         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILEPATH);
2821         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2822         if (default_value) RNA_def_property_string_default(prop, default_value);
2823         RNA_def_property_ui_text(prop, ui_name, ui_description);
2824
2825         return prop;
2826 }
2827
2828 PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2829                                      int maxlen, const char *ui_name, const char *ui_description)
2830 {
2831         ContainerRNA *cont = cont_;
2832         PropertyRNA *prop;
2833
2834         BLI_assert(default_value == NULL || default_value[0]);
2835
2836         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_DIRPATH);
2837         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2838         if (default_value) RNA_def_property_string_default(prop, default_value);
2839         RNA_def_property_ui_text(prop, ui_name, ui_description);
2840
2841         return prop;
2842 }
2843
2844 PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
2845                                       int maxlen, const char *ui_name, const char *ui_description)
2846 {
2847         ContainerRNA *cont = cont_;
2848         PropertyRNA *prop;
2849
2850         BLI_assert(default_value == NULL || default_value[0]);
2851
2852         prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_FILENAME);
2853         if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
2854         if (default_value) RNA_def_property_string_default(prop, default_value);
2855         RNA_def_property_ui_text(prop, ui_name, ui_description);
2856
2857         return prop;
2858 }
2859
2860 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2861                           int default_value, const char *ui_name, const char *ui_description)
2862 {
2863         ContainerRNA *cont = cont_;
2864         PropertyRNA *prop;
2865
2866         if (!items) {
2867                 printf("%s: items not allowed to be NULL.\n", __func__);
2868                 return NULL;
2869         }
2870
2871         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2872         if (items) RNA_def_property_enum_items(prop, items);
2873         RNA_def_property_enum_default(prop, default_value);
2874         RNA_def_property_ui_text(prop, ui_name, ui_description);
2875
2876         return prop;
2877 }
2878
2879 /* same as above but sets 'PROP_ENUM_FLAG' before setting the default value */
2880 PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
2881                                int default_value, const char *ui_name, const char *ui_description)
2882 {
2883         ContainerRNA *cont = cont_;
2884         PropertyRNA *prop;
2885
2886         if (!items) {
2887                 printf("%s: items not allowed to be NULL.\n", __func__);
2888                 return NULL;
2889         }
2890
2891         prop = RNA_def_property(cont, identifier, PROP_ENUM, PROP_NONE);
2892         RNA_def_property_flag(prop, PROP_ENUM_FLAG); /* important to run before default set */
2893         if (items) RNA_def_property_enum_items(prop, items);
2894         RNA_def_property_enum_default(prop, default_value);
2895         RNA_def_property_ui_text(prop, ui_name, ui_description);
2896
2897         return prop;
2898 }
2899
2900 void RNA_def_enum_funcs(PropertyRNA *prop, EnumPropertyItemFunc itemfunc)
2901 {
2902         EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2903         eprop->itemf = itemfunc;
2904 }
2905
2906 PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
2907                            float hardmin, float hardmax, const char *ui_name, const char *ui_description,
2908                            float softmin, float softmax)
2909 {
2910         ContainerRNA *cont = cont_;
2911         PropertyRNA *prop;
2912
2913         ASSERT_SOFT_HARD_LIMITS;
2914
2915         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
2916         RNA_def_property_float_default(prop, default_value);
2917         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2918         RNA_def_property_ui_text(prop, ui_name, ui_description);
2919         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2920
2921         return prop;
2922 }
2923
2924 PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len,
2925                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2926                                   const char *ui_description, float softmin, float softmax)
2927 {
2928         ContainerRNA *cont = cont_;
2929         PropertyRNA *prop;
2930
2931         ASSERT_SOFT_HARD_LIMITS;
2932
2933         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_XYZ);
2934         if (len != 0) RNA_def_property_array(prop, len);
2935         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2936         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2937         RNA_def_property_ui_text(prop, ui_name, ui_description);
2938         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2939
2940         return prop;
2941 }
2942
2943 PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len,
2944                                       const float *default_value, float hardmin, float hardmax, const char *ui_name,
2945                                       const char *ui_description, float softmin, float softmax)
2946 {
2947         PropertyRNA *prop;
2948
2949         prop = RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description,
2950                                     softmin, softmax);
2951         prop->subtype = PROP_XYZ_LENGTH;
2952
2953         return prop;
2954 }
2955
2956 PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len,
2957                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
2958                                  const char *ui_description, float softmin, float softmax)
2959 {
2960         ContainerRNA *cont = cont_;
2961         PropertyRNA *prop;
2962
2963         ASSERT_SOFT_HARD_LIMITS;
2964
2965         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_COLOR);
2966         if (len != 0) RNA_def_property_array(prop, len);
2967         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2968         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2969         RNA_def_property_ui_text(prop, ui_name, ui_description);
2970         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2971
2972         return prop;
2973 }
2974
2975
2976 PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns,
2977                                   const float *default_value, float hardmin, float hardmax, const char *ui_name,
2978                                   const char *ui_description, float softmin, float softmax)
2979 {
2980         ContainerRNA *cont = cont_;
2981         PropertyRNA *prop;
2982         const int length[2] = {rows, columns};
2983
2984         ASSERT_SOFT_HARD_LIMITS;
2985
2986         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_MATRIX);
2987         RNA_def_property_multi_array(prop, 2, length);
2988         if (default_value) RNA_def_property_float_array_default(prop, default_value);
2989         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
2990         RNA_def_property_ui_text(prop, ui_name, ui_description);
2991         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
2992
2993         return prop;
2994 }
2995
2996 PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len,
2997                                     const float *default_value, float hardmin, float hardmax, const char *ui_name,
2998                                     const char *ui_description, float softmin, float softmax)
2999 {
3000         ContainerRNA *cont = cont_;
3001         PropertyRNA *prop;
3002
3003         ASSERT_SOFT_HARD_LIMITS;
3004
3005         prop = RNA_def_property(cont, identifier, PROP_FLOAT, (len >= 3) ? PROP_EULER : PROP_ANGLE);
3006         if (len != 0) {
3007                 RNA_def_property_array(prop, len);
3008                 if (default_value) RNA_def_property_float_array_default(prop, default_value);
3009         }
3010         else {
3011                 /* RNA_def_property_float_default must be called outside */
3012                 BLI_assert(default_value == NULL);
3013         }
3014         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3015         RNA_def_property_ui_text(prop, ui_name, ui_description);
3016         RNA_def_property_ui_range(prop, softmin, softmax, 10, 3);
3017
3018         return prop;
3019 }
3020
3021 PropertyRNA *RNA_def_float_distance(StructOrFunctionRNA *cont_, const char *identifier,
3022                                     float default_value, float hardmin, float hardmax, const char *ui_name,
3023                                     const char *ui_description, float softmin, float softmax)
3024 {
3025         PropertyRNA *prop = RNA_def_float(cont_, identifier, default_value,
3026                                           hardmin, hardmax, ui_name, ui_description,
3027                                           softmin, softmax);
3028         RNA_def_property_subtype(prop, PROP_DISTANCE);
3029
3030         return prop;
3031 }
3032
3033 PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len,
3034                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
3035                                  const char *ui_description, float softmin, float softmax)
3036 {
3037         ContainerRNA *cont = cont_;
3038         PropertyRNA *prop;
3039
3040         ASSERT_SOFT_HARD_LIMITS;
3041
3042         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_NONE);
3043         if (len != 0) RNA_def_property_array(prop, len);
3044         if (default_value) RNA_def_property_float_array_default(prop, default_value);
3045         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3046         RNA_def_property_ui_text(prop, ui_name, ui_description);
3047         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3048
3049         return prop;
3050 }
3051
3052 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
3053                                       float hardmin, float hardmax, const char *ui_name, const char *ui_description,
3054                                       float softmin, float softmax)
3055 {
3056         ContainerRNA *cont = cont_;
3057         PropertyRNA *prop;
3058
3059         ASSERT_SOFT_HARD_LIMITS;
3060
3061         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_PERCENTAGE);
3062         RNA_def_property_float_default(prop, default_value);
3063         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3064         RNA_def_property_ui_text(prop, ui_name, ui_description);
3065         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3066
3067         return prop;
3068 }
3069
3070 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
3071                                   float hardmin, float hardmax, const char *ui_name, const char *ui_description,
3072                                   float softmin, float softmax)
3073 {
3074         ContainerRNA *cont = cont_;
3075         PropertyRNA *prop;
3076
3077         ASSERT_SOFT_HARD_LIMITS;
3078
3079         prop = RNA_def_property(cont, identifier, PROP_FLOAT, PROP_FACTOR);
3080         RNA_def_property_float_default(prop, default_value);
3081         if (hardmin != hardmax) RNA_def_property_range(prop, hardmin, hardmax);
3082         RNA_def_property_ui_text(prop, ui_name, ui_description);
3083         RNA_def_property_ui_range(prop, softmin, softmax, 1, 3);
3084
3085         return prop;
3086 }
3087
3088 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
3089                              const char *ui_name, const char *ui_description)
3090 {
3091         ContainerRNA *cont = cont_;
3092         PropertyRNA *prop;
3093
3094         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
3095         RNA_def_property_struct_type(prop, type);
3096         RNA_def_property_ui_text(prop, ui_name, ui_description);
3097
3098         return prop;
3099 }
3100
3101 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
3102                                      const char *ui_name, const char *ui_description)
3103 {
3104         ContainerRNA *cont = cont_;
3105         PropertyRNA *prop;
3106
3107         prop = RNA_def_property(cont, identifier, PROP_POINTER, PROP_NONE);
3108         RNA_def_property_struct_runtime(prop, type);
3109         if ((type->flag & STRUCT_ID) != 0) {
3110                 prop->flag |= PROP_EDITABLE;
3111         }
3112         RNA_def_property_ui_text(prop, ui_name, ui_description);
3113
3114         return prop;
3115 }
3116
3117 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
3118                                 const char *ui_name, const char *ui_description)
3119 {
3120         ContainerRNA *cont = cont_;
3121         PropertyRNA *prop;
3122
3123         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
3124         RNA_def_property_struct_type(prop, type);
3125         RNA_def_property_ui_text(prop, ui_name, ui_description);
3126
3127         return prop;
3128 }
3129
3130 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
3131                                         const char *ui_name, const char *ui_description)
3132 {
3133         ContainerRNA *cont = cont_;
3134         PropertyRNA *prop;
3135
3136         prop = RNA_def_property(cont, identifier, PROP_COLLECTION, PROP_NONE);
3137         RNA_def_property_struct_runtime(prop, type);
3138         RNA_def_property_ui_text(prop, ui_name, ui_description);
3139
3140         return prop;
3141 }
3142
3143 /* Function */
3144
3145 static FunctionRNA *rna_def_function(StructRNA *srna, const char *identifier)
3146 {
3147         FunctionRNA *func;
3148         StructDefRNA *dsrna;
3149         FunctionDefRNA *dfunc;
3150
3151         if (DefRNA.preprocess) {
3152                 char error[512];
3153
3154                 if (rna_validate_identifier(identifier, error, false) == 0) {
3155                         fprintf(stderr, "%s: function identifier \"%s\" - %s\n", __func__, identifier, error);
3156                         DefRNA.error = 1;
3157                 }
3158         }
3159
3160         func = MEM_callocN(sizeof(FunctionRNA), "FunctionRNA");
3161         func->identifier = identifier;
3162         func->description = identifier;
3163
3164         rna_addtail(&srna->functions, func);
3165
3166         if (DefRNA.preprocess) {
3167                 dsrna = rna_find_struct_def(srna);
3168                 dfunc = MEM_callocN(sizeof(FunctionDefRNA), "FunctionDefRNA");
3169                 rna_addtail(&dsrna->functions, dfunc);
3170                 dfunc->func = func;
3171         }
3172         else
3173                 func->flag |= FUNC_RUNTIME;
3174
3175         return func;
3176 }
3177
3178 FunctionRNA *RNA_def_function(StructRNA *srna, const char *identifier, const char *call)
3179 {
3180         FunctionRNA *func;
3181         FunctionDefRNA *dfunc;
3182
3183         if (BLI_findstring_ptr(&srna->functions, identifier, offsetof(FunctionRNA, identifier))) {
3184                 fprintf(stderr, "%s: %s.%s already defined.\n", __func__, srna->identifier, identifier);
3185                 return NULL;
3186         }
3187
3188         func = rna_def_function(srna, identifier);
3189
3190         if (!DefRNA.preprocess) {
3191                 fprintf(stderr, "%s: only at preprocess time.\n", __func__);
3192                 return func;
3193         }
3194
3195         dfunc = rna_find_function_def(func);
3196         dfunc->call = call;
3197
3198         return func;
3199 }
3200
3201 FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, CallFunc call)
3202 {
3203         FunctionRNA *func;
3204
3205         func = rna_def_function(srna, identifier);
3206
3207         if (DefRNA.preprocess) {
3208                 fprintf(stderr, "%s: only at runtime.\n", __func__);
3209                 return func;
3210         }
3211
3212         func->call = call;
3213
3214
3215         return func;
3216 }
3217
3218 /* C return value only!, multiple RNA returns can be done with RNA_def_function_output */
3219 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
3220 {
3221         if (ret->flag & PROP_DYNAMIC) {
3222                 fprintf(stderr, "%s: \"%s.%s\", dynamic values are not allowed as strict returns, "
3223                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
3224                 return;
3225         }
3226         else if (ret->arraydimension) {
3227                 fprintf(stderr, "%s: \"%s.%s\", arrays are not allowed as strict returns, "
3228                         "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
3229                 return;
3230         }
3231
3232         BLI_assert(func->c_ret == NULL);
3233         func->c_ret = ret;
3234
3235         RNA_def_function_output(func, ret);
3236 }
3237
3238 void RNA_def_function_output(FunctionRNA *UNUSED(func), PropertyRNA *ret)
3239 {
3240         ret->flag_parameter |= PARM_OUTPUT;
3241 }
3242
3243 void RNA_def_function_flag(FunctionRNA *func, int flag)
3244 {
3245         func->flag |= flag;
3246 }
3247
3248 void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
3249 {
3250         func->description = description;
3251 }
3252
3253 int rna_parameter_size(PropertyRNA *parm)
3254 {