RNA
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 14 Nov 2008 18:46:57 +0000 (18:46 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 14 Nov 2008 18:46:57 +0000 (18:46 +0000)
* Rename cname to identifier.
* Rename PropertyEnumItem to EnumPropertyItem.
* Wrapped min/max/step/precision, pointer type for RNA.
* Draw FLT_MAX a bit better in buttons.

source/blender/editors/interface/interface.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/RNA_define.h
source/blender/makesrna/RNA_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_dependency.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_rna.c
source/blender/makesrna/intern/rna_scene.c

index 4fbc1147d1141cf36a3e82bf34bd3fa0ba088297..ac86b874db8b8f9a10d4fb9327efcb6e93dd001e 100644 (file)
@@ -27,6 +27,7 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+#include <float.h>
 #include <math.h>
 #include <string.h>
  
@@ -1514,7 +1515,9 @@ void ui_check_but(uiBut *but)
                value= ui_get_but_val(but);
 
                if(ui_is_but_float(but)) {
-                       if(but->a2) { /* amount of digits defined */
+                       if(value == FLT_MAX) sprintf(but->drawstr, "%sFLT_MAX", but->str);
+                       else if(value == -FLT_MAX) sprintf(but->drawstr, "%s-FLT_MAX", but->str);
+                       else if(but->a2) { /* amount of digits defined */
                                if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value);
                                else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value);
                                else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value);
@@ -2261,7 +2264,7 @@ uiBut *uiDefRNABut(uiBlock *block, int retval, PointerRNA *ptr, PropertyRNA *pro
                        break;
                }
                case PROP_ENUM: {
-                       const PropertyEnumItem *item;
+                       const EnumPropertyItem *item;
                        DynStr *dynstr;
                        char *menu;
                        int i, totitem;
index 4e21e93d47359e1f1b6cb6bb6fb514be7b1f4681..62fc72dbe93bf36398911026d66af63459479b83 100644 (file)
@@ -39,7 +39,7 @@ void RNA_pointer_main_get(struct Main *main, PointerRNA *r_ptr);
 
 /* Structs */
 
-const char *RNA_struct_cname(PointerRNA *ptr);
+const char *RNA_struct_identifier(PointerRNA *ptr);
 const char *RNA_struct_ui_name(PointerRNA *ptr);
 
 PropertyRNA *RNA_struct_name_property(PointerRNA *ptr);
@@ -52,7 +52,7 @@ PropertyRNA *RNA_struct_iterator_property(PointerRNA *ptr);
 
 /* Property Information */
 
-const char *RNA_property_cname(PropertyRNA *prop, PointerRNA *ptr);
+const char *RNA_property_identifier(PropertyRNA *prop, PointerRNA *ptr);
 PropertyType RNA_property_type(PropertyRNA *prop, PointerRNA *ptr);
 PropertySubType RNA_property_subtype(PropertyRNA *prop, PointerRNA *ptr);
 
@@ -66,7 +66,7 @@ void RNA_property_float_ui_range(PropertyRNA *prop, PointerRNA *ptr, float *soft
 
 int RNA_property_string_maxlength(PropertyRNA *prop, PointerRNA *ptr);
 
-void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const PropertyEnumItem **item, int *totitem);
+void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const EnumPropertyItem **item, int *totitem);
 
 const char *RNA_property_ui_name(PropertyRNA *prop, PointerRNA *ptr);
 const char *RNA_property_ui_description(PropertyRNA *prop, PointerRNA *ptr);
index 4b971c6a6dab85f2b4e42a23b54f94adbef8fcdf..1425bbb3c47a95ca6e25a0b1fdaac4094e4cba81 100644 (file)
@@ -43,14 +43,14 @@ void RNA_free(BlenderRNA *brna);
 
 /* Struct */
 
-StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name);
+StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *name);
 void RNA_def_struct_sdna(StructRNA *srna, const char *structname);
 void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop);
 void RNA_def_struct_flag(StructRNA *srna, int flag);
 
 /* Property */
 
-PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int subtype);
+PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype);
 
 void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int bit);
 void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname);
@@ -64,7 +64,7 @@ void RNA_def_property_flag(PropertyRNA *prop, int flag);
 void RNA_def_property_array(PropertyRNA *prop, int arraylength);
 void RNA_def_property_range(PropertyRNA *prop, double min, double max);
 
-void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item);
+void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item);
 void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength);
 void RNA_def_property_struct_type(PropertyRNA *prop, const char *type);
 
@@ -78,7 +78,7 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value);
 void RNA_def_property_string_default(PropertyRNA *prop, const char *value);
 
 void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description);
-void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, double precision);
+void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision);
 
 void RNA_def_property_funcs(PropertyRNA *prop, const char *notify, const char *readonly);
 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set);
index 41151e58fec2e91a63c49cb51de86237a934dd5e..b8d1793a05c43b9dae2a80e1794e35da7683174b 100644 (file)
@@ -147,17 +147,17 @@ typedef struct CollectionPropertyIterator {
        PointerRNA ptr;
 } CollectionPropertyIterator;
 
-typedef struct PropertyEnumItem {
+typedef struct EnumPropertyItem {
        int value;
-       const char *cname;
+       const char *identifier;
        const char *name;
-} PropertyEnumItem;
+} EnumPropertyItem;
 
 typedef struct PropertyRNA {
        struct PropertyRNA *next, *prev;
 
        /* C code name */
-       const char *cname;
+       const char *identifier;
        /* various options */
        int flag;
 
@@ -220,7 +220,8 @@ typedef struct FloatPropertyRNA {
 
        float softmin, softmax;
        float hardmin, hardmax;
-       float step, precision;
+       float step;
+       int precision;
 
        float defaultvalue;
        const float *defaultarray;
@@ -244,7 +245,7 @@ typedef struct EnumPropertyRNA {
        PropEnumGetFunc get;
        PropEnumSetFunc set;
 
-       const PropertyEnumItem *item;
+       const EnumPropertyItem *item;
        int totitem;
 
        int defaultvalue;
@@ -286,7 +287,7 @@ typedef struct StructRNA {
        struct StructRNA *next, *prev;
 
        /* C code name */
-       const char *cname;
+       const char *identifier;
        /* various options */
        int flag;
 
index 11fb81159d6cc700afbb3ed278c36c1b6858aa7b..00bbcb3664ac1f64ec0b901c2d4d6a7eccfdcc02 100644 (file)
@@ -101,18 +101,18 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
        char *func;
 
        if(!dp->dnastructname || !dp->dnaname) {
-               fprintf(stderr, "rna_def_property_get_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
+               fprintf(stderr, "rna_def_property_get_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return NULL;
        }
 
        if(prop->type == PROP_STRING && ((StringPropertyRNA*)prop)->maxlength == 0) {
-               fprintf(stderr, "rna_def_property_get_func: string %s.%s has max length 0.\n", srna->cname, prop->cname);
+               fprintf(stderr, "rna_def_property_get_func: string %s.%s has max length 0.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return NULL;
        }
 
-       func= rna_alloc_function_name(srna->cname, prop->cname, "get");
+       func= rna_alloc_function_name(srna->identifier, prop->identifier, "get");
 
        switch(prop->type) {
                case PROP_STRING: {
@@ -191,13 +191,13 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
 
        if(!dp->dnastructname || !dp->dnaname) {
                if(!(prop->flag & PROP_NOT_EDITABLE)) {
-                       fprintf(stderr, "rna_def_property_set_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
+                       fprintf(stderr, "rna_def_property_set_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                }
                return NULL;
        }
 
-       func= rna_alloc_function_name(srna->cname, prop->cname, "set");
+       func= rna_alloc_function_name(srna->identifier, prop->identifier, "set");
 
        switch(prop->type) {
                case PROP_STRING: {
@@ -254,12 +254,12 @@ static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA
 
        if(prop->type == PROP_STRING) {
                if(!dp->dnastructname || !dp->dnaname) {
-                       fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
+                       fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        return NULL;
                }
 
-               func= rna_alloc_function_name(srna->cname, prop->cname, "length");
+               func= rna_alloc_function_name(srna->identifier, prop->identifier, "length");
 
                fprintf(f, "static int %s(PointerRNA *ptr)\n", func);
                fprintf(f, "{\n");
@@ -269,12 +269,12 @@ static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA
        }
        else if(prop->type == PROP_COLLECTION) {
                if(prop->type == PROP_COLLECTION && !dp->dnalengthname) {
-                       fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
+                       fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        return NULL;
                }
 
-               func= rna_alloc_function_name(srna->cname, prop->cname, "length");
+               func= rna_alloc_function_name(srna->identifier, prop->identifier, "length");
 
                fprintf(f, "static int %s(PointerRNA *ptr)\n", func);
                fprintf(f, "{\n");
@@ -291,12 +291,12 @@ static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *
        char *func;
 
        if(!dp->dnastructname || !dp->dnaname) {
-               fprintf(stderr, "rna_def_property_begin_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
+               fprintf(stderr, "rna_def_property_begin_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
                return NULL;
        }
 
-       func= rna_alloc_function_name(srna->cname, prop->cname, "begin");
+       func= rna_alloc_function_name(srna->identifier, prop->identifier, "begin");
 
        if(dp->dnalengthname) {
                fprintf(f, "static void %s(CollectionPropertyIterator *iter, PointerRNA *ptr)\n", func);
@@ -385,7 +385,7 @@ static void rna_def_property_funcs(FILE *f, PropertyDefRNA *dp)
                        if(!pprop->get) pprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp);
                        if(!pprop->set) pprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp);
                        if(!pprop->structtype && !pprop->type) {
-                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have either type function or fixed type.\n", srna->cname, prop->cname);
+                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have either type function or fixed type.\n", srna->identifier, prop->identifier);
                                DefRNA.error= 1;
                        }
                        break;
@@ -405,19 +405,19 @@ static void rna_def_property_funcs(FILE *f, PropertyDefRNA *dp)
                        }
 
                        if(!cprop->begin) {
-                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a begin function.\n", srna->cname, prop->cname);
+                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a begin function.\n", srna->identifier, prop->identifier);
                                DefRNA.error= 1;
                        }
                        if(!cprop->next) {
-                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a next function.\n", srna->cname, prop->cname);
+                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a next function.\n", srna->identifier, prop->identifier);
                                DefRNA.error= 1;
                        }
                        if(!cprop->get) {
-                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a get function.\n", srna->cname, prop->cname);
+                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a get function.\n", srna->identifier, prop->identifier);
                                DefRNA.error= 1;
                        }
                        if(!cprop->structtype && !cprop->type) {
-                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have either type function or fixed type.\n", srna->cname, prop->cname);
+                               fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have either type function or fixed type.\n", srna->identifier, prop->identifier);
                                DefRNA.error= 1;
                        }
                        break;
@@ -431,7 +431,7 @@ static const char *rna_find_type(const char *type)
 
        for(ds=DefRNA.structs.first; ds; ds=ds->next)
                if(ds->dnaname && strcmp(ds->dnaname, type)==0)
-                       return ds->srna->cname;
+                       return ds->srna->identifier;
        
        return NULL;
 }
@@ -519,17 +519,17 @@ static void rna_generate_prototypes(BlenderRNA *brna, FILE *f)
        StructRNA *srna;
 
        for(srna=brna->structs.first; srna; srna=srna->next)
-               fprintf(f, "StructRNA RNA_%s;\n", srna->cname);
+               fprintf(f, "StructRNA RNA_%s;\n", srna->identifier);
        fprintf(f, "\n");
 
        fprintf(f, "BlenderRNA BLENDER_RNA = {");
 
        srna= brna->structs.first;
-       if(srna) fprintf(f, "{&RNA_%s, ", srna->cname);
+       if(srna) fprintf(f, "{&RNA_%s, ", srna->identifier);
        else fprintf(f, "{NULL, ");
 
        srna= brna->structs.last;
-       if(srna) fprintf(f, "&RNA_%s}", srna->cname);
+       if(srna) fprintf(f, "&RNA_%s}", srna->identifier);
        else fprintf(f, "NULL}");
 
        fprintf(f, "};\n\n");
@@ -545,7 +545,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                fprintf(f, "\n");
 
        for(prop=srna->properties.first; prop; prop=prop->next)
-               fprintf(f, "static %s rna_%s_%s;\n", rna_property_structname(prop->type), srna->cname, prop->cname);
+               fprintf(f, "static %s rna_%s_%s;\n", rna_property_structname(prop->type), srna->identifier, prop->identifier);
        fprintf(f, "\n");
 
        for(prop=srna->properties.first; prop; prop=prop->next) {
@@ -555,11 +555,11 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                int i;
 
                                if(eprop->item) {
-                                       fprintf(f, "static PropertyEnumItem rna_%s_%s_items[%d] = {", srna->cname, prop->cname, eprop->totitem);
+                                       fprintf(f, "static EnumPropertyItem rna_%s_%s_items[%d] = {", srna->identifier, prop->identifier, eprop->totitem);
 
                                        for(i=0; i<eprop->totitem; i++) {
                                                fprintf(f, "{%d, ", eprop->item[i].value);
-                                               rna_print_c_string(f, eprop->item[i].cname); fprintf(f, ", ");
+                                               rna_print_c_string(f, eprop->item[i].identifier); fprintf(f, ", ");
                                                rna_print_c_string(f, eprop->item[i].name); fprintf(f, "}");
                                                if(i != eprop->totitem-1)
                                                        fprintf(f, ", ");
@@ -568,7 +568,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                        fprintf(f, "};\n\n");
                                }
                                else {
-                                       fprintf(stderr, "rna_generate_structs: %s.%s, enum must have items defined.\n", srna->cname, prop->cname);
+                                       fprintf(stderr, "rna_generate_structs: %s.%s, enum must have items defined.\n", srna->identifier, prop->identifier);
                                        DefRNA.error= 1;
                                }
                                break;
@@ -578,7 +578,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                unsigned int i;
 
                                if(bprop->defaultarray) {
-                                       fprintf(f, "static int rna_%s_%s_default[%d] = {", srna->cname, prop->cname, prop->arraylength);
+                                       fprintf(f, "static int rna_%s_%s_default[%d] = {", srna->identifier, prop->identifier, prop->arraylength);
 
                                        for(i=0; i<prop->arraylength; i++) {
                                                fprintf(f, "%d", bprop->defaultarray[i]);
@@ -595,7 +595,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                unsigned int i;
 
                                if(iprop->defaultarray) {
-                                       fprintf(f, "static int rna_%s_%s_default[%d] = {", srna->cname, prop->cname, prop->arraylength);
+                                       fprintf(f, "static int rna_%s_%s_default[%d] = {", srna->identifier, prop->identifier, prop->arraylength);
 
                                        for(i=0; i<prop->arraylength; i++) {
                                                fprintf(f, "%d", iprop->defaultarray[i]);
@@ -612,7 +612,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                unsigned int i;
 
                                if(fprop->defaultarray) {
-                                       fprintf(f, "static float rna_%s_%s_default[%d] = {", srna->cname, prop->cname, prop->arraylength);
+                                       fprintf(f, "static float rna_%s_%s_default[%d] = {", srna->identifier, prop->identifier, prop->arraylength);
 
                                        for(i=0; i<prop->arraylength; i++) {
                                                rna_float_print(f, fprop->defaultarray[i]);
@@ -628,13 +628,13 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                break;
                }
 
-               fprintf(f, "static %s rna_%s_%s = {\n", rna_property_structname(prop->type), srna->cname, prop->cname);
+               fprintf(f, "static %s rna_%s_%s = {\n", rna_property_structname(prop->type), srna->identifier, prop->identifier);
 
-               if(prop->next) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->cname, prop->next->cname);
+               if(prop->next) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->identifier, prop->next->identifier);
                else fprintf(f, "\t{NULL, ");
-               if(prop->prev) fprintf(f, "(PropertyRNA*)&rna_%s_%s,\n", srna->cname, prop->prev->cname);
+               if(prop->prev) fprintf(f, "(PropertyRNA*)&rna_%s_%s,\n", srna->identifier, prop->prev->identifier);
                else fprintf(f, "NULL,\n");
-               fprintf(f, "\t"); rna_print_c_string(f, prop->cname);
+               fprintf(f, "\t"); rna_print_c_string(f, prop->identifier);
                fprintf(f, ", %d, ", prop->flag);
                rna_print_c_string(f, prop->name); fprintf(f, ",\n\t");
                rna_print_c_string(f, prop->description); fprintf(f, ",\n");
@@ -645,14 +645,14 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                        case PROP_BOOLEAN: {
                                BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
                                fprintf(f, "\t%s, %s, %s, %s, %d, ", rna_function_string(bprop->get), rna_function_string(bprop->set), rna_function_string(bprop->getarray), rna_function_string(bprop->setarray), bprop->defaultvalue);
-                               if(bprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->cname);
+                               if(bprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->identifier);
                                else fprintf(f, "NULL\n");
                                break;
                        }
                        case PROP_INT: {
                                IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
                                fprintf(f, "\t%s, %s, %s, %s, %d, %d, %d, %d, %d,\n\t%d, \n", rna_function_string(iprop->get), rna_function_string(iprop->set), rna_function_string(iprop->getarray), rna_function_string(iprop->setarray), iprop->softmin, iprop->softmax, iprop->hardmin, iprop->hardmax, iprop->step, iprop->defaultvalue);
-                               if(iprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->cname);
+                               if(iprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->identifier);
                                else fprintf(f, "NULL\n");
                                break;
                        }
@@ -666,7 +666,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                                rna_float_print(f, fprop->step); fprintf(f, ", ");
                                rna_float_print(f, fprop->precision); fprintf(f, ", ");
                                rna_float_print(f, fprop->defaultvalue); fprintf(f, ", ");
-                               if(fprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->cname);
+                               if(fprop->defaultarray) fprintf(f, "rna_%s_%s_default\n", srna->name, prop->identifier);
                                else fprintf(f, "NULL\n");
                                break;
                        }
@@ -678,7 +678,7 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                        }
                        case PROP_ENUM: {
                                EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
-                               fprintf(f, "\t%s, %s, rna_%s_%s_items, %d, %d\n", rna_function_string(eprop->get), rna_function_string(eprop->set), srna->cname, prop->cname, eprop->totitem, eprop->defaultvalue);
+                               fprintf(f, "\t%s, %s, rna_%s_%s_items, %d, %d\n", rna_function_string(eprop->get), rna_function_string(eprop->set), srna->identifier, prop->identifier, eprop->totitem, eprop->defaultvalue);
                                break;
                        }
                        case PROP_POINTER: {
@@ -700,31 +700,31 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                fprintf(f, "};\n\n");
        }
 
-       fprintf(f, "StructRNA RNA_%s = {\n", srna->cname);
+       fprintf(f, "StructRNA RNA_%s = {\n", srna->identifier);
 
-       if(srna->next) fprintf(f, "\t&RNA_%s, ", srna->next->cname);
+       if(srna->next) fprintf(f, "\t&RNA_%s, ", srna->next->identifier);
        else fprintf(f, "\tNULL, ");
-       if(srna->prev) fprintf(f, "&RNA_%s,\n", srna->prev->cname);
+       if(srna->prev) fprintf(f, "&RNA_%s,\n", srna->prev->identifier);
        else fprintf(f, "NULL,\n");
 
        fprintf(f, "\t");
-       rna_print_c_string(f, srna->cname);
+       rna_print_c_string(f, srna->identifier);
        fprintf(f, ", %d, ", srna->flag);
        rna_print_c_string(f, srna->name);
        fprintf(f, ",\n");
 
        prop= srna->nameproperty;
-       if(prop) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s, ", srna->cname, prop->cname);
+       if(prop) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s, ", srna->identifier, prop->identifier);
        else fprintf(f, "\tNULL, ");
 
-       fprintf(f, "\t(PropertyRNA*)&rna_%s_rna_properties,\n", srna->cname);
+       fprintf(f, "\t(PropertyRNA*)&rna_%s_rna_properties,\n", srna->identifier);
 
        prop= srna->properties.first;
-       if(prop) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->cname, prop->cname);
+       if(prop) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->identifier, prop->identifier);
        else fprintf(f, "\t{NULL, ");
 
        prop= srna->properties.last;
-       if(prop) fprintf(f, "(PropertyRNA*)&rna_%s_%s}\n", srna->cname, prop->cname);
+       if(prop) fprintf(f, "(PropertyRNA*)&rna_%s_%s}\n", srna->identifier, prop->identifier);
        else fprintf(f, "NULL}\n");
 
        fprintf(f, "};\n");
index afb83e97d33939a236633f970ff8564010250713..cdf2f4a8838f31852bd4e8b4b981f99978946386 100644 (file)
@@ -59,9 +59,9 @@ static void rna_pointer_inherit_id(PointerRNA *parent, PointerRNA *ptr)
 
 /* Structs */
 
-const char *RNA_struct_cname(PointerRNA *ptr)
+const char *RNA_struct_identifier(PointerRNA *ptr)
 {
-       return ptr->type->cname;
+       return ptr->type->identifier;
 }
 
 const char *RNA_struct_ui_name(PointerRNA *ptr)
@@ -81,9 +81,9 @@ PropertyRNA *RNA_struct_iterator_property(PointerRNA *ptr)
 
 /* Property Information */
 
-const char *RNA_property_cname(PropertyRNA *prop, PointerRNA *ptr)
+const char *RNA_property_identifier(PropertyRNA *prop, PointerRNA *ptr)
 {
-       return prop->cname;
+       return prop->identifier;
 }
 
 PropertyType RNA_property_type(PropertyRNA *prop, PointerRNA *ptr)
@@ -143,7 +143,7 @@ int RNA_property_string_maxlength(PropertyRNA *prop, PointerRNA *ptr)
        return sprop->maxlength;
 }
 
-void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const PropertyEnumItem **item, int *totitem)
+void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const EnumPropertyItem **item, int *totitem)
 {
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 
@@ -677,7 +677,7 @@ int RNA_path_resolve(PointerRNA *ptr, const char *path, PointerRNA *r_ptr, Prope
                prop= NULL;
 
                for(; iter.valid; RNA_property_collection_next(iterprop, &iter)) {
-                       if(strcmp(token, RNA_property_cname(iter.ptr.data, &iter.ptr)) == 0) {
+                       if(strcmp(token, RNA_property_identifier(iter.ptr.data, &iter.ptr)) == 0) {
                                prop= iter.ptr.data;
                                break;
                        }
@@ -747,14 +747,14 @@ char *RNA_path_append(const char *path, PropertyRNA *prop, int intkey, const cha
        
        dynstr= BLI_dynstr_new();
 
-       /* add .cname */
+       /* add .identifier */
        if(path) {
                BLI_dynstr_append(dynstr, (char*)path);
                if(*path)
                        BLI_dynstr_append(dynstr, ".");
        }
 
-       BLI_dynstr_append(dynstr, (char*)prop->cname);
+       BLI_dynstr_append(dynstr, (char*)prop->identifier);
 
        if(prop->type == PROP_COLLECTION) {
                /* add ["strkey"] or [intkey] */
index 8e16c422409225489ba5a187b786c8ed2caacaff..9da72701523430f3747f4d992b9435aa059237f4 100644 (file)
@@ -193,7 +193,7 @@ void RNA_free(BlenderRNA *brna)
 
 /* Struct Definition */
 
-StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name)
+StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *name)
 {
        StructRNA *srna;
        StructDefRNA *ds;
@@ -202,14 +202,14 @@ StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name)
        rna_addtail(&DefRNA.structs, ds);
 
        srna= MEM_callocN(sizeof(StructRNA), "StructRNA");
-       srna->cname= cname;
+       srna->identifier= identifier;
        srna->name= name;
 
        ds->srna= srna;
 
        rna_addtail(&brna->structs, srna);
 
-       RNA_def_struct_sdna(srna, srna->cname);
+       RNA_def_struct_sdna(srna, srna->identifier);
 
        rna_def_builtin_properties(srna);
 
@@ -234,7 +234,7 @@ void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
 void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop)
 {
        if(prop->type != PROP_STRING) {
-               fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->cname, prop->cname);
+               fprintf(stderr, "RNA_def_struct_name_property: %s.%s, must be a string property.\n", srna->identifier, prop->identifier);
                DefRNA.error= 1;
        }
        else
@@ -248,7 +248,7 @@ void RNA_def_struct_flag(StructRNA *srna, int flag)
 
 /* Property Definition */
 
-PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int subtype)
+PropertyRNA *RNA_def_property(StructRNA *srna, const char *identifier, int type, int subtype)
 {
        StructDefRNA *ds;
        PropertyDefRNA *dp;
@@ -308,7 +308,7 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int
                        prop= MEM_callocN(sizeof(CollectionPropertyRNA), "CollectionPropertyRNA");
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", ds->srna->cname, cname);
+                       fprintf(stderr, "RNA_def_property: %s.%s, invalid property type.\n", ds->srna->identifier, identifier);
                        DefRNA.error= 1;
                        return NULL;
        }
@@ -316,10 +316,10 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int
        dp->srna= srna;
        dp->prop= prop;
 
-       prop->cname= cname;
+       prop->identifier= identifier;
        prop->type= type;
        prop->subtype= subtype;
-       prop->name= cname;
+       prop->name= identifier;
        prop->description= "";
 
        if(type == PROP_COLLECTION)
@@ -330,40 +330,40 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int
        switch(type) {
                case PROP_BOOLEAN:
                        DefRNA.silent= 1;
-                       RNA_def_property_boolean_sdna(prop, srna->cname, cname, 0);
+                       RNA_def_property_boolean_sdna(prop, srna->identifier, identifier, 0);
                        DefRNA.silent= 0;
                        break;
                case PROP_INT: {
                        DefRNA.silent= 1;
-                       RNA_def_property_int_sdna(prop, srna->cname, cname);
+                       RNA_def_property_int_sdna(prop, srna->identifier, identifier);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_FLOAT: {
                        DefRNA.silent= 1;
-                       RNA_def_property_float_sdna(prop, srna->cname, cname);
+                       RNA_def_property_float_sdna(prop, srna->identifier, identifier);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_STRING: {
                        DefRNA.silent= 1;
-                       RNA_def_property_string_sdna(prop, srna->cname, cname);
+                       RNA_def_property_string_sdna(prop, srna->identifier, identifier);
                        DefRNA.silent= 0;
                        break;
                }
                case PROP_ENUM:
                        DefRNA.silent= 1;
-                       RNA_def_property_enum_sdna(prop, srna->cname, cname);
+                       RNA_def_property_enum_sdna(prop, srna->identifier, identifier);
                        DefRNA.silent= 0;
                        break;
                case PROP_POINTER:
                        DefRNA.silent= 1;
-                       RNA_def_property_pointer_sdna(prop, srna->cname, cname);
+                       RNA_def_property_pointer_sdna(prop, srna->identifier, identifier);
                        DefRNA.silent= 0;
                        break;
                case PROP_COLLECTION:
                        DefRNA.silent= 1;
-                       RNA_def_property_collection_sdna(prop, srna->cname, cname, NULL);
+                       RNA_def_property_collection_sdna(prop, srna->identifier, identifier, NULL);
                        DefRNA.silent= 0;
                        break;
        }
@@ -384,7 +384,7 @@ void RNA_def_property_flag(PropertyRNA *prop, int flag)
 #if 0
        if(prop->type != PROP_POINTER && prop->type != PROP_COLLECTION) {
                if(flag & (PROP_EVALUATE_DEPENDENCY|PROP_INVERSE_EVALUATE_DEPENDENCY|PROP_RENDER_DEPENDENCY|PROP_INVERSE_RENDER_DEPENDENCY)) {
-                       fprintf(stderr, "RNA_def_property_flag: %s.%s, only pointer and collection types can create dependencies.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_flag: %s.%s, only pointer and collection types can create dependencies.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                }
        }
@@ -402,7 +402,7 @@ void RNA_def_property_array(PropertyRNA *prop, int arraylength)
                        prop->arraylength= arraylength;
                        break;
                default:
-                       fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_array: %s.%s, only boolean/int/float can be array.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -414,7 +414,7 @@ void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *d
        prop->description= description;
 }
 
-void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, double precision)
+void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
 {
        StructDefRNA *ds= DefRNA.structs.last;
 
@@ -431,11 +431,11 @@ void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double
                        fprop->softmin= (float)min;
                        fprop->softmax= (float)max;
                        fprop->step= (float)step;
-                       fprop->precision= (float)precision;
+                       fprop->precision= (int)precision;
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_ui_range: %s.%s, invalid type for ui range.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -463,7 +463,7 @@ void RNA_def_property_range(PropertyRNA *prop, double min, double max)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_range: %s.%s, invalid type for range.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -485,13 +485,13 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
 }
 
-void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item)
+void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
 {
        StructDefRNA *ds= DefRNA.structs.last;
        int i;
@@ -501,13 +501,13 @@ void RNA_def_property_enum_items(PropertyRNA *prop, const PropertyEnumItem *item
                        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
                        eprop->item= item;
                        eprop->totitem= 0;
-                       for(i=0; item[i].cname; i++)
+                       for(i=0; item[i].identifier; i++)
                                eprop->totitem++;
 
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_struct_type: %s.%s, invalid type for struct type.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -524,7 +524,7 @@ void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_string_maxlength: %s.%s, type is not string.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -541,7 +541,7 @@ void RNA_def_property_boolean_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -558,7 +558,7 @@ void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_boolean_default: %s.%s, type is not boolean.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -575,7 +575,7 @@ void RNA_def_property_int_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -592,7 +592,7 @@ void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_int_default: %s.%s, type is not int.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -609,7 +609,7 @@ void RNA_def_property_float_default(PropertyRNA *prop, float value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -626,7 +626,7 @@ void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_float_default: %s.%s, type is not float.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -643,7 +643,7 @@ void RNA_def_property_string_default(PropertyRNA *prop, const char *value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_string_default: %s.%s, type is not string.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -660,7 +660,7 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value)
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_enum_default: %s.%s, type is not enum.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -677,7 +677,7 @@ static PropertyDefRNA *rna_def_property_sdna(PropertyRNA *prop, const char *stru
        if(!structname)
                structname= ds->dnaname;
        if(!propname)
-               propname= prop->cname;
+               propname= prop->identifier;
 
        if(!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
                if(!DefRNA.silent) {
@@ -855,7 +855,7 @@ void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const ch
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -880,7 +880,7 @@ void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -905,7 +905,7 @@ void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -924,7 +924,7 @@ void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -944,7 +944,7 @@ void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const cha
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -964,7 +964,7 @@ void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const ch
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
@@ -989,7 +989,7 @@ void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, con
                        break;
                }
                default:
-                       fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", ds->srna->cname, prop->cname);
+                       fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", ds->srna->identifier, prop->identifier);
                        DefRNA.error= 1;
                        break;
        }
index a8f99a9dcb68dde937e6bf8d96439f1ed96943d5..fe39a78fbe78390ca2c791d833687ac45c2be04e 100644 (file)
@@ -86,7 +86,7 @@ void RNA_test_dependencies_cb(void *udata, PointerRNA *from, PointerRNA *to)
        if(prop) RNA_property_string_get(prop, to, nameto);
        else strcpy(nameto, "unknown");
        
-       printf("%s (%s) -> %s (%s)\n", name, from->type->cname, nameto, to->type->cname);
+       printf("%s (%s) -> %s (%s)\n", name, from->type->identifier, nameto, to->type->identifier);
 }
 #endif
 
index d09b593e884413d6e1848b8cb39d1311e6f2b76c..90d2fdd88f990635b1ccaa1837afcfda581374a2 100644 (file)
@@ -77,7 +77,7 @@ extern StructRNA RNA_Main;
 extern StructRNA RNA_Mesh;
 extern StructRNA RNA_Object;
 extern StructRNA RNA_Scene;
-extern StructRNA RNA_StructRNA;
+extern StructRNA RNA_Struct;
 
 void RNA_def_ID(struct StructRNA *srna);
 
index 02746681d4ae08f5c2d939c75ae71dadba633038..9c38bf139a2c4ed4cdc9390bb7ff30931f64802a 100644 (file)
 
 /* Struct */
 
-static void rna_StructRNA_cname_get(PointerRNA *ptr, char *value)
+static void rna_Struct_identifier_get(PointerRNA *ptr, char *value)
 {
-       strcpy(value, ((StructRNA*)ptr->data)->cname);
+       strcpy(value, ((StructRNA*)ptr->data)->identifier);
 }
 
-static int rna_StructRNA_cname_length(PointerRNA *ptr)
+static int rna_Struct_identifier_length(PointerRNA *ptr)
 {
-       return strlen(((StructRNA*)ptr->data)->cname);
+       return strlen(((StructRNA*)ptr->data)->identifier);
 }
 
-static void rna_StructRNA_name_get(PointerRNA *ptr, char *value)
+static void rna_Struct_name_get(PointerRNA *ptr, char *value)
 {
        strcpy(value, ((StructRNA*)ptr->data)->name);
 }
 
-static int rna_StructRNA_name_length(PointerRNA *ptr)
+static int rna_Struct_name_length(PointerRNA *ptr)
 {
        return strlen(((StructRNA*)ptr->data)->name);
 }
 
-static void *rna_StructRNA_name_property_get(PointerRNA *ptr)
+static void *rna_Struct_name_property_get(PointerRNA *ptr)
 {
        return ((StructRNA*)ptr->data)->nameproperty;
 }
 
-static void rna_StructRNA_properties_next(CollectionPropertyIterator *iter)
+static void rna_Struct_properties_next(CollectionPropertyIterator *iter)
 {
        do {
                rna_iterator_listbase_next(iter);
        } while(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN));
 }
 
-static void rna_StructRNA_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+static void rna_Struct_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        rna_iterator_listbase_begin(iter, &((StructRNA*)ptr->data)->properties);
 
        if(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN))
-               rna_StructRNA_properties_next(iter);
+               rna_Struct_properties_next(iter);
 }
 
-static void *rna_StructRNA_properties_get(CollectionPropertyIterator *iter)
+static void *rna_Struct_properties_get(CollectionPropertyIterator *iter)
 {
        return rna_iterator_listbase_get(iter);
 }
 
-static StructRNA *rna_StructRNA_properties_type(CollectionPropertyIterator *iter)
+static StructRNA *rna_Struct_properties_type(CollectionPropertyIterator *iter)
 {
        PropertyRNA *prop= iter->internal;
 
        switch(prop->type) {
-               case PROP_BOOLEAN: return &RNA_BooleanPropertyRNA;
-               case PROP_INT: return &RNA_IntPropertyRNA;
-               case PROP_FLOAT: return &RNA_FloatPropertyRNA;
-               case PROP_STRING: return &RNA_StringPropertyRNA;
-               case PROP_ENUM: return &RNA_EnumPropertyRNA;
-               case PROP_POINTER: return &RNA_PointerPropertyRNA;
-               case PROP_COLLECTION: return &RNA_CollectionPropertyRNA;
+               case PROP_BOOLEAN: return &RNA_BooleanProperty;
+               case PROP_INT: return &RNA_IntProperty;
+               case PROP_FLOAT: return &RNA_FloatProperty;
+               case PROP_STRING: return &RNA_StringProperty;
+               case PROP_ENUM: return &RNA_EnumProperty;
+               case PROP_POINTER: return &RNA_PointerProperty;
+               case PROP_COLLECTION: return &RNA_CollectionProperty;
                default: return NULL;
        }
 }
@@ -98,7 +98,7 @@ static void rna_builtin_properties_begin(CollectionPropertyIterator *iter, Point
        PointerRNA newptr;
 
        /* we create a new with the type as the data */
-       newptr.type= &RNA_StructRNA;
+       newptr.type= &RNA_Struct;
        newptr.data= ptr->type;
 
        if(ptr->type->flag & STRUCT_ID) {
@@ -110,22 +110,22 @@ static void rna_builtin_properties_begin(CollectionPropertyIterator *iter, Point
                newptr.id.data= NULL;
        }
 
-       rna_StructRNA_properties_begin(iter, &newptr);
+       rna_Struct_properties_begin(iter, &newptr);
 }
 
 static void rna_builtin_properties_next(CollectionPropertyIterator *iter)
 {
-       rna_StructRNA_properties_next(iter);
+       rna_Struct_properties_next(iter);
 }
 
 static void *rna_builtin_properties_get(CollectionPropertyIterator *iter)
 {
-       return rna_StructRNA_properties_get(iter);
+       return rna_Struct_properties_get(iter);
 }
 
 static StructRNA *rna_builtin_properties_type(CollectionPropertyIterator *iter)
 {
-       return rna_StructRNA_properties_type(iter);
+       return rna_Struct_properties_type(iter);
 }
 
 static void *rna_builtin_type_get(PointerRNA *ptr)
@@ -135,62 +135,158 @@ static void *rna_builtin_type_get(PointerRNA *ptr)
 
 /* Property */
 
-static void rna_PropertyRNA_cname_get(PointerRNA *ptr, char *value)
+static void rna_Property_identifier_get(PointerRNA *ptr, char *value)
 {
-       strcpy(value, ((PropertyRNA*)ptr->data)->cname);
+       strcpy(value, ((PropertyRNA*)ptr->data)->identifier);
 }
 
-static int rna_PropertyRNA_cname_length(PointerRNA *ptr)
+static int rna_Property_identifier_length(PointerRNA *ptr)
 {
-       return strlen(((PropertyRNA*)ptr->data)->cname);
+       return strlen(((PropertyRNA*)ptr->data)->identifier);
 }
 
-static void rna_PropertyRNA_name_get(PointerRNA *ptr, char *value)
+static void rna_Property_name_get(PointerRNA *ptr, char *value)
 {
        strcpy(value, ((PropertyRNA*)ptr->data)->name);
 }
 
-static int rna_PropertyRNA_name_length(PointerRNA *ptr)
+static int rna_Property_name_length(PointerRNA *ptr)
 {
        return strlen(((PropertyRNA*)ptr->data)->name);
 }
 
-static void rna_PropertyRNA_description_get(PointerRNA *ptr, char *value)
+static void rna_Property_description_get(PointerRNA *ptr, char *value)
 {
        strcpy(value, ((PropertyRNA*)ptr->data)->description);
 }
 
-static int rna_PropertyRNA_description_length(PointerRNA *ptr)
+static int rna_Property_description_length(PointerRNA *ptr)
 {
        return strlen(((PropertyRNA*)ptr->data)->description);
 }
 
-static int rna_PropertyRNA_type_get(PointerRNA *ptr)
+static int rna_Property_type_get(PointerRNA *ptr)
 {
        return ((PropertyRNA*)ptr->data)->type;
 }
 
-static int rna_PropertyRNA_subtype_get(PointerRNA *ptr)
+static int rna_Property_subtype_get(PointerRNA *ptr)
 {
        return ((PropertyRNA*)ptr->data)->subtype;
 }
 
-static int rna_PropertyRNA_array_length_get(PointerRNA *ptr)
+static int rna_Property_array_length_get(PointerRNA *ptr)
 {
        return ((PropertyRNA*)ptr->data)->arraylength;
 }
 
-static int rna_PropertyRNA_max_length_get(PointerRNA *ptr)
+static int rna_IntProperty_hard_min_get(PointerRNA *ptr)
+{
+       return ((IntPropertyRNA*)ptr->data)->hardmin;
+}
+
+static int rna_IntProperty_hard_max_get(PointerRNA *ptr)
+{
+       return ((IntPropertyRNA*)ptr->data)->hardmax;
+}
+
+static int rna_IntProperty_soft_min_get(PointerRNA *ptr)
+{
+       return ((IntPropertyRNA*)ptr->data)->softmin;
+}
+
+static int rna_IntProperty_soft_max_get(PointerRNA *ptr)
+{
+       return ((IntPropertyRNA*)ptr->data)->softmax;
+}
+
+static int rna_IntProperty_step_get(PointerRNA *ptr)
+{
+       return ((IntPropertyRNA*)ptr->data)->step;
+}
+
+static float rna_FloatProperty_hard_min_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->hardmin;
+}
+
+static float rna_FloatProperty_hard_max_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->hardmax;
+}
+
+static float rna_FloatProperty_soft_min_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->softmin;
+}
+
+static float rna_FloatProperty_soft_max_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->softmax;
+}
+
+static float rna_FloatProperty_step_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->step;
+}
+
+static int rna_FloatProperty_precision_get(PointerRNA *ptr)
+{
+       return ((FloatPropertyRNA*)ptr->data)->precision;
+}
+
+static int rna_StringProperty_max_length_get(PointerRNA *ptr)
 {
        return ((StringPropertyRNA*)ptr->data)->maxlength;
 }
 
+static void rna_EnumProperty_items_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       EnumPropertyRNA *eprop= (EnumPropertyRNA*)ptr->data;
+       rna_iterator_array_begin(iter, (void*)eprop->item, sizeof(eprop->item[0]), eprop->totitem);
+}
+
+static void rna_EnumPropertyItem_identifier_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((EnumPropertyItem*)ptr->data)->identifier);
+}
+
+static int rna_EnumPropertyItem_identifier_length(PointerRNA *ptr)
+{
+       return strlen(((EnumPropertyItem*)ptr->data)->identifier);
+}
+
+static void rna_EnumPropertyItem_name_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((EnumPropertyItem*)ptr->data)->name);
+}
+
+static int rna_EnumPropertyItem_name_length(PointerRNA *ptr)
+{
+       return strlen(((EnumPropertyItem*)ptr->data)->name);
+}
+
+static int rna_EnumPropertyItem_value_get(PointerRNA *ptr)
+{
+       return ((EnumPropertyItem*)ptr->data)->value;
+}
+
+static void *rna_PointerProperty_fixed_type_get(PointerRNA *ptr)
+{
+       return ((PointerPropertyRNA*)ptr->data)->structtype;
+}
+
+static void *rna_CollectionProperty_fixed_type_get(PointerRNA *ptr)
+{
+       return ((CollectionPropertyRNA*)ptr->data)->structtype;
+}
+
 #else
 
 static void rna_def_property(StructRNA *srna)
 {
        PropertyRNA *prop;
-       static PropertyEnumItem type_items[] = {
+       static EnumPropertyItem type_items[] = {
                {PROP_BOOLEAN, "BOOLEAN", "Boolean"},
                {PROP_INT, "INT", "Integer"},
                {PROP_FLOAT, "FLOAT", "Float"},
@@ -199,7 +295,7 @@ static void rna_def_property(StructRNA *srna)
                {PROP_POINTER, "POINTER", "Pointer"},
                {PROP_COLLECTION, "COLLECTION", "Collection"},
                {0, NULL, NULL}};
-       static PropertyEnumItem subtype_items[] = {
+       static EnumPropertyItem subtype_items[] = {
                {PROP_NONE, "NONE", "None"},
                {PROP_UNSIGNED, "UNSIGNED", "Unsigned Number"},
                {PROP_FILEPATH, "FILEPATH", "File Path"},
@@ -211,110 +307,194 @@ static void rna_def_property(StructRNA *srna)
 
        prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_string_funcs(prop, "rna_PropertyRNA_name_get", "rna_PropertyRNA_name_length", NULL);
+       RNA_def_property_string_funcs(prop, "rna_Property_name_get", "rna_Property_name_length", NULL);
        RNA_def_property_ui_text(prop, "Name", "Human readable name.");
        RNA_def_struct_name_property(srna, prop);
 
-       prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE);
+       prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_string_funcs(prop, "rna_PropertyRNA_cname_get", "rna_PropertyRNA_cname_length", NULL);
+       RNA_def_property_string_funcs(prop, "rna_Property_identifier_get", "rna_Property_identifier_length", NULL);
        RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
 
        prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_string_funcs(prop, "rna_PropertyRNA_description_get", "rna_PropertyRNA_description_length", NULL);
+       RNA_def_property_string_funcs(prop, "rna_Property_description_get", "rna_Property_description_length", NULL);
        RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips.");
 
        prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_type_get", NULL);
+       RNA_def_property_enum_funcs(prop, "rna_Property_type_get", NULL);
        RNA_def_property_ui_text(prop, "Type", "Data type of the property.");
 
        prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
        RNA_def_property_enum_items(prop, subtype_items);
-       RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_subtype_get", NULL);
+       RNA_def_property_enum_funcs(prop, "rna_Property_subtype_get", NULL);
        RNA_def_property_ui_text(prop, "Sub Type", "Sub type indicating the interpretation of the property.");
 }
 
+static void rna_def_number_property(StructRNA *srna, PropertyType type)
+{
+       PropertyRNA *prop;
+
+       prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_int_funcs(prop, "rna_Property_array_length_get", NULL);
+       RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
+
+       if(type == PROP_BOOLEAN)
+               return;
+
+       prop= RNA_def_property(srna, "hard_min", type, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_min_get", NULL);
+       else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_min_get", NULL);
+       RNA_def_property_ui_text(prop, "Hard Minimum", "Minimum value used by buttons.");
+
+       prop= RNA_def_property(srna, "hard_max", type, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_hard_max_get", NULL);
+       else RNA_def_property_float_funcs(prop, "rna_FloatProperty_hard_max_get", NULL);
+       RNA_def_property_ui_text(prop, "Hard Maximum", "Maximum value used by buttons.");
+
+       prop= RNA_def_property(srna, "soft_min", type, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_min_get", NULL);
+       else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_min_get", NULL);
+       RNA_def_property_ui_text(prop, "Soft Minimum", "Minimum value used by buttons.");
+
+       prop= RNA_def_property(srna, "soft_max", type, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_soft_max_get", NULL);
+       else RNA_def_property_float_funcs(prop, "rna_FloatProperty_soft_max_get", NULL);
+       RNA_def_property_ui_text(prop, "Soft Maximum", "Maximum value used by buttons.");
+
+       prop= RNA_def_property(srna, "step", type, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       if(type == PROP_INT) RNA_def_property_int_funcs(prop, "rna_IntProperty_step_get", NULL);
+       else RNA_def_property_float_funcs(prop, "rna_FloatProperty_step_get", NULL);
+       RNA_def_property_ui_text(prop, "Step", "Step size used by number buttons, for floats 1/100th of the step size.");
+
+       if(type == PROP_FLOAT) {
+               prop= RNA_def_property(srna, "precision", PROP_INT, PROP_NONE);
+               RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+               RNA_def_property_int_funcs(prop, "rna_FloatProperty_precision_get", NULL);
+               RNA_def_property_ui_text(prop, "Precision", "Number of digits after the dot used by buttons.");
+       }
+}
+
+static void rna_def_enum_property(BlenderRNA *brna, StructRNA *srna)
+{
+       PropertyRNA *prop;
+
+       prop= RNA_def_property(srna, "items", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_struct_type(prop, "EnumPropertyItem");
+       RNA_def_property_collection_funcs(prop, "rna_EnumProperty_items_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", 0, 0, 0, 0);
+       RNA_def_property_ui_text(prop, "Items", "Possible values for the property.");
+
+       srna= RNA_def_struct(brna, "EnumPropertyItem", "Enum Item Definition");
+
+       prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_name_get", "rna_EnumPropertyItem_name_length", NULL);
+       RNA_def_property_ui_text(prop, "Name", "Human readable name.");
+       RNA_def_struct_name_property(srna, prop);
+
+       prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_string_funcs(prop, "rna_EnumPropertyItem_identifier_get", "rna_EnumPropertyItem_identifier_length", NULL);
+       RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
+
+       prop= RNA_def_property(srna, "value", PROP_INT, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_int_funcs(prop, "rna_EnumPropertyItem_value_get", NULL);
+       RNA_def_property_ui_text(prop, "Value", "Value of the item.");
+}
+
+static void rna_def_pointer_property(StructRNA *srna, PropertyType type)
+{
+       PropertyRNA *prop;
+
+       prop= RNA_def_property(srna, "fixed_type", PROP_POINTER, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_struct_type(prop, "Struct");
+       if(type == PROP_POINTER)
+               RNA_def_property_pointer_funcs(prop, "rna_PointerProperty_fixed_type_get", NULL, NULL);
+       else
+               RNA_def_property_pointer_funcs(prop, "rna_CollectionProperty_fixed_type_get", NULL, NULL);
+       RNA_def_property_ui_text(prop, "Pointer Type", "Fixed pointer type, empty if variable type.");
+}
+
 void RNA_def_rna(BlenderRNA *brna)
 {
        StructRNA *srna;
        PropertyRNA *prop;
 
        /* StructRNA */
-       srna= RNA_def_struct(brna, "StructRNA", "Struct RNA");
+       srna= RNA_def_struct(brna, "Struct", "Struct Definition");
 
        prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_string_funcs(prop, "rna_StructRNA_name_get", "rna_StructRNA_name_length", NULL);
+       RNA_def_property_string_funcs(prop, "rna_Struct_name_get", "rna_Struct_name_length", NULL);
        RNA_def_property_ui_text(prop, "Name", "Human readable name.");
        RNA_def_struct_name_property(srna, prop);
 
-       prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE);
+       prop= RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_string_funcs(prop, "rna_StructRNA_cname_get", "rna_StructRNA_cname_length", NULL);
+       RNA_def_property_string_funcs(prop, "rna_Struct_identifier_get", "rna_Struct_identifier_length", NULL);
        RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting.");
 
        prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_struct_type(prop, "StringPropertyRNA");
-       RNA_def_property_pointer_funcs(prop, "rna_StructRNA_name_property_get", NULL, NULL);
+       RNA_def_property_struct_type(prop, "StringProperty");
+       RNA_def_property_pointer_funcs(prop, "rna_Struct_name_property_get", NULL, NULL);
        RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct.");
 
        prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_collection_funcs(prop, "rna_StructRNA_properties_begin", "rna_StructRNA_properties_next", 0, "rna_StructRNA_properties_get", "rna_StructRNA_properties_type", 0, 0, 0);
+       RNA_def_property_collection_funcs(prop, "rna_Struct_properties_begin", "rna_Struct_properties_next", 0, "rna_Struct_properties_get", "rna_Struct_properties_type", 0, 0, 0);
        RNA_def_property_ui_text(prop, "Properties", "Properties in the struct.");
 
-       /* BooleanPropertyRNA */
-       srna= RNA_def_struct(brna, "BooleanPropertyRNA", "Boolean Property");
+       /* BooleanProperty */
+       srna= RNA_def_struct(brna, "BooleanProperty", "Boolean Definition");
        rna_def_property(srna);
+       rna_def_number_property(srna, PROP_BOOLEAN);
 
-       prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
-       RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
-
-       /* IntPropertyRNA */
-       srna= RNA_def_struct(brna, "IntPropertyRNA", "Int Property");
+       /* IntProperty */
+       srna= RNA_def_struct(brna, "IntProperty", "Int Definition");
        rna_def_property(srna);
+       rna_def_number_property(srna, PROP_INT);
 
-       prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
-       RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
-
-       /* FloatPropertyRNA */
-       srna= RNA_def_struct(brna, "FloatPropertyRNA", "Float Property");
+       /* FloatProperty */
+       srna= RNA_def_struct(brna, "FloatProperty", "Float Definition");
        rna_def_property(srna);
+       rna_def_number_property(srna, PROP_FLOAT);
 
-       prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL);
-       RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited.");
-
-       /* StringPropertyRNA */
-       srna= RNA_def_struct(brna, "StringPropertyRNA", "String Property");
+       /* StringProperty */
+       srna= RNA_def_struct(brna, "StringProperty", "String Definition");
        rna_def_property(srna);
 
        prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_int_funcs(prop, "rna_PropertyRNA_max_length_get", NULL);
+       RNA_def_property_int_funcs(prop, "rna_StringProperty_max_length_get", NULL);
        RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited.");
 
-       /* EnumPropertyRNA */
-       srna= RNA_def_struct(brna, "EnumPropertyRNA", "Enum Property");
+       /* EnumProperty */
+       srna= RNA_def_struct(brna, "EnumProperty", "Enum Definition");
        rna_def_property(srna);
+       rna_def_enum_property(brna, srna);
 
-       /* PointerPropertyRNA */
-       srna= RNA_def_struct(brna, "PointerPropertyRNA", "Pointer Property");
+       /* PointerProperty */
+       srna= RNA_def_struct(brna, "PointerProperty", "Pointer Definition");
        rna_def_property(srna);
+       rna_def_pointer_property(srna, PROP_POINTER);
 
-       /* CollectionPropertyRNA */
-       srna= RNA_def_struct(brna, "CollectionPropertyRNA", "Collection Property");
+       /* CollectionProperty */
+       srna= RNA_def_struct(brna, "CollectionProperty", "Collection Definition");
        rna_def_property(srna);
+       rna_def_pointer_property(srna, PROP_COLLECTION);
 }
 
 void rna_def_builtin_properties(StructRNA *srna)
@@ -328,7 +508,7 @@ void rna_def_builtin_properties(StructRNA *srna)
 
        prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
-       RNA_def_property_struct_type(prop, "StructRNA");
+       RNA_def_property_struct_type(prop, "Struct");
        RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
        RNA_def_property_ui_text(prop, "Type", "RNA type definition.");
 }
index 181b7a5b7a93963247336f6d8703d4ff294fe86c..5e6743e56ff675ce3b6f17a5a12526d4408a6cc1 100644 (file)
@@ -59,8 +59,8 @@ void RNA_def_scene(BlenderRNA *brna)
 {
        StructRNA *srna;
        PropertyRNA *prop;
-       static PropertyEnumItem prop_mode_items[] = {{PROP_SMOOTH, "SMOOTH", "Smooth"}, {PROP_SPHERE, "SPHERE", "Sphere"}, {PROP_ROOT, "ROOT", "Root"}, {PROP_SHARP, "SHARP", "Sharp"}, {PROP_LIN, "LINEAR", "Linear"}, {PROP_CONST, "CONSTANT", "Constant"}, {PROP_RANDOM, "RANDOM", "Random"}, {0, NULL, NULL}};
-       static PropertyEnumItem unwrapper_items[] = {{0, "CONFORMAL", "Conformal"}, {1, "ANGLEBASED", "Angle Based"},  {0, NULL, NULL}};
+       static EnumPropertyItem prop_mode_items[] = {{PROP_SMOOTH, "SMOOTH", "Smooth"}, {PROP_SPHERE, "SPHERE", "Sphere"}, {PROP_ROOT, "ROOT", "Root"}, {PROP_SHARP, "SHARP", "Sharp"}, {PROP_LIN, "LINEAR", "Linear"}, {PROP_CONST, "CONSTANT", "Constant"}, {PROP_RANDOM, "RANDOM", "Random"}, {0, NULL, NULL}};
+       static EnumPropertyItem unwrapper_items[] = {{0, "CONFORMAL", "Conformal"}, {1, "ANGLEBASED", "Angle Based"},  {0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "Scene", "Scene");