RNA
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 14 Nov 2008 14:34:19 +0000 (14:34 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Fri, 14 Nov 2008 14:34:19 +0000 (14:34 +0000)
* Added accessor functions for structs and properties instead of
  direct access, in preparation of wrapping ID properties.
* Added more error prints for wrong defines.
* Wrap RNA data structures with RNA.
* Disable dependency code for now to avoid confusion.

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_object.c
source/blender/makesrna/intern/rna_rna.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_scene.c

index ed07120a619b8fb54dd5bd1325cd054864fbdf42..cee371b91ab9ff7cfe36e06bd0cde5a1a79c032a 100644 (file)
 #ifndef RNA_ACCESS
 #define RNA_ACCESS
 
+#include "RNA_types.h"
+
 struct bContext;
-struct BlenderRNA;
-struct StructRNA;
-struct PropertyRNA;
-struct PointerRNA;
-struct CollectionPropertyIterator;
 struct Main;
 
 /* Pointer
@@ -38,53 +35,84 @@ struct Main;
  * Currently only an RNA pointer to Main can be obtained, this
  * should  be extended to allow making other pointers as well. */
 
-void RNA_pointer_main_get(struct Main *main, struct PointerRNA *r_ptr);
+void RNA_pointer_main_get(struct Main *main, PointerRNA *r_ptr);
+
+/* Structs */
+
+const char *RNA_struct_cname(PointerRNA *ptr);
+const char *RNA_struct_ui_name(PointerRNA *ptr);
+
+PropertyRNA *RNA_struct_name_property(PointerRNA *ptr);
+PropertyRNA *RNA_struct_iterator_property(PointerRNA *ptr);
 
-/* Property
+/* Properties
  *
  * Access to struct properties. All this works with RNA pointers rather than
  * direct pointers to the data. */
 
-int RNA_property_editable(struct PropertyRNA *prop, struct PointerRNA *ptr);
-int RNA_property_evaluated(struct PropertyRNA *prop, struct PointerRNA *ptr);
+/* Property Information */
+
+const char *RNA_property_cname(PropertyRNA *prop, PointerRNA *ptr);
+PropertyType RNA_property_type(PropertyRNA *prop, PointerRNA *ptr);
+PropertySubType RNA_property_subtype(PropertyRNA *prop, PointerRNA *ptr);
+
+int RNA_property_array_length(PropertyRNA *prop, PointerRNA *ptr);
+
+void RNA_property_int_range(PropertyRNA *prop, PointerRNA *ptr, int *hardmin, int *hardmax);
+void RNA_property_int_ui_range(PropertyRNA *prop, PointerRNA *ptr, int *softmin, int *softmax, int *step);
+
+void RNA_property_float_range(PropertyRNA *prop, PointerRNA *ptr, float *hardmin, float *hardmax);
+void RNA_property_float_ui_range(PropertyRNA *prop, PointerRNA *ptr, float *softmin, float *softmax, float *step, float *precision);
+
+int RNA_property_string_maxlength(PropertyRNA *prop, PointerRNA *ptr);
+
+void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const PropertyEnumItem **item, int *totitem);
+
+const char *RNA_property_ui_name(PropertyRNA *prop, PointerRNA *ptr);
+const char *RNA_property_ui_description(PropertyRNA *prop, PointerRNA *ptr);
+
+int RNA_property_editable(PropertyRNA *prop, PointerRNA *ptr);
+int RNA_property_evaluated(PropertyRNA *prop, PointerRNA *ptr);
+
+void RNA_property_notify(PropertyRNA *prop, struct bContext *C, PointerRNA *ptr);
 
-void RNA_property_notify(struct PropertyRNA *prop, struct bContext *C, struct PointerRNA *ptr);
+/* Property Data */
 
-int RNA_property_boolean_get(struct PropertyRNA *prop, struct PointerRNA *ptr);
-void RNA_property_boolean_set(struct PropertyRNA *prop, struct PointerRNA *ptr, int value);
-int RNA_property_boolean_get_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index);
-void RNA_property_boolean_set_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index, int value);
+int RNA_property_boolean_get(PropertyRNA *prop, PointerRNA *ptr);
+void RNA_property_boolean_set(PropertyRNA *prop, PointerRNA *ptr, int value);
+int RNA_property_boolean_get_array(PropertyRNA *prop, PointerRNA *ptr, int index);
+void RNA_property_boolean_set_array(PropertyRNA *prop, PointerRNA *ptr, int index, int value);
 
-int RNA_property_int_get(struct PropertyRNA *prop, struct PointerRNA *ptr);
-void RNA_property_int_set(struct PropertyRNA *prop, struct PointerRNA *ptr, int value);
-int RNA_property_int_get_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index);
-void RNA_property_int_set_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index, int value);
+int RNA_property_int_get(PropertyRNA *prop, PointerRNA *ptr);
+void RNA_property_int_set(PropertyRNA *prop, PointerRNA *ptr, int value);
+int RNA_property_int_get_array(PropertyRNA *prop, PointerRNA *ptr, int index);
+void RNA_property_int_set_array(PropertyRNA *prop, PointerRNA *ptr, int index, int value);
 
-float RNA_property_float_get(struct PropertyRNA *prop, struct PointerRNA *ptr);
-void RNA_property_float_set(struct PropertyRNA *prop, struct PointerRNA *ptr, float value);
-float RNA_property_float_get_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index);
-void RNA_property_float_set_array(struct PropertyRNA *prop, struct PointerRNA *ptr, int index, float value);
+float RNA_property_float_get(PropertyRNA *prop, PointerRNA *ptr);
+void RNA_property_float_set(PropertyRNA *prop, PointerRNA *ptr, float value);
+float RNA_property_float_get_array(PropertyRNA *prop, PointerRNA *ptr, int index);
+void RNA_property_float_set_array(PropertyRNA *prop, PointerRNA *ptr, int index, float value);
 
-void RNA_property_string_get(struct PropertyRNA *prop, struct PointerRNA *ptr, char *value);
-char *RNA_property_string_get_alloc(struct PropertyRNA *prop, struct PointerRNA *ptr, char *fixedbuf, int fixedlen);
-int RNA_property_string_length(struct PropertyRNA *prop, struct PointerRNA *ptr);
-void RNA_property_string_set(struct PropertyRNA *prop, struct PointerRNA *ptr, const char *value);
+void RNA_property_string_get(PropertyRNA *prop, PointerRNA *ptr, char *value);
+char *RNA_property_string_get_alloc(PropertyRNA *prop, PointerRNA *ptr, char *fixedbuf, int fixedlen);
+int RNA_property_string_length(PropertyRNA *prop, PointerRNA *ptr);
+void RNA_property_string_set(PropertyRNA *prop, PointerRNA *ptr, const char *value);
 
-int RNA_property_enum_get(struct PropertyRNA *prop, struct PointerRNA *ptr);
-void RNA_property_enum_set(struct PropertyRNA *prop, struct PointerRNA *ptr, int value);
+int RNA_property_enum_get(PropertyRNA *prop, PointerRNA *ptr);
+void RNA_property_enum_set(PropertyRNA *prop, PointerRNA *ptr, int value);
 
-void RNA_property_pointer_get(struct PropertyRNA *prop, struct PointerRNA *ptr, struct PointerRNA *r_ptr);
-void RNA_property_pointer_set(struct PropertyRNA *prop, struct PointerRNA *ptr, struct PointerRNA *ptr_value);
-struct StructRNA *RNA_property_pointer_type(struct PropertyRNA *prop, struct PointerRNA *ptr);
+void RNA_property_pointer_get(PropertyRNA *prop, PointerRNA *ptr, PointerRNA *r_ptr);
+void RNA_property_pointer_set(PropertyRNA *prop, PointerRNA *ptr, PointerRNA *ptr_value);
+StructRNA *RNA_property_pointer_type(PropertyRNA *prop, PointerRNA *ptr);
 
-void RNA_property_collection_begin(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter, struct PointerRNA *ptr);
-void RNA_property_collection_next(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter);
-void RNA_property_collection_end(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter);
-void RNA_property_collection_get(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter, struct PointerRNA *r_ptr);
-struct StructRNA *RNA_property_collection_type(struct PropertyRNA *prop, struct CollectionPropertyIterator *iter);
-int RNA_property_collection_length(struct PropertyRNA *prop, struct PointerRNA *ptr);
-int RNA_property_collection_lookup_int(struct PropertyRNA *prop, struct PointerRNA *ptr, int key, struct PointerRNA *r_ptr);
-int RNA_property_collection_lookup_string(struct PropertyRNA *prop, struct PointerRNA *ptr, const char *key, struct PointerRNA *r_ptr);
+void RNA_property_collection_begin(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *ptr);
+void RNA_property_collection_next(PropertyRNA *prop, CollectionPropertyIterator *iter);
+void RNA_property_collection_end(PropertyRNA *prop, CollectionPropertyIterator *iter);
+void RNA_property_collection_get(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *r_ptr);
+StructRNA *RNA_property_collection_type(PropertyRNA *prop, CollectionPropertyIterator *iter);
+int RNA_property_collection_length(PropertyRNA *prop, PointerRNA *ptr);
+int RNA_property_collection_lookup_int(PropertyRNA *prop, PointerRNA *ptr, int key, PointerRNA *r_ptr);
+int RNA_property_collection_lookup_string(PropertyRNA *prop, PointerRNA *ptr, const char *key, PointerRNA *r_ptr);
 
 /* Path
  *
@@ -95,12 +123,13 @@ int RNA_property_collection_lookup_string(struct PropertyRNA *prop, struct Point
  * particular pointers, which is useful in a number of applications, like
  * UI code or Actions, though efficiency is a concern. */
 
-char *RNA_path_append(const char *path, struct PropertyRNA *prop, int intkey, const char *strkey);
+char *RNA_path_append(const char *path, PropertyRNA *prop, int intkey, const char *strkey);
 char *RNA_path_back(const char *path);
 
-int RNA_path_resolve(struct PointerRNA *ptr, const char *path,
-       struct PointerRNA *r_ptr, struct PropertyRNA **r_prop);
+int RNA_path_resolve(PointerRNA *ptr, const char *path,
+       PointerRNA *r_ptr, PropertyRNA **r_prop);
 
+#if 0
 /* Dependency
  *
  * Experimental code that will generate callbacks for each dependency
@@ -108,10 +137,11 @@ int RNA_path_resolve(struct PointerRNA *ptr, const char *path,
  * and evaluation code that needs to know such dependencies for correct
  * redraws and re-evaluations. */
 
-typedef void (*PropDependencyCallback)(void *udata, struct PointerRNA *from, struct PointerRNA *to);
-void RNA_test_dependencies_cb(void *udata, struct PointerRNA *from, struct PointerRNA *to);
+typedef void (*PropDependencyCallback)(void *udata, PointerRNA *from, PointerRNA *to);
+void RNA_test_dependencies_cb(void *udata, PointerRNA *from, PointerRNA *to);
 
-void RNA_generate_dependencies(struct PointerRNA *mainptr, void *udata, PropDependencyCallback cb);
+void RNA_generate_dependencies(PointerRNA *mainptr, void *udata, PropDependencyCallback cb);
+#endif
 
 #endif /* RNA_ACCESS */
 
index 6f0c1c1bca39d6b84d84362da35880d971f2addd..4b971c6a6dab85f2b4e42a23b54f94adbef8fcdf 100644 (file)
  * to be figured out still. */
 
 #include "DNA_listBase.h"
-
-struct BlenderRNA;
-struct StructRNA;
-struct PropertyRNA;
-struct PropertyEnumItem;
+#include "RNA_types.h"
 
 /* Blender RNA */
 
-struct BlenderRNA *RNA_create(void);
-void RNA_define_free(struct BlenderRNA *brna);
-void RNA_free(struct BlenderRNA *brna);
+BlenderRNA *RNA_create(void);
+void RNA_define_free(BlenderRNA *brna);
+void RNA_free(BlenderRNA *brna);
 
 /* Struct */
 
-struct StructRNA *RNA_def_struct(struct BlenderRNA *brna, const char *cname, const char *name);
-void RNA_def_struct_sdna(struct StructRNA *srna, const char *structname);
-void RNA_def_struct_name_property(struct StructRNA *srna, struct PropertyRNA *prop);
-void RNA_def_struct_flag(struct StructRNA *srna, int flag);
+StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, 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 */
 
-struct PropertyRNA *RNA_def_property(struct StructRNA *srna, const char *cname, int type, int subtype);
-
-void RNA_def_property_boolean_sdna(struct PropertyRNA *prop, const char *structname, const char *propname, int bit);
-void RNA_def_property_int_sdna(struct PropertyRNA *prop, const char *structname, const char *propname);
-void RNA_def_property_float_sdna(struct PropertyRNA *prop, const char *structname, const char *propname);
-void RNA_def_property_string_sdna(struct PropertyRNA *prop, const char *structname, const char *propname);
-void RNA_def_property_enum_sdna(struct PropertyRNA *prop, const char *structname, const char *propname);
-void RNA_def_property_pointer_sdna(struct PropertyRNA *prop, const char *structname, const char *propname);
-void RNA_def_property_collection_sdna(struct PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname);
-
-void RNA_def_property_flag(struct PropertyRNA *prop, int flag);
-void RNA_def_property_array(struct PropertyRNA *prop, int arraylength);
-void RNA_def_property_range(struct PropertyRNA *prop, double min, double max);
-
-void RNA_def_property_enum_items(struct PropertyRNA *prop, const struct PropertyEnumItem *item);
-void RNA_def_property_string_maxlength(struct PropertyRNA *prop, int maxlength);
-void RNA_def_property_struct_type(struct PropertyRNA *prop, const char *type);
-
-void RNA_def_property_boolean_default(struct PropertyRNA *prop, int value);
-void RNA_def_property_boolean_array_default(struct PropertyRNA *prop, const int *array);
-void RNA_def_property_int_default(struct PropertyRNA *prop, int value);
-void RNA_def_property_int_array_default(struct PropertyRNA *prop, const int *array);
-void RNA_def_property_float_default(struct PropertyRNA *prop, float value);
-void RNA_def_property_float_array_default(struct PropertyRNA *prop, const float *array);
-void RNA_def_property_enum_default(struct PropertyRNA *prop, int value);
-void RNA_def_property_string_default(struct PropertyRNA *prop, const char *value);
-
-void RNA_def_property_ui_text(struct PropertyRNA *prop, const char *name, const char *description);
-void RNA_def_property_ui_range(struct PropertyRNA *prop, double min, double max, double step, double precision);
-
-void RNA_def_property_funcs(struct PropertyRNA *prop, const char *notify, const char *readonly);
-void RNA_def_property_boolean_funcs(struct PropertyRNA *prop, const char *get, const char *set);
-void RNA_def_property_int_funcs(struct PropertyRNA *prop, const char *get, const char *set);
-void RNA_def_property_float_funcs(struct PropertyRNA *prop, const char *get, const char *set);
-void RNA_def_property_enum_funcs(struct PropertyRNA *prop, const char *get, const char *set);
-void RNA_def_property_string_funcs(struct PropertyRNA *prop, const char *get, const char *length, const char *set);
-void RNA_def_property_pointer_funcs(struct PropertyRNA *prop, const char *get, const char *type, const char *set);
-void RNA_def_property_collection_funcs(struct PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *type, const char *length, const char *lookupint, const char *lookupstring);
+PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, 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);
+void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname);
+void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname);
+void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname);
+void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname);
+void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname);
+
+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_string_maxlength(PropertyRNA *prop, int maxlength);
+void RNA_def_property_struct_type(PropertyRNA *prop, const char *type);
+
+void RNA_def_property_boolean_default(PropertyRNA *prop, int value);
+void RNA_def_property_boolean_array_default(PropertyRNA *prop, const int *array);
+void RNA_def_property_int_default(PropertyRNA *prop, int value);
+void RNA_def_property_int_array_default(PropertyRNA *prop, const int *array);
+void RNA_def_property_float_default(PropertyRNA *prop, float value);
+void RNA_def_property_float_array_default(PropertyRNA *prop, const float *array);
+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_funcs(PropertyRNA *prop, const char *notify, const char *readonly);
+void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set);
+void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set);
+void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set);
+void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set);
+void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set);
+void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *type, const char *set);
+void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *type, const char *length, const char *lookupint, const char *lookupstring);
 
 #endif /* RNA_DEFINE_H */
 
index 86fd535f25dd3a5af24859442c28c3acb764b450..846e516a41f2622b38044bedb3f190518241f551 100644 (file)
@@ -111,15 +111,16 @@ typedef enum PropertyFlag {
         * as part of an evaluation. these can change at runtime
         * the property flag contains the default. editable is
         * enabled by default except for collections. */
-       PROP_EDITABLE = 1,
+       PROP_NOT_EDITABLE = 1,
        PROP_EVALUATED = 2,
 
        /* driveable means the property can be driven by some
         * other input, be it animation curves, expressions, ..
-        * in other words making the property evaluated. this is
+        * in other words making the property evaluated.
         * enable by default except for pointers and collections. */
-       PROP_DRIVEABLE = 4,
+       PROP_NOT_DRIVEABLE = 4,
 
+#if 0
        /* for pointers and collections, means that the struct
         * depends on the data pointed to for evaluation, such
         * that a change in the data pointed to will affect the
@@ -132,6 +133,10 @@ typedef enum PropertyFlag {
         * be it the render engine or viewport */
        PROP_RENDER_DEPENDENCY = 32,
        PROP_INVERSE_RENDER_DEPENDENCY = 64,
+#endif
+
+       /* internal flag */
+       PROP_BUILTIN = 128
 } PropertyFlag;
 
 typedef struct CollectionPropertyIterator {
@@ -289,6 +294,9 @@ typedef struct StructRNA {
        /* property that defines the name */
        PropertyRNA *nameproperty;
 
+       /* property to iterate over properties */
+       PropertyRNA *iteratorproperty;
+
        /* properties of this struct */
        ListBase properties; 
 } StructRNA;
index a98bdddade311beb30549a5b58e56b3e58201660..11fb81159d6cc700afbb3ed278c36c1b6858aa7b 100644 (file)
@@ -190,8 +190,10 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
        char *func;
 
        if(!dp->dnastructname || !dp->dnaname) {
-               fprintf(stderr, "rna_def_property_set_func: %s.%s has no valid dna info.\n", srna->cname, prop->cname);
-               DefRNA.error= 1;
+               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);
+                       DefRNA.error= 1;
+               }
                return NULL;
        }
 
@@ -712,8 +714,10 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
        fprintf(f, ",\n");
 
        prop= srna->nameproperty;
-       if(prop) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s,\n", srna->cname, prop->cname);
-       else fprintf(f, "\tNULL,\n");
+       if(prop) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s, ", srna->cname, prop->cname);
+       else fprintf(f, "\tNULL, ");
+
+       fprintf(f, "\t(PropertyRNA*)&rna_%s_rna_properties,\n", srna->cname);
 
        prop= srna->properties.first;
        if(prop) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->cname, prop->cname);
@@ -738,6 +742,7 @@ RNAProcessItem PROCESS_ITEMS[]= {
        {"rna_main.c", RNA_def_main},
        {"rna_mesh.c", RNA_def_mesh},
        {"rna_object.c", RNA_def_object},
+       {"rna_rna.c", RNA_def_rna},
        {"rna_scene.c", RNA_def_scene},
        {NULL, NULL}};
 
@@ -761,13 +766,9 @@ static int rna_preprocess(char *basedirectory, FILE *f)
 
        fprintf(f, "#include \"BKE_utildefines.h\"\n\n");
 
-       fprintf(f, "#include \"RNA_define.h\"\n\n");
-       fprintf(f, "#include \"RNA_types.h\"\n\n");
-
+       fprintf(f, "#include \"RNA_define.h\"\n");
+       fprintf(f, "#include \"RNA_types.h\"\n");
        fprintf(f, "#include \"rna_internal.h\"\n\n");
-       for(i=0; PROCESS_ITEMS[i].filename; i++)
-               fprintf(f, "#include \"%s\"\n", PROCESS_ITEMS[i].filename);
-       fprintf(f, "\n");
 
        for(i=0; PROCESS_ITEMS[i].filename; i++)
                if(PROCESS_ITEMS[i].define)
@@ -775,6 +776,11 @@ static int rna_preprocess(char *basedirectory, FILE *f)
        rna_auto_types();
        
        rna_generate_prototypes(brna, f);
+
+       for(i=0; PROCESS_ITEMS[i].filename; i++)
+               fprintf(f, "#include \"%s\"\n", PROCESS_ITEMS[i].filename);
+       fprintf(f, "\n");
+
        rna_auto_functions(f);
 
        for(srna=brna->structs.first; srna; srna=srna->next)
index 553875c81582a214a613120b824570ab94318f0f..9304618f596586e8a1f81d40b70a65358b3a418c 100644 (file)
@@ -57,11 +57,115 @@ static void rna_pointer_inherit_id(PointerRNA *parent, PointerRNA *ptr)
        }
 }
 
-/* Property */
+/* Structs */
+
+const char *RNA_struct_cname(PointerRNA *ptr)
+{
+       return ptr->type->cname;
+}
+
+const char *RNA_struct_ui_name(PointerRNA *ptr)
+{
+       return ptr->type->name;
+}
+
+PropertyRNA *RNA_struct_name_property(PointerRNA *ptr)
+{
+       return ptr->type->nameproperty;
+}
+
+PropertyRNA *RNA_struct_iterator_property(PointerRNA *ptr)
+{
+       return ptr->type->iteratorproperty;
+}
+
+/* Property Information */
+
+const char *RNA_property_cname(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->cname;
+}
+
+PropertyType RNA_property_type(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->type;
+}
+
+PropertySubType RNA_property_subtype(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->subtype;
+}
+
+int RNA_property_array_length(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->arraylength;
+}
+
+void RNA_property_int_range(PropertyRNA *prop, PointerRNA *ptr, int *hardmin, int *hardmax)
+{
+       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+
+       *hardmin= iprop->hardmin;
+       *hardmax= iprop->hardmax;
+}
+
+void RNA_property_int_ui_range(PropertyRNA *prop, PointerRNA *ptr, int *softmin, int *softmax, int *step)
+{
+       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+
+       *softmin= iprop->softmin;
+       *softmax= iprop->softmax;
+       *step= iprop->step;
+}
+
+void RNA_property_float_range(PropertyRNA *prop, PointerRNA *ptr, float *hardmin, float *hardmax)
+{
+       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+
+       *hardmin= fprop->hardmin;
+       *hardmax= fprop->hardmax;
+}
+
+void RNA_property_float_ui_range(PropertyRNA *prop, PointerRNA *ptr, float *softmin, float *softmax, float *step, float *precision)
+{
+       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+
+       *softmin= fprop->softmin;
+       *softmax= fprop->softmax;
+       *step= fprop->step;
+       *precision= fprop->precision;
+}
+
+int RNA_property_string_maxlength(PropertyRNA *prop, PointerRNA *ptr)
+{
+       StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+       
+       return sprop->maxlength;
+}
+
+void RNA_property_enum_items(PropertyRNA *prop, PointerRNA *ptr, const PropertyEnumItem **item, int *totitem)
+{
+       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
+
+       *item= eprop->item;
+       *totitem= eprop->totitem;
+}
+
+const char *RNA_property_ui_name(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->name;
+}
+
+const char *RNA_property_ui_description(PropertyRNA *prop, PointerRNA *ptr)
+{
+       return prop->description;
+}
+
+/* Property Data */
 
 int RNA_property_editable(PropertyRNA *prop, PointerRNA *ptr)
 {
-       return (prop->flag & PROP_EDITABLE);
+       return !(prop->flag & PROP_NOT_EDITABLE);
 }
 
 int RNA_property_evaluated(PropertyRNA *prop, PointerRNA *ptr)
@@ -86,7 +190,8 @@ void RNA_property_boolean_set(PropertyRNA *prop, PointerRNA *ptr, int value)
 {
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 
-       bprop->set(ptr, value);
+       if(bprop->set)
+               bprop->set(ptr, value);
 }
 
 int RNA_property_boolean_get_array(PropertyRNA *prop, PointerRNA *ptr, int index)
@@ -100,7 +205,8 @@ void RNA_property_boolean_set_array(PropertyRNA *prop, PointerRNA *ptr, int inde
 {
        BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
 
-       bprop->setarray(ptr, index, value);
+       if(bprop->setarray)
+               bprop->setarray(ptr, index, value);
 }
 
 int RNA_property_int_get(PropertyRNA *prop, PointerRNA *ptr)
@@ -114,7 +220,8 @@ void RNA_property_int_set(PropertyRNA *prop, PointerRNA *ptr, int value)
 {
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 
-       iprop->set(ptr, value);
+       if(iprop->set)
+               iprop->set(ptr, value);
 }
 
 int RNA_property_int_get_array(PropertyRNA *prop, PointerRNA *ptr, int index)
@@ -128,7 +235,8 @@ void RNA_property_int_set_array(PropertyRNA *prop, PointerRNA *ptr, int index, i
 {
        IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
 
-       iprop->setarray(ptr, index, value);
+       if(iprop->setarray)
+               iprop->setarray(ptr, index, value);
 }
 
 float RNA_property_float_get(PropertyRNA *prop, PointerRNA *ptr)
@@ -142,7 +250,8 @@ void RNA_property_float_set(PropertyRNA *prop, PointerRNA *ptr, float value)
 {
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 
-       fprop->set(ptr, value);
+       if(fprop->set)
+               fprop->set(ptr, value);
 }
 
 float RNA_property_float_get_array(PropertyRNA *prop, PointerRNA *ptr, int index)
@@ -156,7 +265,8 @@ void RNA_property_float_set_array(PropertyRNA *prop, PointerRNA *ptr, int index,
 {
        FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
 
-       fprop->setarray(ptr, index, value);
+       if(fprop->setarray)
+               fprop->setarray(ptr, index, value);
 }
 
 void RNA_property_string_get(PropertyRNA *prop, PointerRNA *ptr, char *value)
@@ -194,7 +304,8 @@ void RNA_property_string_set(PropertyRNA *prop, PointerRNA *ptr, const char *val
 {
        StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
 
-       sprop->set(ptr, value);
+       if(sprop->set)
+               sprop->set(ptr, value);
 }
 
 int RNA_property_enum_get(PropertyRNA *prop, PointerRNA *ptr)
@@ -208,7 +319,8 @@ void RNA_property_enum_set(PropertyRNA *prop, PointerRNA *ptr, int value)
 {
        EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 
-       eprop->set(ptr, value);
+       if(eprop->set)
+               eprop->set(ptr, value);
 }
 
 void RNA_property_pointer_get(PropertyRNA *prop, PointerRNA *ptr, PointerRNA *r_ptr)
@@ -229,7 +341,8 @@ void RNA_property_pointer_set(PropertyRNA *prop, PointerRNA *ptr, PointerRNA *pt
 {
        PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
 
-       pprop->set(ptr, ptr_value->data);
+       if(pprop->set)
+               pprop->set(ptr, ptr_value->data);
 }
 
 StructRNA *RNA_property_pointer_type(PropertyRNA *prop, PointerRNA *ptr)
@@ -536,7 +649,8 @@ static char *rna_path_token(const char **path, char *fixedbuf, int fixedlen, int
 
 int RNA_path_resolve(PointerRNA *ptr, const char *path, PointerRNA *r_ptr, PropertyRNA **r_prop)
 {
-       PropertyRNA *prop;
+       CollectionPropertyIterator iter;
+       PropertyRNA *prop, *iterprop;
        PointerRNA curptr, nextptr;
        char fixedbuf[256], *token;
        int len, intkey;
@@ -551,9 +665,24 @@ int RNA_path_resolve(PointerRNA *ptr, const char *path, PointerRNA *r_ptr, Prope
                if(!token)
                        return 0;
 
-               for(prop=curptr.type->properties.first; prop; prop=prop->next)
-                       if(strcmp(token, prop->cname) == 0)
+               iterprop= RNA_struct_iterator_property(&curptr);
+               RNA_property_collection_begin(iterprop, &iter, &curptr);
+               prop= NULL;
+
+               for(; iter.valid; RNA_property_collection_next(iterprop, &iter)) {
+                       PointerRNA cptr;
+                       PropertyRNA *cprop;
+
+                       RNA_property_collection_get(iterprop, &iter, &cptr);
+                       cprop= cptr.data;
+
+                       if(strcmp(token, cprop->cname) == 0) {
+                               prop= cprop;
                                break;
+                       }
+               }
+
+               RNA_property_collection_end(iterprop, &iter);
 
                if(token != fixedbuf)
                        MEM_freeN(token);
index aea7cf75f798ca51b17a77d899150d3297c69d91..003773381c9cdee89329345047e3756fe287f945 100644 (file)
@@ -211,6 +211,8 @@ StructRNA *RNA_def_struct(BlenderRNA *brna, const char *cname, const char *name)
 
        RNA_def_struct_sdna(srna, srna->cname);
 
+       rna_def_builtin_properties(srna);
+
        return srna;
 }
 
@@ -318,11 +320,9 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int
        prop->description= "";
 
        if(type == PROP_COLLECTION)
-               prop->flag= 0;
+               prop->flag= PROP_NOT_EDITABLE|PROP_NOT_DRIVEABLE;
        else if(type == PROP_POINTER)
-               prop->flag= PROP_EDITABLE;
-       else
-               prop->flag= PROP_EDITABLE|PROP_DRIVEABLE;
+               prop->flag= PROP_NOT_DRIVEABLE;
 
        switch(type) {
                case PROP_BOOLEAN:
@@ -374,14 +374,16 @@ void RNA_def_property_flag(PropertyRNA *prop, int flag)
 {
        StructDefRNA *ds= DefRNA.structs.last;
 
-       prop->flag= flag;
+       prop->flag |= 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);
                        DefRNA.error= 1;
                }
        }
+#endif
 }
 
 void RNA_def_property_array(PropertyRNA *prop, int arraylength)
@@ -831,83 +833,160 @@ void RNA_def_property_notify_func(PropertyRNA *prop, const char *notify)
 
 void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
-               if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
-       }
-       else {
-               if(get) bprop->get= (PropBooleanGetFunc)get;
-               if(set) bprop->set= (PropBooleanSetFunc)set;
+       switch(prop->type) {
+               case PROP_BOOLEAN: {
+                       BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) bprop->getarray= (PropBooleanArrayGetFunc)get;
+                               if(set) bprop->setarray= (PropBooleanArraySetFunc)set;
+                       }
+                       else {
+                               if(get) bprop->get= (PropBooleanGetFunc)get;
+                               if(set) bprop->set= (PropBooleanSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_boolean_funcs: %s.%s, type is not boolean.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
 void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) iprop->getarray= (PropIntArrayGetFunc)get;
-               if(set) iprop->setarray= (PropIntArraySetFunc)set;
-       }
-       else {
-               if(get) iprop->get= (PropIntGetFunc)get;
-               if(set) iprop->set= (PropIntSetFunc)set;
+       switch(prop->type) {
+               case PROP_INT: {
+                       IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) iprop->getarray= (PropIntArrayGetFunc)get;
+                               if(set) iprop->setarray= (PropIntArraySetFunc)set;
+                       }
+                       else {
+                               if(get) iprop->get= (PropIntGetFunc)get;
+                               if(set) iprop->set= (PropIntSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_int_funcs: %s.%s, type is not int.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
 void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(prop->arraylength) {
-               if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
-               if(set) fprop->setarray= (PropFloatArraySetFunc)set;
-       }
-       else {
-               if(get) fprop->get= (PropFloatGetFunc)get;
-               if(set) fprop->set= (PropFloatSetFunc)set;
+       switch(prop->type) {
+               case PROP_FLOAT: {
+                       FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
+
+                       if(prop->arraylength) {
+                               if(get) fprop->getarray= (PropFloatArrayGetFunc)get;
+                               if(set) fprop->setarray= (PropFloatArraySetFunc)set;
+                       }
+                       else {
+                               if(get) fprop->get= (PropFloatGetFunc)get;
+                               if(set) fprop->set= (PropFloatSetFunc)set;
+                       }
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_float_funcs: %s.%s, type is not float.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
        }
 }
 
 void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set)
 {
-       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
+
+       switch(prop->type) {
+               case PROP_ENUM: {
+                       EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
 
-       if(get) eprop->get= (PropEnumGetFunc)get;
-       if(set) eprop->set= (PropEnumSetFunc)set;
+                       if(get) eprop->get= (PropEnumGetFunc)get;
+                       if(set) eprop->set= (PropEnumSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_enum_funcs: %s.%s, type is not enum.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
 void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
 {
-       StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(get) sprop->get= (PropStringGetFunc)get;
-       if(length) sprop->length= (PropStringLengthFunc)length;
-       if(set) sprop->set= (PropStringSetFunc)set;
+       switch(prop->type) {
+               case PROP_STRING: {
+                       StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
+
+                       if(get) sprop->get= (PropStringGetFunc)get;
+                       if(length) sprop->length= (PropStringLengthFunc)length;
+                       if(set) sprop->set= (PropStringSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_string_funcs: %s.%s, type is not string.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
 void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *type, const char *set)
 {
-       PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
 
-       if(get) pprop->get= (PropPointerGetFunc)get;
-       if(type) pprop->type= (PropPointerTypeFunc)type;
-       if(set) pprop->set= (PropPointerSetFunc)set;
+       switch(prop->type) {
+               case PROP_POINTER: {
+                       PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
+
+                       if(get) pprop->get= (PropPointerGetFunc)get;
+                       if(type) pprop->type= (PropPointerTypeFunc)type;
+                       if(set) pprop->set= (PropPointerSetFunc)set;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_pointer_funcs: %s.%s, type is not pointer.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
 void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *type, const char *length, const char *lookupint, const char *lookupstring)
 {
-       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
+       StructDefRNA *ds= DefRNA.structs.last;
+
+       switch(prop->type) {
+               case PROP_COLLECTION: {
+                       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
 
-       if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
-       if(next) cprop->next= (PropCollectionNextFunc)next;
-       if(end) cprop->end= (PropCollectionEndFunc)end;
-       if(get) cprop->get= (PropCollectionGetFunc)get;
-       if(type) cprop->type= (PropCollectionTypeFunc)type;
-       if(length) cprop->length= (PropCollectionLengthFunc)length;
-       if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
-       if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
+                       if(begin) cprop->begin= (PropCollectionBeginFunc)begin;
+                       if(next) cprop->next= (PropCollectionNextFunc)next;
+                       if(end) cprop->end= (PropCollectionEndFunc)end;
+                       if(get) cprop->get= (PropCollectionGetFunc)get;
+                       if(type) cprop->type= (PropCollectionTypeFunc)type;
+                       if(length) cprop->length= (PropCollectionLengthFunc)length;
+                       if(lookupint) cprop->lookupint= (PropCollectionLookupIntFunc)lookupint;
+                       if(lookupstring) cprop->lookupstring= (PropCollectionLookupStringFunc)lookupstring;
+                       break;
+               }
+               default:
+                       fprintf(stderr, "RNA_def_property_collection_funcs: %s.%s, type is not collection.\n", ds->srna->cname, prop->cname);
+                       DefRNA.error= 1;
+                       break;
+       }
 }
 
index 09d68e001d20b7639e0e0e3be775703657c3b2ca..a8f99a9dcb68dde937e6bf8d96439f1ed96943d5 100644 (file)
@@ -8,6 +8,7 @@
 #include "RNA_access.h"
 #include "RNA_types.h"
 
+#if 0
 typedef struct RNAGenDeps {
        void *udata;
        PropDependencyCallback cb;
@@ -87,4 +88,5 @@ void RNA_test_dependencies_cb(void *udata, PointerRNA *from, PointerRNA *to)
        
        printf("%s (%s) -> %s (%s)\n", name, from->type->cname, nameto, to->type->cname);
 }
+#endif
 
index 253112277cb44c0749b664c5c50cd1ec1b794f25..d09b593e884413d6e1848b8cb39d1311e6f2b76c 100644 (file)
@@ -77,14 +77,18 @@ extern StructRNA RNA_Main;
 extern StructRNA RNA_Mesh;
 extern StructRNA RNA_Object;
 extern StructRNA RNA_Scene;
+extern StructRNA RNA_StructRNA;
 
 void RNA_def_ID(struct StructRNA *srna);
 
 void RNA_def_main(struct BlenderRNA *brna);
 void RNA_def_mesh(struct BlenderRNA *brna);
 void RNA_def_object(struct BlenderRNA *brna);
+void RNA_def_rna(struct BlenderRNA *brna);
 void RNA_def_scene(struct BlenderRNA *brna);
 
+void rna_def_builtin_properties(struct StructRNA *srna);
+
 /* Standard iterator functions */
 
 void rna_iterator_listbase_begin(struct CollectionPropertyIterator *iter, struct ListBase *lb);
index 2719410b33a11c86b510cde58bfa36b2906d61bf..d79bd2a3f48b742e465930881ce4d9b5d545bbdd 100644 (file)
@@ -78,16 +78,13 @@ void RNA_def_object(BlenderRNA *brna)
        RNA_def_ID(srna);
 
        prop= RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_EDITABLE|PROP_RENDER_DEPENDENCY);
        RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_data_type", NULL);
 
        prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "Object");
-       RNA_def_property_flag(prop, PROP_EVALUATE_DEPENDENCY);
 
        prop= RNA_def_property(srna, "track", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "Object");
-       RNA_def_property_flag(prop, PROP_EVALUATE_DEPENDENCY);
 }
 
 #endif
diff --git a/source/blender/makesrna/intern/rna_rna.c b/source/blender/makesrna/intern/rna_rna.c
new file mode 100644 (file)
index 0000000..dc3d248
--- /dev/null
@@ -0,0 +1,310 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Blender Foundation (2008).
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+
+#include "RNA_access.h"
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#ifdef RNA_RUNTIME
+
+/* Struct */
+
+static void rna_StructRNA_cname_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((StructRNA*)ptr->data)->cname);
+}
+
+static int rna_StructRNA_cname_length(PointerRNA *ptr)
+{
+       return strlen(((StructRNA*)ptr->data)->cname);
+}
+
+static void rna_StructRNA_name_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((StructRNA*)ptr->data)->name);
+}
+
+static int rna_StructRNA_name_length(PointerRNA *ptr)
+{
+       return strlen(((StructRNA*)ptr->data)->name);
+}
+
+static void *rna_StructRNA_name_property_get(PointerRNA *ptr)
+{
+       return ((StructRNA*)ptr->data)->nameproperty;
+}
+
+static void *rna_StructRNA_iterator_property_get(PointerRNA *ptr)
+{
+       return ((StructRNA*)ptr->data)->iteratorproperty;
+}
+
+static void rna_StructRNA_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       rna_iterator_listbase_begin(iter, &((StructRNA*)ptr->data)->properties);
+}
+
+static void rna_StructRNA_properties_next(CollectionPropertyIterator *iter)
+{
+       rna_iterator_listbase_next(iter);
+}
+
+static void *rna_StructRNA_properties_get(CollectionPropertyIterator *iter)
+{
+       return rna_iterator_listbase_get(iter);
+}
+
+static StructRNA *rna_StructRNA_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;
+               default: return NULL;
+       }
+}
+
+static void rna_builtin_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
+{
+       PointerRNA newptr;
+
+       /* we create a new with the type as the data */
+       newptr.type= &RNA_StructRNA;
+       newptr.data= ptr->type;
+
+       if(ptr->type->flag & STRUCT_ID) {
+               newptr.id.type= ptr->type;
+               newptr.id.data= ptr->data;
+       }
+       else {
+               newptr.id.type= NULL;
+               newptr.id.data= NULL;
+       }
+
+       rna_StructRNA_properties_begin(iter, &newptr);
+}
+
+static void rna_builtin_properties_next(CollectionPropertyIterator *iter)
+{
+       rna_StructRNA_properties_next(iter);
+}
+
+static void *rna_builtin_properties_get(CollectionPropertyIterator *iter)
+{
+       return rna_StructRNA_properties_get(iter);
+}
+
+static StructRNA *rna_builtin_properties_type(CollectionPropertyIterator *iter)
+{
+       return rna_StructRNA_properties_type(iter);
+}
+
+static void *rna_builtin_type_get(PointerRNA *ptr)
+{
+       return ptr->type;
+}
+
+/* Property */
+
+static void rna_PropertyRNA_cname_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((PropertyRNA*)ptr->data)->cname);
+}
+
+static int rna_PropertyRNA_cname_length(PointerRNA *ptr)
+{
+       return strlen(((PropertyRNA*)ptr->data)->cname);
+}
+
+static void rna_PropertyRNA_name_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((PropertyRNA*)ptr->data)->name);
+}
+
+static int rna_PropertyRNA_name_length(PointerRNA *ptr)
+{
+       return strlen(((PropertyRNA*)ptr->data)->name);
+}
+
+static void rna_PropertyRNA_description_get(PointerRNA *ptr, char *value)
+{
+       strcpy(value, ((PropertyRNA*)ptr->data)->description);
+}
+
+static int rna_PropertyRNA_description_length(PointerRNA *ptr)
+{
+       return strlen(((PropertyRNA*)ptr->data)->description);
+}
+
+static int rna_PropertyRNA_type_get(PointerRNA *ptr)
+{
+       return ((PropertyRNA*)ptr->data)->type;
+}
+
+static int rna_PropertyRNA_subtype_get(PointerRNA *ptr)
+{
+       return ((PropertyRNA*)ptr->data)->subtype;
+}
+
+static int rna_PropertyRNA_array_length_get(PointerRNA *ptr)
+{
+       return ((PropertyRNA*)ptr->data)->arraylength;
+}
+
+#else
+
+static void rna_def_property(StructRNA *srna)
+{
+       PropertyRNA *prop;
+       static PropertyEnumItem type_items[] = {
+               {PROP_BOOLEAN, "BOOLEAN", "Boolean"},
+               {PROP_INT, "INT", "Integer"},
+               {PROP_FLOAT, "FLOAT", "Float"},
+               {PROP_STRING, "STRING", "String"},
+               {PROP_ENUM, "ENUM", "Enumeration"},
+               {PROP_POINTER, "POINTER", "Pointer"},
+               {PROP_COLLECTION, "COLLECTION", "Collection"},
+               {0, NULL, NULL}};
+       static PropertyEnumItem subtype_items[] = {
+               {PROP_NONE, "NONE", "None"},
+               {PROP_UNSIGNED, "UNSIGNED", "Unsigned Number"},
+               {PROP_FILEPATH, "FILEPATH", "File Path"},
+               {PROP_COLOR, "COLOR", "Color"},
+               {PROP_VECTOR, "VECTOR", "Vector"},
+               {PROP_MATRIX, "MATRIX", "Matrix"},
+               {PROP_ROTATION, "ROTATION", "Rotation"},
+               {0, NULL, NULL}};
+
+       prop= RNA_def_property(srna, "cname", 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);
+
+       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_struct_name_property(srna, prop);
+
+       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);
+
+       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);
+
+       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);
+
+       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);
+}
+
+void RNA_def_rna(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       /* StructRNA */
+       srna= RNA_def_struct(brna, "StructRNA", "Struct RNA");
+
+       prop= RNA_def_property(srna, "cname", 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);
+
+       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_struct_name_property(srna, prop);
+
+       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);
+
+       prop= RNA_def_property(srna, "iterator_property", PROP_POINTER, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE);
+       RNA_def_property_struct_type(prop, "CollectionPropertyRNA");
+       RNA_def_property_pointer_funcs(prop, "rna_StructRNA_iterator_property_get", NULL, NULL);
+
+       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);
+
+       /* BooleanPropertyRNA */
+       srna= RNA_def_struct(brna, "BooleanPropertyRNA", "Boolean Property");
+       rna_def_property(srna);
+
+       /* IntPropertyRNA */
+       srna= RNA_def_struct(brna, "IntPropertyRNA", "Int Property");
+       rna_def_property(srna);
+
+       /* FloatPropertyRNA */
+       srna= RNA_def_struct(brna, "FloatPropertyRNA", "Float Property");
+       rna_def_property(srna);
+
+       /* StringPropertyRNA */
+       srna= RNA_def_struct(brna, "StringPropertyRNA", "String Property");
+       rna_def_property(srna);
+
+       /* EnumPropertyRNA */
+       srna= RNA_def_struct(brna, "EnumPropertyRNA", "Enum Property");
+       rna_def_property(srna);
+
+       /* PointerPropertyRNA */
+       srna= RNA_def_struct(brna, "PointerPropertyRNA", "Pointer Property");
+       rna_def_property(srna);
+
+       /* CollectionPropertyRNA */
+       srna= RNA_def_struct(brna, "CollectionPropertyRNA", "Collection Property");
+       rna_def_property(srna);
+}
+
+void rna_def_builtin_properties(StructRNA *srna)
+{
+       PropertyRNA *prop;
+
+       prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE|PROP_BUILTIN);
+       RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", 0, "rna_builtin_properties_get", "rna_builtin_properties_type", 0, 0, 0);
+
+       prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NOT_EDITABLE|PROP_BUILTIN);
+       RNA_def_property_struct_type(prop, "StructRNA");
+       RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL);
+}
+
+#endif
+
index a2fa48d86dd1fd65d15cf6fe6938ad95f956c9ab..181b7a5b7a93963247336f6d8703d4ff294fe86c 100644 (file)
@@ -68,7 +68,6 @@ void RNA_def_scene(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
        RNA_def_property_ui_text(prop, "Active Camera", "Active camera used for rendering the scene.");
-       RNA_def_property_flag(prop, PROP_EDITABLE|PROP_DRIVEABLE|PROP_RENDER_DEPENDENCY);
 
        prop= RNA_def_property(srna, "cursor", PROP_FLOAT, PROP_VECTOR);
        RNA_def_property_ui_text(prop, "Cursor Location", "3D cursor location.");
@@ -79,7 +78,6 @@ void RNA_def_scene(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "Object");
        RNA_def_property_ui_text(prop, "Objects", "Objects in the scene.");
        RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_Scene_objects_get", 0, 0, 0, 0);
-       RNA_def_property_flag(prop, PROP_RENDER_DEPENDENCY);
 
        prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "lay", 1);
@@ -92,7 +90,7 @@ void RNA_def_scene(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Proportional Mode", "Proportional edit mode.");
 
        prop= RNA_def_property(srna, "current_frame", PROP_INT, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_EDITABLE);
+       RNA_def_property_flag(prop, PROP_NOT_DRIVEABLE);
        RNA_def_property_int_sdna(prop, NULL, "r.cfra");
        RNA_def_property_range(prop, MINFRAME, MAXFRAME);
        RNA_def_property_ui_text(prop, "Current Frame", "Current frame.");