RNA
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Tue, 16 Jun 2009 00:52:21 +0000 (00:52 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Tue, 16 Jun 2009 00:52:21 +0000 (00:52 +0000)
* Added icon to property and enum property items. The latter is
  responsible for the large number of files changed.
* For RNA functions, added PROP_RNAPTR flag to ask for a PointerRNA
  as argument instead of a C pointer, instead of doing it implicitly
  with the AnyType type.

* Material: properly wrap diffuse/specular param variables, and
  rename some things for consistency.
* MaterialTextureSlot: added "enabled" property (ma->septex).
* Image: make animated property editable.
* Image Editor: make some things editable, notifiers, respect state.
* Context: fix issue with screen not being set as ID.

81 files changed:
source/blender/blenkernel/intern/ipo.c
source/blender/editors/animation/anim_channels.c
source/blender/editors/animation/keyingsets.c
source/blender/editors/armature/editarmature.c
source/blender/editors/armature/poseobject.c
source/blender/editors/curve/editcurve.c
source/blender/editors/curve/editfont.c
source/blender/editors/interface/interface_api.c
source/blender/editors/mesh/editmesh.c
source/blender/editors/mesh/editmesh_loop.c
source/blender/editors/mesh/editmesh_mods.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/object/object_edit.c
source/blender/editors/physics/editparticle.c
source/blender/editors/screen/screen_ops.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_action/action_edit.c
source/blender/editors/space_action/action_select.c
source/blender/editors/space_graph/graph_edit.c
source/blender/editors/space_graph/graph_select.c
source/blender/editors/space_image/image_ops.c
source/blender/editors/space_node/node_select.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_text/text_ops.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/transform/transform_ops.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/editors/uvedit/uvedit_unwrap_ops.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/RNA_define.h
source/blender/makesrna/RNA_types.h
source/blender/makesrna/SConscript
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/Makefile
source/blender/makesrna/intern/SConscript
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_actuator.c
source/blender/makesrna/intern/rna_animation.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_camera.c
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_constraint.c
source/blender/makesrna/intern/rna_context.c
source/blender/makesrna/intern/rna_controller.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_fcurve.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_internal_types.h
source/blender/makesrna/intern/rna_key.c
source/blender/makesrna/intern/rna_lamp.c
source/blender/makesrna/intern/rna_lattice.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_meta.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_force.c
source/blender/makesrna/intern/rna_particle.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_property.c
source/blender/makesrna/intern/rna_radio.c
source/blender/makesrna/intern/rna_rna.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_screen.c
source/blender/makesrna/intern/rna_sensor.c
source/blender/makesrna/intern/rna_sequence.c
source/blender/makesrna/intern/rna_sound.c
source/blender/makesrna/intern/rna_space.c
source/blender/makesrna/intern/rna_texture.c
source/blender/makesrna/intern/rna_ui.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/makesrna/intern/rna_vpaint.c
source/blender/makesrna/intern/rna_world.c
source/blender/python/intern/bpy_rna.c
source/blender/windowmanager/intern/wm_operators.c

index 8cbf25e..e4c366d 100644 (file)
@@ -545,7 +545,7 @@ static char *material_adrcodes_to_paths (int adrcode, int *array_index)
                        return "ambient";
                
                case MA_SPEC:
-                       return "specularity";
+                       return "specular_reflection";
                
                case MA_HARD:
                        return "specular_hardness";
index 9e0e50a..c52ade1 100644 (file)
@@ -721,17 +721,17 @@ enum {
 
 /* defines for setting animation-channel flags */
 EnumPropertyItem prop_animchannel_setflag_types[] = {
-       {ACHANNEL_SETFLAG_CLEAR, "DISABLE", "Disable", ""},
-       {ACHANNEL_SETFLAG_ADD, "ENABLE", "Enable", ""},
-       {ACHANNEL_SETFLAG_TOGGLE, "TOGGLE", "Toggle", ""},
-       {0, NULL, NULL, NULL}
+       {ACHANNEL_SETFLAG_CLEAR, "DISABLE", 0, "Disable", ""},
+       {ACHANNEL_SETFLAG_ADD, "ENABLE", 0, "Enable", ""},
+       {ACHANNEL_SETFLAG_TOGGLE, "TOGGLE", 0, "Toggle", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* defines for set animation-channel settings */
 EnumPropertyItem prop_animchannel_settings_types[] = {
-       {ACHANNEL_SETTING_PROTECT, "PROTECT", "Protect", ""},
-       {ACHANNEL_SETTING_MUTE, "MUTE", "Mute", ""},
-       {0, NULL, NULL, NULL}
+       {ACHANNEL_SETTING_PROTECT, "PROTECT", 0, "Protect", ""},
+       {ACHANNEL_SETTING_MUTE, "MUTE", 0, "Mute", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 
index 0f5cef5..1813c76 100644 (file)
@@ -106,10 +106,10 @@ void ANIM_OT_keyingset_add_destination (wmOperatorType *ot)
 {
        // XXX: this is also defined in rna_animation.c
        static EnumPropertyItem prop_mode_grouping_items[] = {
-               {KSP_GROUP_NAMED, "NAMED", "Named Group", ""},
-               {KSP_GROUP_NONE, "NONE", "None", ""},
-               {KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""},
-               {0, NULL, NULL, NULL}};
+               {KSP_GROUP_NAMED, "NAMED", 0, "Named Group", ""},
+               {KSP_GROUP_NONE, "NONE", 0, "None", ""},
+               {KSP_GROUP_KSNAME, "KEYINGSET", 0, "Keying Set Name", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        /* identifiers */
        ot->name= "Add Keying Set Destination";
index 9c9be51..7155bdd 100644 (file)
@@ -1957,9 +1957,9 @@ void auto_align_ebone_tocursor(Scene *scene, View3D *v3d, EditBone *ebone)
 
 
 static EnumPropertyItem prop_calc_roll_types[] = {
-       {0, "GLOBALUP", "Z-Axis Up", ""},
-       {1, "CURSOR", "Z-Axis to Cursor", ""},
-       {0, NULL, NULL, NULL}
+       {0, "GLOBALUP", 0, "Z-Axis Up", ""},
+       {1, "CURSOR", 0, "Z-Axis to Cursor", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int armature_calc_roll_exec(bContext *C, wmOperator *op) 
@@ -3489,9 +3489,9 @@ static int armature_subdivs_exec(bContext *C, wmOperator *op)
 void ARMATURE_OT_subdivs(wmOperatorType *ot)
 {
        static EnumPropertyItem type_items[]= {
-               {0, "SIMPLE", "Simple", ""},
-               {1, "MULTI", "Multi", ""},
-               {0, NULL, NULL}};
+               {0, "SIMPLE", 0, "Simple", ""},
+               {1, "MULTI", 0, "Multi", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "subdivs";
@@ -3669,9 +3669,9 @@ static void bone_connect_to_new_parent(ListBase *edbo, EditBone *selbone, EditBo
 }
 
 static EnumPropertyItem prop_editarm_make_parent_types[] = {
-       {ARM_PAR_CONNECT, "CONNECTED", "Connected", ""},
-       {ARM_PAR_OFFSET, "OFFSET", "Keep Offset", ""},
-       {0, NULL, NULL, NULL}
+       {ARM_PAR_CONNECT, "CONNECTED", 0, "Connected", ""},
+       {ARM_PAR_OFFSET, "OFFSET", 0, "Keep Offset", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int armature_parent_set_exec(bContext *C, wmOperator *op) 
@@ -3785,9 +3785,9 @@ void ARMATURE_OT_parent_set(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_editarm_clear_parent_types[] = {
-       {1, "CLEAR", "Clear Parent", ""},
-       {2, "DISCONNECT", "Disconnect Bone", ""},
-       {0, NULL, NULL, NULL}
+       {1, "CLEAR", 0, "Clear Parent", ""},
+       {2, "DISCONNECT", 0, "Disconnect Bone", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static void editbone_clear_parent(EditBone *ebone, int mode)
@@ -3973,9 +3973,9 @@ static int armature_select_hierarchy_exec(bContext *C, wmOperator *op)
 void ARMATURE_OT_select_hierarchy(wmOperatorType *ot)
 {
        static EnumPropertyItem direction_items[]= {
-       {BONE_SELECT_PARENT, "PARENT", "Select Parent", ""},
-       {BONE_SELECT_CHILD, "CHILD", "Select Child", ""},
-       {0, NULL, NULL, NULL}
+       {BONE_SELECT_PARENT, "PARENT", 0, "Select Parent", ""},
+       {BONE_SELECT_CHILD, "CHILD", 0, "Select Child", ""},
+       {0, NULL, 0, NULL, NULL}
        };
        
        /* identifiers */
index 0d7bb3c..281f314 100644 (file)
@@ -500,9 +500,9 @@ static int pose_select_hierarchy_exec(bContext *C, wmOperator *op)
 void POSE_OT_select_hierarchy(wmOperatorType *ot)
 {
        static EnumPropertyItem direction_items[]= {
-       {BONE_SELECT_PARENT, "PARENT", "Select Parent", ""},
-       {BONE_SELECT_CHILD, "CHILD", "Select Child", ""},
-       {0, NULL, NULL, NULL}
+       {BONE_SELECT_PARENT, "PARENT", 0, "Select Parent", ""},
+       {BONE_SELECT_CHILD, "CHILD", 0, "Select Child", ""},
+       {0, NULL, 0, NULL, NULL}
        };
        
        /* identifiers */
index 45b9a58..466908c 100644 (file)
@@ -2475,12 +2475,12 @@ static int set_spline_type_exec(bContext *C, wmOperator *op)
 void CURVE_OT_spline_type_set(wmOperatorType *ot)
 {
        static EnumPropertyItem type_items[]= {
-               {CU_POLY, "POLY", "Poly", ""},
-               {CU_BEZIER, "BEZIER", "Bezier", ""},
-               {CU_CARDINAL, "CARDINAL", "Cardinal", ""},
-               {CU_BSPLINE, "B_SPLINE", "B-Spline", ""},
-               {CU_NURBS, "NURBS", "NURBS", ""},
-               {0, NULL, NULL, NULL}};
+               {CU_POLY, "POLY", 0, "Poly", ""},
+               {CU_BEZIER, "BEZIER", 0, "Bezier", ""},
+               {CU_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
+               {CU_BSPLINE, "B_SPLINE", 0, "B-Spline", ""},
+               {CU_NURBS, "NURBS", 0, "NURBS", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Set Spline Type";
@@ -2516,12 +2516,12 @@ static int set_handle_type_exec(bContext *C, wmOperator *op)
 void CURVE_OT_handle_type_set(wmOperatorType *ot)
 {
        static EnumPropertyItem type_items[]= {
-               {1, "AUTOMATIC", "Automatic", ""},
-               {2, "VECTOR", "Vector", ""},
-               {3, "TOGGLE_FREE_ALIGN", "Toggle Free/Align", ""},
-               {5, "ALIGN", "Align", ""},
-               {6, "FREE_ALIGN", "Free Align", ""},
-               {0, NULL, NULL, NULL}};
+               {1, "AUTOMATIC", 0, "Automatic", ""},
+               {2, "VECTOR", 0, "Vector", ""},
+               {3, "TOGGLE_FREE_ALIGN", 0, "Toggle Free/Align", ""},
+               {5, "ALIGN", 0, "Align", ""},
+               {6, "FREE_ALIGN", 0, "Free Align", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Set Handle Type";
@@ -3582,9 +3582,9 @@ static int toggle_cyclic_invoke(bContext *C, wmOperator *op, wmEvent *event)
 void CURVE_OT_cyclic_toggle(wmOperatorType *ot)
 {
        static EnumPropertyItem direction_items[]= {
-               {0, "CYCLIC_U", "Cyclic U", ""},
-               {1, "CYCLIC_V", "Cyclic V", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "CYCLIC_U", 0, "Cyclic U", ""},
+               {1, "CYCLIC_V", 0, "Cyclic V", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Toggle Cyclic";
@@ -4530,10 +4530,10 @@ static int delete_invoke(bContext *C, wmOperator *op, wmEvent *event)
 void CURVE_OT_delete(wmOperatorType *ot)
 {
        static EnumPropertyItem type_items[] = {
-               {0, "SELECTED", "Selected", ""},
-               {1, "SEGMENT", "Segment", ""},
-               {2, "ALL", "All", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "SELECTED", 0, "Selected", ""},
+               {1, "SEGMENT", 0, "Segment", ""},
+               {2, "ALL", 0, "All", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Delete";
index 0fb6fb8..5389db9 100644 (file)
@@ -607,10 +607,10 @@ static int kill_selection(Object *obedit, int ins)        /* 1 == new character */
 /******************* set style operator ********************/
 
 static EnumPropertyItem style_items[]= {
-       {CU_BOLD, "BOLD", "Bold", ""},
-       {CU_ITALIC, "ITALIC", "Italic", ""},
-       {CU_UNDERLINE, "UNDERLINE", "Underline", ""},
-       {0, NULL, NULL, NULL}};
+       {CU_BOLD, "BOLD", 0, "Bold", ""},
+       {CU_ITALIC, "ITALIC", 0, "Italic", ""},
+       {CU_UNDERLINE, "UNDERLINE", 0, "Underline", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static int set_style(bContext *C, int style, int clear)
 {
@@ -873,17 +873,17 @@ void FONT_OT_text_paste(wmOperatorType *ot)
 /************************ move operator ************************/
 
 static EnumPropertyItem move_type_items[]= {
-       {LINE_BEGIN, "LINE_BEGIN", "Line Begin", ""},
-       {LINE_END, "LINE_END", "Line End", ""},
-       {PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
-       {NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
-       {PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
-       {NEXT_WORD, "NEXT_WORD", "Next Word", ""},
-       {PREV_LINE, "PREVIOUS_LINE", "Previous Line", ""},
-       {NEXT_LINE, "NEXT_LINE", "Next Line", ""},
-       {PREV_PAGE, "PREVIOUS_PAGE", "Previous Page", ""},
-       {NEXT_PAGE, "NEXT_PAGE", "Next Page", ""},
-       {0, NULL, NULL, NULL}};
+       {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
+       {LINE_END, "LINE_END", 0, "Line End", ""},
+       {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
+       {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
+       {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
+       {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
+       {PREV_LINE, "PREVIOUS_LINE", 0, "Previous Line", ""},
+       {NEXT_LINE, "NEXT_LINE", 0, "Next Line", ""},
+       {PREV_PAGE, "PREVIOUS_PAGE", 0, "Previous Page", ""},
+       {NEXT_PAGE, "NEXT_PAGE", 0, "Next Page", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static int move_cursor(bContext *C, int type, int select)
 {
@@ -1164,13 +1164,13 @@ void FONT_OT_line_break(wmOperatorType *ot)
 /******************* delete operator **********************/
 
 static EnumPropertyItem delete_type_items[]= {
-       {DEL_ALL, "ALL", "All", ""},
-       {DEL_NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
-       {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
-       {DEL_SELECTION, "SELECTION", "Selection", ""},
-       {DEL_NEXT_SEL, "NEXT_OR_SELECTION", "Next or Selection", ""},
-       {DEL_PREV_SEL, "PREVIOUS_OR_SELECTION", "Previous or Selection", ""},
-       {0, NULL, NULL, NULL}};
+       {DEL_ALL, "ALL", 0, "All", ""},
+       {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
+       {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
+       {DEL_SELECTION, "SELECTION", 0, "Selection", ""},
+       {DEL_NEXT_SEL, "NEXT_OR_SELECTION", 0, "Next or Selection", ""},
+       {DEL_PREV_SEL, "PREVIOUS_OR_SELECTION", 0, "Previous or Selection", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static int delete_exec(bContext *C, wmOperator *op)
 {
@@ -1465,9 +1465,9 @@ void free_editText(Object *obedit)
 /********************** set case operator *********************/
 
 static EnumPropertyItem case_items[]= {
-       {CASE_LOWER, "LOWER", "Lower", ""},
-       {CASE_UPPER, "UPPER", "Upper", ""},
-       {0, NULL, NULL, NULL}};
+       {CASE_LOWER, "LOWER", 0, "Lower", ""},
+       {CASE_UPPER, "UPPER", 0, "Upper", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static int set_case(bContext *C, int ccase)
 {
index 7b2cdbe..31b0b85 100644 (file)
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-#define DEF_ICON(name) {name, #name, #name, ""},
+#define DEF_ICON(name) {name, #name, 0, #name, ""},
 static EnumPropertyItem icon_items[] = {
 #include "UI_icons.h"
-               {0, NULL, NULL, NULL}};
+               {0, NULL, 0, NULL, NULL}};
 #undef DEF_ICON
 
 static void api_ui_item_common(FunctionRNA *func)
@@ -62,16 +62,26 @@ static void api_ui_item_op_common(FunctionRNA *func)
        RNA_def_property_flag(parm, PROP_REQUIRED);
 }
 
+static void api_ui_item_rna_common(FunctionRNA *func)
+{
+       PropertyRNA *parm;
+
+       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+}
+
 void RNA_api_ui_layout(StructRNA *srna)
 {
        FunctionRNA *func;
        PropertyRNA *parm;
 
        static EnumPropertyItem curve_type_items[] = {
-               {0, "NONE", "None", ""},
-               {'v', "VECTOR", "Vector", ""},
-               {'c', "COLOR", "Color", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {'v', "VECTOR", 0, "Vector", ""},
+               {'c', "COLOR", 0, "Color", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* simple layout specifiers */
        func= RNA_def_function(srna, "row", "uiLayoutRow");
@@ -104,33 +114,21 @@ void RNA_api_ui_layout(StructRNA *srna)
        /* items */
        func= RNA_def_function(srna, "itemR", "uiItemR");
        api_ui_item_common(func);
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
        RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
        RNA_def_boolean(func, "slider", 0, "", "Use slider widget for numeric values.");
        RNA_def_boolean(func, "toggle", 0, "", "Use toggle widget for boolean values.");
 
        func= RNA_def_function(srna, "items_enumR", "uiItemsEnumR");
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
 
        func= RNA_def_function(srna, "item_menu_enumR", "uiItemMenuEnumR");
        api_ui_item_common(func);
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
 
        /*func= RNA_def_function(srna, "item_enumR", "uiItemEnumR");
        api_ui_item_common(func);
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
        parm= RNA_def_string(func, "value", "", 0, "", "Enum property value.");
        RNA_def_property_flag(parm, PROP_REQUIRED);*/
 
@@ -200,7 +198,7 @@ void RNA_api_ui_layout(StructRNA *srna)
        parm= RNA_def_string(func, "name", "", 0, "Name", "Name of entry in the context.");
        RNA_def_property_flag(parm, PROP_REQUIRED);
        parm= RNA_def_pointer(func, "data", "AnyType", "", "Pointer to put in context.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
 
        /* templates */
        func= RNA_def_function(srna, "template_header", "uiTemplateHeader");
@@ -210,23 +208,20 @@ void RNA_api_ui_layout(StructRNA *srna)
        func= RNA_def_function(srna, "template_ID", "uiTemplateID");
        parm= RNA_def_pointer(func, "context", "Context", "", "Current context.");
        RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of pointer property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
        RNA_def_string(func, "new", "", 0, "", "Operator identifier to create a new ID block.");
        RNA_def_string(func, "open", "", 0, "", "Operator identifier to open a new ID block.");
        RNA_def_string(func, "unlink", "", 0, "", "Operator identifier to unlink the ID block.");
 
        func= RNA_def_function(srna, "template_modifier", "uiTemplateModifier");
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Modifier data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "data", "Modifier", "", "Modifier data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
        parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
        RNA_def_function_return(func, parm);
 
        func= RNA_def_function(srna, "template_constraint", "uiTemplateConstraint");
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Constraint data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "data", "Constraint", "", "Constraint data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
        parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
        RNA_def_function_return(func, parm);
 
@@ -245,9 +240,6 @@ void RNA_api_ui_layout(StructRNA *srna)
        RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
        
        func= RNA_def_function(srna, "template_layers", "uiTemplateLayers");
-       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of pointer property in data.");
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       api_ui_item_rna_common(func);
 }
 
index 40373c9..dd003d1 100644 (file)
@@ -1434,10 +1434,10 @@ void remake_editMesh(Scene *scene, Object *ob)
 /* *************** Operator: separate parts *************/
 
 static EnumPropertyItem prop_separate_types[] = {
-       {0, "SELECTED", "Selection", ""},
-       {1, "MATERIAL", "By Material", ""},
-       {2, "LOOSE", "By loose parts", ""},
-       {0, NULL, NULL, NULL}
+       {0, "SELECTED", 0, "Selection", ""},
+       {1, "MATERIAL", 0, "By Material", ""},
+       {2, "LOOSE", 0, "By loose parts", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* return 1: success */
index d0f7517..afbf43c 100644 (file)
@@ -458,10 +458,10 @@ typedef struct CutCurve {
 #define KNIFE_MULTICUT 3
 
 static EnumPropertyItem knife_items[]= {
-       {KNIFE_EXACT, "EXACT", "Exact", ""},
-       {KNIFE_MIDPOINT, "MIDPOINTS", "Midpoints", ""},
-       {KNIFE_MULTICUT, "MULTICUT", "Multicut", ""},
-       {0, NULL, NULL}
+       {KNIFE_EXACT, "EXACT", 0, "Exact", ""},
+       {KNIFE_MIDPOINT, "MIDPOINTS", 0, "Midpoints", ""},
+       {KNIFE_MULTICUT, "MULTICUT", 0, "Multicut", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* seg_intersect() Determines if and where a mouse trail intersects an EditEdge */
index faa3176..a1f8b32 100644 (file)
@@ -655,13 +655,13 @@ FACES GROUP
 */
 
 static EnumPropertyItem prop_simface_types[] = {
-       {1, "MATERIAL", "Material", ""},
-       {2, "IMAGE", "Image", ""},
-       {3, "AREA", "Area", ""},
-       {4, "PERIMETER", "Perimeter", ""},
-       {5, "NORMAL", "Normal", ""},
-       {6, "COPLANAR", "Co-planar", ""},
-       {0, NULL, NULL, NULL}
+       {1, "MATERIAL", 0, "Material", ""},
+       {2, "IMAGE", 0, "Image", ""},
+       {3, "AREA", 0, "Area", ""},
+       {4, "PERIMETER", 0, "Perimeter", ""},
+       {5, "NORMAL", 0, "Normal", ""},
+       {6, "COPLANAR", 0, "Co-planar", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 
@@ -849,14 +849,14 @@ EDGE GROUP
 */
 
 static EnumPropertyItem prop_simedge_types[] = {
-       {1, "LENGTH", "Length", ""},
-       {2, "DIR", "Direction", ""},
-       {3, "FACE", "Amount of Vertices in Face", ""},
-       {4, "FACE_ANGLE", "Face Angles", ""},
-       {5, "CREASE", "Crease", ""},
-       {6, "SEAM", "Seam", ""},
-       {7, "SHARP", "Sharpness", ""},
-       {0, NULL, NULL, NULL}
+       {1, "LENGTH", 0, "Length", ""},
+       {2, "DIR", 0, "Direction", ""},
+       {3, "FACE", 0, "Amount of Vertices in Face", ""},
+       {4, "FACE_ANGLE", 0, "Face Angles", ""},
+       {5, "CREASE", 0, "Crease", ""},
+       {6, "SEAM", 0, "Seam", ""},
+       {7, "SHARP", 0, "Sharpness", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int similar_edge_select__internal(Scene *scene, EditMesh *em, int mode)
@@ -1105,10 +1105,10 @@ VERT GROUP
  mode 3: same vertex groups
 */
 static EnumPropertyItem prop_simvertex_types[] = {
-       {0, "NORMAL", "Normal", ""},
-       {1, "FACE", "Amount of Vertices in Face", ""},
-       {2, "VGROUP", "Vertex Groups", ""},
-       {0, NULL, NULL, NULL}
+       {0, "NORMAL", 0, "Normal", ""},
+       {1, "FACE", 0, "Amount of Vertices in Face", ""},
+       {2, "VGROUP", 0, "Vertex Groups", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 
@@ -3537,10 +3537,10 @@ static void mesh_selection_type(Scene *scene, EditMesh *em, int val)
 }
 
 static EnumPropertyItem prop_mesh_edit_types[] = {
-       {1, "VERT", "Vertices", ""},
-       {2, "EDGE", "Edges", ""},
-       {3, "FACE", "Faces", ""},
-       {0, NULL, NULL, NULL}
+       {1, "VERT", 0, "Vertices", ""},
+       {2, "EDGE", 0, "Edges", ""},
+       {3, "FACE", 0, "Faces", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int mesh_selection_type_exec(bContext *C, wmOperator *op)
index 4fc1629..45cf67d 100644 (file)
@@ -1273,14 +1273,14 @@ void delete_mesh(Object *obedit, EditMesh *em, wmOperator *op, int event)
 
 /* Note, these values must match delete_mesh() event values */
 static EnumPropertyItem prop_mesh_delete_types[] = {
-       {10,"VERT",             "Vertices", ""},
-       {1, "EDGE",             "Edges", ""},
-       {2, "FACE",             "Faces", ""},
-       {3, "ALL",              "All", ""},
-       {4, "EDGE_FACE","Edges & Faces", ""},
-       {5, "ONLY_FACE","Only Faces", ""},
-       {6, "EDGE_LOOP","Edge Loop", ""},
-       {0, NULL, NULL, NULL}
+       {10,"VERT",             0, "Vertices", ""},
+       {1, "EDGE",             0, "Edges", ""},
+       {2, "FACE",             0, "Faces", ""},
+       {3, "ALL",              0, "All", ""},
+       {4, "EDGE_FACE",0, "Edges & Faces", ""},
+       {5, "ONLY_FACE",0, "Only Faces", ""},
+       {6, "EDGE_LOOP",0, "Edge Loop", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int delete_mesh_exec(bContext *C, wmOperator *op)
@@ -6646,11 +6646,11 @@ static int subdivs_exec(bContext *C, wmOperator *op)
 void MESH_OT_subdivs(wmOperatorType *ot)
 {
        static EnumPropertyItem type_items[]= {
-               {0, "SIMPLE", "Simple", ""},
-               {1, "MULTI", "Multi", ""},
-               {2, "FRACTAL", "Fractal", ""},
-               {3, "SMOOTH", "Smooth", ""},
-               {0, NULL, NULL}};
+               {0, "SIMPLE", 0, "Simple", ""},
+               {1, "MULTI", 0, "Multi", ""},
+               {2, "FRACTAL", 0, "Fractal", ""},
+               {3, "SMOOTH", 0, "Smooth", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "subdivs";
index 4cf98f2..74a1fc1 100644 (file)
@@ -244,17 +244,17 @@ void ED_object_base_init_from_view(bContext *C, Base *base)
 /* ******************* add object operator ****************** */
 
 static EnumPropertyItem prop_object_types[] = {
-       {OB_EMPTY, "EMPTY", "Empty", ""},
-       {OB_MESH, "MESH", "Mesh", ""},
-       {OB_CURVE, "CURVE", "Curve", ""},
-       {OB_SURF, "SURFACE", "Surface", ""},
-       {OB_FONT, "TEXT", "Text", ""},
-       {OB_MBALL, "META", "Meta", ""},
-       {OB_LAMP, "LAMP", "Lamp", ""},
-       {OB_CAMERA, "CAMERA", "Camera", ""},
-       {OB_ARMATURE, "ARMATURE", "Armature", ""},
-       {OB_LATTICE, "LATTICE", "Lattice", ""},
-       {0, NULL, NULL, NULL}
+       {OB_EMPTY, "EMPTY", 0, "Empty", ""},
+       {OB_MESH, "MESH", 0, "Mesh", ""},
+       {OB_CURVE, "CURVE", 0, "Curve", ""},
+       {OB_SURF, "SURFACE", 0, "Surface", ""},
+       {OB_FONT, "TEXT", 0, "Text", ""},
+       {OB_MBALL, "META", 0, "Meta", ""},
+       {OB_LAMP, "LAMP", 0, "Lamp", ""},
+       {OB_CAMERA, "CAMERA", 0, "Camera", ""},
+       {OB_ARMATURE, "ARMATURE", 0, "Armature", ""},
+       {OB_LATTICE, "LATTICE", 0, "Lattice", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 
@@ -321,16 +321,16 @@ void OBJECT_OT_object_add(wmOperatorType *ot)
 /* ******  work both in and outside editmode ****** */
 
 static EnumPropertyItem prop_mesh_types[] = {
-       {0, "PLANE", "Plane", ""},
-       {1, "CUBE", "Cube", ""},
-       {2, "CIRCLE", "Circle", ""},
-       {3, "UVSPHERE", "UVsphere", ""},
-       {4, "ICOSPHERE", "Icosphere", ""},
-       {5, "CYLINDER", "Cylinder", ""},
-       {6, "CONE", "Cone", ""},
-       {7, "GRID", "Grid", ""},
-       {8, "MONKEY", "Monkey", ""},
-       {0, NULL, NULL, NULL}
+       {0, "PLANE", 0, "Plane", ""},
+       {1, "CUBE", 0, "Cube", ""},
+       {2, "CIRCLE", 0, "Circle", ""},
+       {3, "UVSPHERE", 0, "UVsphere", ""},
+       {4, "ICOSPHERE", 0, "Icosphere", ""},
+       {5, "CYLINDER", 0, "Cylinder", ""},
+       {6, "CONE", 0, "Cone", ""},
+       {7, "GRID", 0, "Grid", ""},
+       {8, "MONKEY", 0, "Monkey", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int object_add_mesh_exec(bContext *C, wmOperator *op)
@@ -405,12 +405,12 @@ void OBJECT_OT_mesh_add(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_curve_types[] = {
-       {CU_BEZIER|CU_2D|CU_PRIM_CURVE, "BEZIER_CURVE", "Bezier Curve", ""},
-       {CU_BEZIER|CU_2D|CU_PRIM_CIRCLE, "BEZIER_CIRCLE", "Bezier Circle", ""},
-       {CU_NURBS|CU_2D|CU_PRIM_CURVE, "NURBS_CURVE", "NURBS Curve", ""},
-       {CU_NURBS|CU_2D|CU_PRIM_CIRCLE, "NURBS_CIRCLE", "NURBS Circle", ""},
-       {CU_NURBS|CU_2D|CU_PRIM_PATH, "PATH", "Path", ""},
-       {0, NULL, NULL, NULL}
+       {CU_BEZIER|CU_2D|CU_PRIM_CURVE, "BEZIER_CURVE", 0, "Bezier Curve", ""},
+       {CU_BEZIER|CU_2D|CU_PRIM_CIRCLE, "BEZIER_CIRCLE", 0, "Bezier Circle", ""},
+       {CU_NURBS|CU_2D|CU_PRIM_CURVE, "NURBS_CURVE", 0, "NURBS Curve", ""},
+       {CU_NURBS|CU_2D|CU_PRIM_CIRCLE, "NURBS_CIRCLE", 0, "NURBS Circle", ""},
+       {CU_NURBS|CU_2D|CU_PRIM_PATH, "PATH", 0, "Path", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int object_add_curve_exec(bContext *C, wmOperator *op)
@@ -479,13 +479,13 @@ void OBJECT_OT_curve_add(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_surface_types[]= {
-       {CU_PRIM_CURVE|CU_NURBS, "NURBS_CURVE", "NURBS Curve", ""},
-       {CU_PRIM_CIRCLE|CU_NURBS, "NURBS_CIRCLE", "NURBS Circle", ""},
-       {CU_PRIM_PATCH|CU_NURBS, "NURBS_SURFACE", "NURBS Surface", ""},
-       {CU_PRIM_TUBE|CU_NURBS, "NURBS_TUBE", "NURBS Tube", ""},
-       {CU_PRIM_SPHERE|CU_NURBS, "NURBS_SPHERE", "NURBS Sphere", ""},
-       {CU_PRIM_DONUT|CU_NURBS, "NURBS_DONUT", "NURBS Donut", ""},
-       {0, NULL, NULL, NULL}
+       {CU_PRIM_CURVE|CU_NURBS, "NURBS_CURVE", 0, "NURBS Curve", ""},
+       {CU_PRIM_CIRCLE|CU_NURBS, "NURBS_CIRCLE", 0, "NURBS Circle", ""},
+       {CU_PRIM_PATCH|CU_NURBS, "NURBS_SURFACE", 0, "NURBS Surface", ""},
+       {CU_PRIM_TUBE|CU_NURBS, "NURBS_TUBE", 0, "NURBS Tube", ""},
+       {CU_PRIM_SPHERE|CU_NURBS, "NURBS_SPHERE", 0, "NURBS Sphere", ""},
+       {CU_PRIM_DONUT|CU_NURBS, "NURBS_DONUT", 0, "NURBS Donut", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int object_add_surface_exec(bContext *C, wmOperator *op)
@@ -1366,10 +1366,10 @@ void add_hook_menu(Scene *scene, View3D *v3d)
 /* ******************** clear parent operator ******************* */
 
 static EnumPropertyItem prop_clear_parent_types[] = {
-       {0, "CLEAR", "Clear Parent", ""},
-       {1, "CLEAR_KEEP_TRANSFORM", "Clear and Keep Transformation (Clear Track)", ""},
-       {2, "CLEAR_INVERSE", "Clear Parent Inverse", ""},
-       {0, NULL, NULL, NULL}
+       {0, "CLEAR", 0, "Clear Parent", ""},
+       {1, "CLEAR_KEEP_TRANSFORM", 0, "Clear and Keep Transformation (Clear Track)", ""},
+       {2, "CLEAR_INVERSE", 0, "Clear Parent Inverse", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* note, poll should check for editable scene */
@@ -1422,9 +1422,9 @@ void OBJECT_OT_parent_clear(wmOperatorType *ot)
 
 
 static EnumPropertyItem prop_clear_track_types[] = {
-       {0, "CLEAR", "Clear Track", ""},
-       {1, "CLEAR_KEEP_TRANSFORM", "Clear and Keep Transformation (Clear Track)", ""},
-       {0, NULL, NULL, NULL}
+       {0, "CLEAR", 0, "Clear Track", ""},
+       {1, "CLEAR_KEEP_TRANSFORM", 0, "Clear and Keep Transformation (Clear Track)", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* note, poll should check for editable scene */
@@ -1471,9 +1471,9 @@ void OBJECT_OT_track_clear(wmOperatorType *ot)
 
 /* *****************Selection Operators******************* */
 static EnumPropertyItem prop_select_types[] = {
-       {0, "EXCLUSIVE", "Exclusive", ""},
-       {1, "EXTEND", "Extend", ""},
-       {0, NULL, NULL, NULL}
+       {0, "EXCLUSIVE", 0, "Exclusive", ""},
+       {1, "EXTEND", 0, "Extend", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* ****** Select by Type ****** */
@@ -1526,13 +1526,13 @@ void OBJECT_OT_select_by_type(wmOperatorType *ot)
 /* ****** selection by links *******/
 
 static EnumPropertyItem prop_select_linked_types[] = {
-       {1, "IPO", "Object IPO", ""}, // XXX depreceated animation system stuff...
-       {2, "OBDATA", "Ob Data", ""},
-       {3, "MATERIAL", "Material", ""},
-       {4, "TEXTURE", "Texture", ""},
-       {5, "DUPGROUP", "Dupligroup", ""},
-       {6, "PARTICLE", "Particle System", ""},
-       {0, NULL, NULL, NULL}
+       {1, "IPO", 0, "Object IPO", ""}, // XXX depreceated animation system stuff...
+       {2, "OBDATA", 0, "Ob Data", ""},
+       {3, "MATERIAL", 0, "Material", ""},
+       {4, "TEXTURE", 0, "Texture", ""},
+       {5, "DUPGROUP", 0, "Dupligroup", ""},
+       {6, "PARTICLE", 0, "Particle System", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int object_select_linked_exec(bContext *C, wmOperator *op)
@@ -2085,9 +2085,9 @@ void OBJECT_OT_restrictview_clear(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_set_restrictview_types[] = {
-       {0, "SELECTED", "Selected", ""},
-       {1, "UNSELECTED", "Unselected ", ""},
-       {0, NULL, NULL, NULL}
+       {0, "SELECTED", 0, "Selected", ""},
+       {1, "UNSELECTED", 0, "Unselected ", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int object_restrictview_set_exec(bContext *C, wmOperator *op)
@@ -2462,16 +2462,16 @@ void make_proxy(Scene *scene)
 #define PAR_TRIA               8
 
 static EnumPropertyItem prop_make_parent_types[] = {
-       {PAR_OBJECT, "OBJECT", "Object", ""},
-       {PAR_ARMATURE, "ARMATURE", "Armature Deform", ""},
-       {PAR_BONE, "BONE", "Bone", ""},
-       {PAR_CURVE, "CURVE", "Curve Deform", ""},
-       {PAR_FOLLOW, "FOLLOW", "Follow Path", ""},
-       {PAR_PATH_CONST, "PATH_CONST", "Path Constraint", ""},
-       {PAR_LATTICE, "LATTICE", "Lattice Deform", ""},
-       {PAR_VERTEX, "VERTEX", "Vertex", ""},
-       {PAR_TRIA, "TRIA", "Triangle", ""},
-       {0, NULL, NULL, NULL}
+       {PAR_OBJECT, "OBJECT", 0, "Object", ""},
+       {PAR_ARMATURE, "ARMATURE", 0, "Armature Deform", ""},
+       {PAR_BONE, "BONE", 0, "Bone", ""},
+       {PAR_CURVE, "CURVE", 0, "Curve Deform", ""},
+       {PAR_FOLLOW, "FOLLOW", 0, "Follow Path", ""},
+       {PAR_PATH_CONST, "PATH_CONST", 0, "Path Constraint", ""},
+       {PAR_LATTICE, "LATTICE", 0, "Lattice Deform", ""},
+       {PAR_VERTEX, "VERTEX", 0, "Vertex", ""},
+       {PAR_TRIA, "TRIA", 0, "Triangle", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int test_parent_loop(Object *par, Object *ob)
@@ -2655,10 +2655,10 @@ void OBJECT_OT_parent_set(wmOperatorType *ot)
 
 /* *** make track ***** */
 static EnumPropertyItem prop_make_track_types[] = {
-       {1, "TRACKTO", "TrackTo Constraint", ""},
-       {2, "LOCKTRACK", "LockTrack Constraint", ""},
-       {3, "OLDTRACK", "Old Track", ""},
-       {0, NULL, NULL, NULL}
+       {1, "TRACKTO", 0, "TrackTo Constraint", ""},
+       {2, "LOCKTRACK", 0, "LockTrack Constraint", ""},
+       {3, "OLDTRACK", 0, "Old Track", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int track_set_exec(bContext *C, wmOperator *op)
@@ -2831,10 +2831,10 @@ void OBJECT_OT_dupli_set_real(wmOperatorType *ot)
 /* ******************* Set Object Center ********************** */
 
 static EnumPropertyItem prop_set_center_types[] = {
-       {0, "CENTER", "ObData to Center", "Move object data around Object center"},
-       {1, "CENTERNEW", "Center New", "Move Object center to center of object data"},
-       {2, "CENTERCURSOR", "Center Cursor", "Move Object Center to position of the 3d cursor"},
-       {0, NULL, NULL, NULL}
+       {0, "CENTER", 0, "ObData to Center", "Move object data around Object center"},
+       {1, "CENTERNEW", 0, "Center New", "Move Object center to center of object data"},
+       {2, "CENTERCURSOR", 0, "Center Cursor", "Move Object Center to position of the 3d cursor"},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* 0 == do center, 1 == center new, 2 == center cursor */
index 0947f54..a9fc65b 100644 (file)
@@ -2347,8 +2347,8 @@ void PARTICLE_OT_brush_radial_control(wmOperatorType *ot)
 enum { DEL_PARTICLE, DEL_KEY };
 
 static EnumPropertyItem delete_type_items[]= {
-       {DEL_PARTICLE, "PARTICLE", "Particle", ""},
-       {DEL_KEY, "KEY", "Key", ""},
+       {DEL_PARTICLE, "PARTICLE", 0, "Particle", ""},
+       {DEL_KEY, "KEY", 0, "Key", ""},
        {0, NULL, NULL}};
 
 static void set_delete_particle(PEData *data, int pa_index)
@@ -2563,15 +2563,15 @@ void PARTICLE_OT_mirror(wmOperatorType *ot)
 /*********************** set brush operator **********************/
 
 static EnumPropertyItem brush_type_items[]= {
-       {PE_BRUSH_NONE, "NONE", "None", ""},
-       {PE_BRUSH_COMB, "COMB", "Comb", ""},
-       {PE_BRUSH_SMOOTH, "SMOOTH", "Smooth", ""},
-       {PE_BRUSH_WEIGHT, "WEIGHT", "Weight", ""},
-       {PE_BRUSH_ADD, "ADD", "Add", ""},
-       {PE_BRUSH_LENGTH, "LENGTH", "Length", ""},
-       {PE_BRUSH_PUFF, "PUFF", "Puff", ""},
-       {PE_BRUSH_CUT, "CUT", "Cut", ""},
-       {0, NULL, NULL, NULL}
+       {PE_BRUSH_NONE, "NONE", 0, "None", ""},
+       {PE_BRUSH_COMB, "COMB", 0, "Comb", ""},
+       {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", ""},
+       {PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", ""},
+       {PE_BRUSH_ADD, "ADD", 0, "Add", ""},
+       {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", ""},
+       {PE_BRUSH_PUFF, "PUFF", 0, "Puff", ""},
+       {PE_BRUSH_CUT, "CUT", 0, "Cut", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int set_brush_exec(bContext *C, wmOperator *op)
index 3f4d175..dae7a7c 100644 (file)
@@ -1192,9 +1192,9 @@ static int area_split_modal(bContext *C, wmOperator *op, wmEvent *event)
 }
 
 static EnumPropertyItem prop_direction_items[] = {
-       {'h', "HORIZONTAL", "Horizontal", ""},
-       {'v', "VERTICAL", "Vertical", ""},
-       {0, NULL, NULL, NULL}};
+       {'h', "HORIZONTAL", 0, "Horizontal", ""},
+       {'v', "VERTICAL", 0, "Vertical", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 void SCREEN_OT_area_split(wmOperatorType *ot)
 {
index dc954ff..2dba08b 100644 (file)
@@ -1245,10 +1245,10 @@ static int sculpt_brush_curve_preset_exec(bContext *C, wmOperator *op)
 static void SCULPT_OT_brush_curve_preset(wmOperatorType *ot)
 {
        static EnumPropertyItem prop_mode_items[] = {
-               {BRUSH_PRESET_SHARP, "SHARP", "Sharp Curve", ""},
-               {BRUSH_PRESET_SMOOTH, "SMOOTH", "Smooth Curve", ""},
-               {BRUSH_PRESET_MAX, "MAX", "Max Curve", ""},
-               {0, NULL, NULL, NULL}};
+               {BRUSH_PRESET_SHARP, "SHARP", 0, "Sharp Curve", ""},
+               {BRUSH_PRESET_SMOOTH, "SMOOTH", 0, "Smooth Curve", ""},
+               {BRUSH_PRESET_MAX, "MAX", 0, "Max Curve", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        ot->name= "Preset";
        ot->idname= "SCULPT_OT_brush_curve_preset";
index af074ca..a0f1adb 100644 (file)
@@ -369,10 +369,10 @@ void ACT_OT_keyframes_paste (wmOperatorType *ot)
 
 /* defines for insert keyframes tool */
 EnumPropertyItem prop_actkeys_insertkey_types[] = {
-       {1, "ALL", "All Channels", ""},
-       {2, "SEL", "Only Selected Channels", ""},
-       {3, "GROUP", "In Active Group", ""}, // xxx not in all cases
-       {0, NULL, NULL, NULL}
+       {1, "ALL", 0, "All Channels", ""},
+       {2, "SEL", 0, "Only Selected Channels", ""},
+       {3, "GROUP", 0, "In Active Group", ""}, // xxx not in all cases
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for snapping keyframes to frame-times */
@@ -799,9 +799,9 @@ void ACT_OT_keyframes_sample (wmOperatorType *ot)
 
 /* defines for set extrapolation-type for selected keyframes tool */
 EnumPropertyItem prop_actkeys_expo_types[] = {
-       {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
-       {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
-       {0, NULL, NULL, NULL}
+       {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
+       {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for setting extrapolation mode for keyframes */
@@ -1089,11 +1089,11 @@ void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
 
 /* defines for snap keyframes tool */
 EnumPropertyItem prop_actkeys_snap_types[] = {
-       {ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
-       {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
-       {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
-       {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
-       {0, NULL, NULL, NULL}
+       {ACTKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
+       {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
+       {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
+       {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for snapping keyframes to frame-times */
@@ -1188,11 +1188,11 @@ void ACT_OT_keyframes_snap (wmOperatorType *ot)
 
 /* defines for mirror keyframes tool */
 EnumPropertyItem prop_actkeys_mirror_types[] = {
-       {ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
-       {ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
-       {ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
-       {ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
-       {0, NULL, NULL, NULL}
+       {ACTKEYS_MIRROR_CFRA, "CFRA", 0, "Current frame", ""},
+       {ACTKEYS_MIRROR_YAXIS, "YAXIS", 0, "Vertical Axis", ""},
+       {ACTKEYS_MIRROR_XAXIS, "XAXIS", 0, "Horizontal Axis", ""},
+       {ACTKEYS_MIRROR_MARKER, "MARKER", 0, "First Selected Marker", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for mirroring keyframes */
index d478241..b82e44f 100644 (file)
@@ -374,11 +374,11 @@ void ACT_OT_keyframes_select_border(wmOperatorType *ot)
 
 /* defines for column-select mode */
 static EnumPropertyItem prop_column_select_types[] = {
-       {ACTKEYS_COLUMNSEL_KEYS, "KEYS", "On Selected Keyframes", ""},
-       {ACTKEYS_COLUMNSEL_CFRA, "CFRA", "On Current Frame", ""},
-       {ACTKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", "On Selected Markers", ""},
-       {ACTKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", "Between Min/Max Selected Markers", ""},
-       {0, NULL, NULL, NULL}
+       {ACTKEYS_COLUMNSEL_KEYS, "KEYS", 0, "On Selected Keyframes", ""},
+       {ACTKEYS_COLUMNSEL_CFRA, "CFRA", 0, "On Current Frame", ""},
+       {ACTKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", 0, "On Selected Markers", ""},
+       {ACTKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", 0, "Between Min/Max Selected Markers", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* ------------------- */ 
@@ -584,11 +584,11 @@ void ACT_OT_keyframes_select_column (wmOperatorType *ot)
 
 /* defines for left-right select tool */
 static EnumPropertyItem prop_actkeys_leftright_select_types[] = {
-       {ACTKEYS_LRSEL_TEST, "CHECK", "Check if Select Left or Right", ""},
-       {ACTKEYS_LRSEL_NONE, "OFF", "Don't select", ""},
-       {ACTKEYS_LRSEL_LEFT, "LEFT", "Before current frame", ""},
-       {ACTKEYS_LRSEL_RIGHT, "RIGHT", "After current frame", ""},
-       {0, NULL, NULL, NULL}
+       {ACTKEYS_LRSEL_TEST, "CHECK", 0, "Check if Select Left or Right", ""},
+       {ACTKEYS_LRSEL_NONE, "OFF", 0, "Don't select", ""},
+       {ACTKEYS_LRSEL_LEFT, "LEFT", 0, "Before current frame", ""},
+       {ACTKEYS_LRSEL_RIGHT, "RIGHT", 0, "After current frame", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* sensitivity factor for frame-selections */
index a3d0b50..49397ed 100644 (file)
@@ -1001,9 +1001,9 @@ void GRAPHEDIT_OT_keyframes_sample (wmOperatorType *ot)
 
 /* defines for set extrapolation-type for selected keyframes tool */
 EnumPropertyItem prop_graphkeys_expo_types[] = {
-       {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
-       {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
-       {0, NULL, NULL, NULL}
+       {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
+       {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for setting extrapolation mode for keyframes */
@@ -1371,12 +1371,12 @@ void GRAPHEDIT_OT_keyframes_cfrasnap (wmOperatorType *ot)
 
 /* defines for snap keyframes tool */
 EnumPropertyItem prop_graphkeys_snap_types[] = {
-       {GRAPHKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
-       {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
-       {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
-       {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
-       {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", "Flatten Handles", ""},
-       {0, NULL, NULL, NULL}
+       {GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
+       {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
+       {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
+       {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
+       {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for snapping keyframes to frame-times */
@@ -1466,11 +1466,11 @@ void GRAPHEDIT_OT_keyframes_snap (wmOperatorType *ot)
 
 /* defines for mirror keyframes tool */
 EnumPropertyItem prop_graphkeys_mirror_types[] = {
-       {GRAPHKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
-       {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
-       {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
-       {GRAPHKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
-       {0, NULL, NULL, NULL}
+       {GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "Current frame", ""},
+       {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "Vertical Axis", ""},
+       {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "Horizontal Axis", ""},
+       {GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "First Selected Marker", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* this function is responsible for mirroring keyframes */
index bb923ca..9aaef9f 100644 (file)
@@ -340,11 +340,11 @@ void GRAPHEDIT_OT_keyframes_select_border(wmOperatorType *ot)
 
 /* defines for column-select mode */
 static EnumPropertyItem prop_column_select_types[] = {
-       {GRAPHKEYS_COLUMNSEL_KEYS, "KEYS", "On Selected Keyframes", ""},
-       {GRAPHKEYS_COLUMNSEL_CFRA, "CFRA", "On Current Frame", ""},
-       {GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", "On Selected Markers", ""},
-       {GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", "Between Min/Max Selected Markers", ""},
-       {0, NULL, NULL, NULL}
+       {GRAPHKEYS_COLUMNSEL_KEYS, "KEYS", 0, "On Selected Keyframes", ""},
+       {GRAPHKEYS_COLUMNSEL_CFRA, "CFRA", 0, "On Current Frame", ""},
+       {GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", 0, "On Selected Markers", ""},
+       {GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", 0, "Between Min/Max Selected Markers", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* ------------------- */ 
@@ -526,11 +526,11 @@ void GRAPHEDIT_OT_keyframes_columnselect (wmOperatorType *ot)
 
 /* defines for left-right select tool */
 static EnumPropertyItem prop_graphkeys_leftright_select_types[] = {
-       {GRAPHKEYS_LRSEL_TEST, "CHECK", "Check if Select Left or Right", ""},
-       {GRAPHKEYS_LRSEL_NONE, "OFF", "Don't select", ""},
-       {GRAPHKEYS_LRSEL_LEFT, "LEFT", "Before current frame", ""},
-       {GRAPHKEYS_LRSEL_RIGHT, "RIGHT", "After current frame", ""},
-       {0, NULL, NULL, NULL}
+       {GRAPHKEYS_LRSEL_TEST, "CHECK", 0, "Check if Select Left or Right", ""},
+       {GRAPHKEYS_LRSEL_NONE, "OFF", 0, "Don't select", ""},
+       {GRAPHKEYS_LRSEL_LEFT, "LEFT", 0, "Before current frame", ""},
+       {GRAPHKEYS_LRSEL_RIGHT, "RIGHT", 0, "After current frame", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* ------------------- */
index 378d91c..73a7f57 100644 (file)
@@ -1412,9 +1412,9 @@ void IMAGE_OT_sample(wmOperatorType *ot)
 void IMAGE_OT_curves_point_set(wmOperatorType *ot)
 {
        static EnumPropertyItem point_items[]= {
-               {0, "BLACK_POINT", "Black Point", ""},
-               {1, "WHITE_POINT", "White Point", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "BLACK_POINT", 0, "Black Point", ""},
+               {1, "WHITE_POINT", 0, "White Point", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Set Curves Point";
index 3c37793..6746c21 100644 (file)
@@ -177,8 +177,8 @@ static int node_extend_select_invoke(bContext *C, wmOperator *op, wmEvent *event
 /* operators */
 
 static EnumPropertyItem prop_select_items[] = {
-       {NODE_SELECT_MOUSE, "NORMAL", "Normal Select", "Select using the mouse"},
-       {0, NULL, NULL, NULL}};
+       {NODE_SELECT_MOUSE, "NORMAL", 0, "Normal Select", "Select using the mouse"},
+       {0, NULL, 0, NULL, NULL}};
 
 void NODE_OT_select_extend(wmOperatorType *ot)
 {
@@ -225,9 +225,9 @@ void NODE_OT_select(wmOperatorType *ot)
 /* ****** Border Select ****** */
 
 static EnumPropertyItem prop_select_types[] = {
-       {NODE_EXCLUSIVE, "EXCLUSIVE", "Exclusive", ""}, /* right mouse */
-       {NODE_EXTEND, "EXTEND", "Extend", ""}, /* left mouse */
-       {0, NULL, NULL, NULL}
+       {NODE_EXCLUSIVE, "EXCLUSIVE", 0, "Exclusive", ""}, /* right mouse */
+       {NODE_EXTEND, "EXTEND", 0, "Extend", ""}, /* left mouse */
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int node_borderselect_exec(bContext *C, wmOperator *op)
index 20ad1b6..7cd81fa 100644 (file)
@@ -105,35 +105,35 @@ static int okee() {return 0;}
 /* XXX */
 /* RNA Enums, used in multiple files */
 EnumPropertyItem sequencer_prop_effect_types[] = {
-       {SEQ_CROSS, "CROSS", "Crossfade", "Crossfade effect strip type"},
-       {SEQ_ADD, "ADD", "Add", "Add effect strip type"},
-       {SEQ_SUB, "SUBTRACT", "Subtract", "Subtract effect strip type"},
-       {SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", "Alpha Over effect strip type"},
-       {SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", "Alpha Under effect strip type"},
-       {SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", "Gamma Cross effect strip type"},
-       {SEQ_MUL, "MULTIPLY", "Multiply", "Multiply effect strip type"},
-       {SEQ_OVERDROP, "OVER_DROP", "Alpha Over Drop", "Alpha Over Drop effect strip type"},
-       {SEQ_PLUGIN, "PLUGIN", "Plugin", "Plugin effect strip type"},
-       {SEQ_WIPE, "WIPE", "Wipe", "Wipe effect strip type"},
-       {SEQ_GLOW, "GLOW", "Glow", "Glow effect strip type"},
-       {SEQ_TRANSFORM, "TRANSFORM", "Transform", "Transform effect strip type"},
-       {SEQ_COLOR, "COLOR", "Color", "Color effect strip type"},
-       {SEQ_SPEED, "SPEED", "Speed", "Color effect strip type"},
-       {0, NULL, NULL, NULL}
+       {SEQ_CROSS, "CROSS", 0, "Crossfade", "Crossfade effect strip type"},
+       {SEQ_ADD, "ADD", 0, "Add", "Add effect strip type"},
+       {SEQ_SUB, "SUBTRACT", 0, "Subtract", "Subtract effect strip type"},
+       {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", "Alpha Over effect strip type"},
+       {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", "Alpha Under effect strip type"},
+       {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", "Gamma Cross effect strip type"},
+       {SEQ_MUL, "MULTIPLY", 0, "Multiply", "Multiply effect strip type"},
+       {SEQ_OVERDROP, "OVER_DROP", 0, "Alpha Over Drop", "Alpha Over Drop effect strip type"},
+       {SEQ_PLUGIN, "PLUGIN", 0, "Plugin", "Plugin effect strip type"},
+       {SEQ_WIPE, "WIPE", 0, "Wipe", "Wipe effect strip type"},
+       {SEQ_GLOW, "GLOW", 0, "Glow", "Glow effect strip type"},
+       {SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", "Transform effect strip type"},
+       {SEQ_COLOR, "COLOR", 0, "Color", "Color effect strip type"},
+       {SEQ_SPEED, "SPEED", 0, "Speed", "Color effect strip type"},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* mute operator */
 EnumPropertyItem sequencer_prop_operate_types[] = { /* better name? */
-       {SEQ_SELECTED, "SELECTED", "Selected", ""},
-       {SEQ_UNSELECTED, "UNSELECTED", "Unselected ", ""},
-       {0, NULL, NULL, NULL}
+       {SEQ_SELECTED, "SELECTED", 0, "Selected", ""},
+       {SEQ_UNSELECTED, "UNSELECTED", 0, "Unselected ", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
  EnumPropertyItem prop_side_types[] = {
-       {SEQ_SIDE_LEFT, "LEFT", "Left", ""},
-       {SEQ_SIDE_RIGHT, "RIGHT", "Right", ""},
-       {SEQ_SIDE_BOTH, "BOTH", "Both", ""},
-       {0, NULL, NULL, NULL}
+       {SEQ_SIDE_LEFT, "LEFT", 0, "Left", ""},
+       {SEQ_SIDE_RIGHT, "RIGHT", 0, "Right", ""},
+       {SEQ_SIDE_BOTH, "BOTH", 0, "Both", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 typedef struct TransSeq {
@@ -1726,9 +1726,9 @@ void SEQUENCER_OT_refresh_all(struct wmOperatorType *ot)
 
 /* cut operator */
 static EnumPropertyItem prop_cut_types[] = {
-       {SEQ_CUT_SOFT, "SOFT", "Soft", ""},
-       {SEQ_CUT_HARD, "HARD", "Hard", ""},
-       {0, NULL, NULL, NULL}
+       {SEQ_CUT_SOFT, "SOFT", 0, "Soft", ""},
+       {SEQ_CUT_HARD, "HARD", 0, "Hard", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static int sequencer_cut_exec(bContext *C, wmOperator *op)
index f43888b..9597079 100644 (file)
@@ -972,9 +972,9 @@ void TEXT_OT_uncomment(wmOperatorType *ot)
 
 enum { TO_SPACES, TO_TABS };
 static EnumPropertyItem whitespace_type_items[]= {
-       {TO_SPACES, "SPACES", "To Spaces", NULL},
-       {TO_TABS, "TABS", "To Tabs", NULL},
-       {0, NULL, NULL, NULL}};
+       {TO_SPACES, "SPACES", 0, "To Spaces", NULL},
+       {TO_TABS, "TABS", 0, "To Tabs", NULL},
+       {0, NULL, 0, NULL, NULL}};
 
 static int convert_whitespace_exec(bContext *C, wmOperator *op)
 {
@@ -1270,19 +1270,19 @@ void TEXT_OT_markers_clear(wmOperatorType *ot)
 /************************ move operator ************************/
 
 static EnumPropertyItem move_type_items[]= {
-       {LINE_BEGIN, "LINE_BEGIN", "Line Begin", ""},
-       {LINE_END, "LINE_END", "Line End", ""},
-       {FILE_TOP, "FILE_TOP", "File Top", ""},
-       {FILE_BOTTOM, "FILE_BOTTOM", "File Bottom", ""},
-       {PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
-       {NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
-       {PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
-       {NEXT_WORD, "NEXT_WORD", "Next Word", ""},
-       {PREV_LINE, "PREVIOUS_LINE", "Previous Line", ""},
-       {NEXT_LINE, "NEXT_LINE", "Next Line", ""},
-       {PREV_PAGE, "PREVIOUS_PAGE", "Previous Page", ""},
-       {NEXT_PAGE, "NEXT_PAGE", "Next Page", ""},
-       {0, NULL, NULL, NULL}};
+       {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
+       {LINE_END, "LINE_END", 0, "Line End", ""},
+       {FILE_TOP, "FILE_TOP", 0, "File Top", ""},
+       {FILE_BOTTOM, "FILE_BOTTOM", 0, "File Bottom", ""},
+       {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
+       {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
+       {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
+       {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
+       {PREV_LINE, "PREVIOUS_LINE", 0, "Previous Line", ""},
+       {NEXT_LINE, "NEXT_LINE", 0, "Next Line", ""},
+       {PREV_PAGE, "PREVIOUS_PAGE", 0, "Previous Page", ""},
+       {NEXT_PAGE, "NEXT_PAGE", 0, "Next Page", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static void wrap_move_bol(SpaceText *st, ARegion *ar, short sel)
 {
@@ -1613,11 +1613,11 @@ void TEXT_OT_jump(wmOperatorType *ot)
 /******************* delete operator **********************/
 
 static EnumPropertyItem delete_type_items[]= {
-       {DEL_NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
-       {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
-       {DEL_NEXT_WORD, "NEXT_WORD", "Next Word", ""},
-       {DEL_PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
-       {0, NULL, NULL, NULL}};
+       {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
+       {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
+       {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
+       {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static int delete_exec(bContext *C, wmOperator *op)
 {
@@ -2469,11 +2469,11 @@ void TEXT_OT_replace_set_selected(wmOperatorType *ot)
 
 enum { RESOLVE_IGNORE, RESOLVE_RELOAD, RESOLVE_SAVE, RESOLVE_MAKE_INTERNAL };
 static EnumPropertyItem resolution_items[]= {
-       {RESOLVE_IGNORE, "IGNORE", "Ignore", ""},
-       {RESOLVE_RELOAD, "RELOAD", "Reload", ""},
-       {RESOLVE_SAVE, "SAVE", "Save", ""},
-       {RESOLVE_MAKE_INTERNAL, "MAKE_INTERNAL", "Make Internal", ""},
-       {0, NULL, NULL, NULL}};
+       {RESOLVE_IGNORE, "IGNORE", 0, "Ignore", ""},
+       {RESOLVE_RELOAD, "RELOAD", 0, "Reload", ""},
+       {RESOLVE_SAVE, "SAVE", 0, "Save", ""},
+       {RESOLVE_MAKE_INTERNAL, "MAKE_INTERNAL", 0, "Make Internal", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 /* returns 0 if file on disk is the same or Text is in memory only
    returns 1 if file has been modified on disk since last local edit
index b4b35be..79173d3 100644 (file)
@@ -1320,14 +1320,14 @@ void VIEW3D_OT_zoom_border(wmOperatorType *ot)
 /* ********************* Changing view operator ****************** */
 
 static EnumPropertyItem prop_view_items[] = {
-       {V3D_VIEW_FRONT, "FRONT", "Front", "View From the Front"},
-       {V3D_VIEW_BACK, "BACK", "Back", "View From the Back"},
-       {V3D_VIEW_LEFT, "LEFT", "Left", "View From the Left"},
-       {V3D_VIEW_RIGHT, "RIGHT", "Right", "View From the Right"},
-       {V3D_VIEW_TOP, "TOP", "Top", "View From the Top"},
-       {V3D_VIEW_BOTTOM, "BOTTOM", "Bottom", "View From the Bottom"},
-       {V3D_VIEW_CAMERA, "CAMERA", "Camera", "View From the active amera"},
-       {0, NULL, NULL, NULL}};
+       {V3D_VIEW_FRONT, "FRONT", 0, "Front", "View From the Front"},
+       {V3D_VIEW_BACK, "BACK", 0, "Back", "View From the Back"},
+       {V3D_VIEW_LEFT, "LEFT", 0, "Left", "View From the Left"},
+       {V3D_VIEW_RIGHT, "RIGHT", 0, "Right", "View From the Right"},
+       {V3D_VIEW_TOP, "TOP", 0, "Top", "View From the Top"},
+       {V3D_VIEW_BOTTOM, "BOTTOM", 0, "Bottom", "View From the Bottom"},
+       {V3D_VIEW_CAMERA, "CAMERA", 0, "Camera", "View From the active amera"},
+       {0, NULL, 0, NULL, NULL}};
 
 static void axis_set_view(bContext *C, float q1, float q2, float q3, float q4, short view, int perspo)
 {
@@ -1479,11 +1479,11 @@ void VIEW3D_OT_viewnumpad(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_view_orbit_items[] = {
-       {V3D_VIEW_STEPLEFT, "ORBITLEFT", "Orbit Left", "Orbit the view around to the Left"},
-       {V3D_VIEW_STEPRIGHT, "ORBITRIGHT", "Orbit Right", "Orbit the view around to the Right"},
-       {V3D_VIEW_STEPUP, "ORBITUP", "Orbit Up", "Orbit the view Up"},
-       {V3D_VIEW_STEPDOWN, "ORBITDOWN", "Orbit Down", "Orbit the view Down"},
-       {0, NULL, NULL, NULL}};
+       {V3D_VIEW_STEPLEFT, "ORBITLEFT", 0, "Orbit Left", "Orbit the view around to the Left"},
+       {V3D_VIEW_STEPRIGHT, "ORBITRIGHT", 0, "Orbit Right", "Orbit the view around to the Right"},
+       {V3D_VIEW_STEPUP, "ORBITUP", 0, "Orbit Up", "Orbit the view Up"},
+       {V3D_VIEW_STEPDOWN, "ORBITDOWN", 0, "Orbit Down", "Orbit the view Down"},
+       {0, NULL, 0, NULL, NULL}};
 
 static int vieworbit_exec(bContext *C, wmOperator *op)
 {
@@ -1547,11 +1547,11 @@ void VIEW3D_OT_view_orbit(wmOperatorType *ot)
 }
 
 static EnumPropertyItem prop_view_pan_items[] = {
-       {V3D_VIEW_PANLEFT, "PANLEFT", "Pan Left", "Pan the view to the Left"},
-       {V3D_VIEW_PANRIGHT, "PANRIGHT", "Pan Right", "Pan the view to the Right"},
-       {V3D_VIEW_PANUP, "PANUP", "Pan Up", "Pan the view Up"},
-       {V3D_VIEW_PANDOWN, "PANDOWN", "Pan Down", "Pan the view Down"},
-       {0, NULL, NULL, NULL}};
+       {V3D_VIEW_PANLEFT, "PANLEFT", 0, "Pan Left", "Pan the view to the Left"},
+       {V3D_VIEW_PANRIGHT, "PANRIGHT", 0, "Pan Right", "Pan the view to the Right"},
+       {V3D_VIEW_PANUP, "PANUP", 0, "Pan Up", "Pan the view Up"},
+       {V3D_VIEW_PANDOWN, "PANDOWN", 0, "Pan Down", "Pan the view Down"},
+       {0, NULL, 0, NULL, NULL}};
 
 static int viewpan_exec(bContext *C, wmOperator *op)
 {
index 9c4f0b5..e0e8ac7 100644 (file)
@@ -715,9 +715,9 @@ void view3d_lasso_select(bContext *C, ViewContext *vc, short mcords[][2], short
 }
 
 static EnumPropertyItem lasso_select_types[] = {
-       {0, "SELECT", "Select", ""},
-       {1, "DESELECT", "Deselect", ""},
-       {0, NULL, NULL, NULL}
+       {0, "SELECT", 0, "Select", ""},
+       {1, "DESELECT", 0, "Deselect", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 
@@ -1526,9 +1526,9 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
 
 /* *****************Selection Operators******************* */
 static EnumPropertyItem prop_select_types[] = {
-       {0, "EXCLUSIVE", "Exclusive", ""},
-       {1, "EXTEND", "Extend", ""},
-       {0, NULL, NULL, NULL}
+       {0, "EXCLUSIVE", 0, "Exclusive", ""},
+       {1, "EXTEND", 0, "Extend", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 /* ****** Border Select ****** */
index 769001b..e697b6d 100644 (file)
@@ -56,29 +56,29 @@ static float VecOne[3] = {1, 1, 1};
 
 /* need constants for this */
 EnumPropertyItem proportional_mode_types[] = {
-               {0, "OFF", "Off", ""},
-               {1, "ON", "On", ""},
-               {2, "CONNECTED", "Connected", ""},
-               {0, NULL, NULL, NULL}
+               {0, "OFF", 0, "Off", ""},
+               {1, "ON", 0, "On", ""},
+               {2, "CONNECTED", 0, "Connected", ""},
+               {0, NULL, 0, NULL, NULL}
 };
 
 EnumPropertyItem snap_mode_types[] = {
-               {SCE_SNAP_TARGET_CLOSEST, "CLOSEST", "Closest", ""},
-               {SCE_SNAP_TARGET_CENTER,  "CENTER", "Center", ""},
-               {SCE_SNAP_TARGET_MEDIAN,  "MEDIAN", "Median", ""},
-               {SCE_SNAP_TARGET_ACTIVE,  "ACTIVE", "Active", ""},
-               {0, NULL, NULL, NULL}
+               {SCE_SNAP_TARGET_CLOSEST, "CLOSEST", 0, "Closest", ""},
+               {SCE_SNAP_TARGET_CENTER,  "CENTER", 0, "Center", ""},
+               {SCE_SNAP_TARGET_MEDIAN,  "MEDIAN", 0, "Median", ""},
+               {SCE_SNAP_TARGET_ACTIVE,  "ACTIVE", 0, "Active", ""},
+               {0, NULL, 0, NULL, NULL}
 };
 
 EnumPropertyItem proportional_falloff_types[] = {
-               {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, NULL}
+               {PROP_SMOOTH, "SMOOTH", 0, "Smooth", ""},
+               {PROP_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {PROP_ROOT, "ROOT", 0, "Root", ""},
+               {PROP_SHARP, "SHARP", 0, "Sharp", ""},
+               {PROP_LIN, "LINEAR", 0, "Linear", ""},
+               {PROP_CONST, "CONSTANT", 0, "Constant", ""},
+               {PROP_RANDOM, "RANDOM", 0, "Random", ""},
+               {0, NULL, 0, NULL, NULL}
 };
 
 char OP_TRANSLATION[] = "TFM_OT_translation";
@@ -133,12 +133,12 @@ static int select_orientation_invoke(bContext *C, wmOperator *op, wmEvent *event
 void TFM_OT_select_orientation(struct wmOperatorType *ot)
 {
        static EnumPropertyItem orientation_items[]= {
-               {V3D_MANIP_GLOBAL, "GLOBAL", "Global", ""},
-               {V3D_MANIP_NORMAL, "NORMAL", "Normal", ""},
-               {V3D_MANIP_LOCAL, "LOCAL", "Local", ""},
-               {V3D_MANIP_VIEW, "VIEW", "View", ""},
-               {V3D_MANIP_CUSTOM, "CUSTOM", "Custom", ""},
-               {0, NULL, NULL, NULL}};
+               {V3D_MANIP_GLOBAL, "GLOBAL", 0, "Global", ""},
+               {V3D_MANIP_NORMAL, "NORMAL", 0, "Normal", ""},
+               {V3D_MANIP_LOCAL, "LOCAL", 0, "Local", ""},
+               {V3D_MANIP_VIEW, "VIEW", 0, "View", ""},
+               {V3D_MANIP_CUSTOM, "CUSTOM", 0, "Custom", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name   = "Select Orientation";
@@ -484,33 +484,33 @@ void TFM_OT_tosphere(struct wmOperatorType *ot)
 void TFM_OT_transform(struct wmOperatorType *ot)
 {
        static EnumPropertyItem transform_mode_types[] = {
-                       {TFM_INIT, "INIT", "Init", ""},
-                       {TFM_DUMMY, "DUMMY", "Dummy", ""},
-                       {TFM_TRANSLATION, "TRANSLATION", "Translation", ""},
-                       {TFM_ROTATION, "ROTATION", "Rotation", ""},
-                       {TFM_RESIZE, "RESIZE", "Resize", ""},
-                       {TFM_TOSPHERE, "TOSPHERE", "Tosphere", ""},
-                       {TFM_SHEAR, "SHEAR", "Shear", ""},
-                       {TFM_WARP, "WARP", "Warp", ""},
-                       {TFM_SHRINKFATTEN, "SHRINKFATTEN", "Shrinkfatten", ""},
-                       {TFM_TILT, "TILT", "Tilt", ""},
-                       {TFM_TRACKBALL, "TRACKBALL", "Trackball", ""},
-                       {TFM_PUSHPULL, "PUSHPULL", "Pushpull", ""},
-                       {TFM_CREASE, "CREASE", "Crease", ""},
-                       {TFM_MIRROR, "MIRROR", "Mirror", ""},
-                       {TFM_BONESIZE, "BONESIZE", "Bonesize", ""},
-                       {TFM_BONE_ENVELOPE, "BONE_ENVELOPE", "Bone_Envelope", ""},
-                       {TFM_CURVE_SHRINKFATTEN, "CURVE_SHRINKFATTEN", "Curve_Shrinkfatten", ""},
-                       {TFM_BONE_ROLL, "BONE_ROLL", "Bone_Roll", ""},
-                       {TFM_TIME_TRANSLATE, "TIME_TRANSLATE", "Time_Translate", ""},
-                       {TFM_TIME_SLIDE, "TIME_SLIDE", "Time_Slide", ""},
-                       {TFM_TIME_SCALE, "TIME_SCALE", "Time_Scale", ""},
-                       {TFM_TIME_EXTEND, "TIME_EXTEND", "Time_Extend", ""},
-                       {TFM_BAKE_TIME, "BAKE_TIME", "Bake_Time", ""},
-                       {TFM_BEVEL, "BEVEL", "Bevel", ""},
-                       {TFM_BWEIGHT, "BWEIGHT", "Bweight", ""},
-                       {TFM_ALIGN, "ALIGN", "Align", ""},
-                       {0, NULL, NULL, NULL}
+                       {TFM_INIT, "INIT", 0, "Init", ""},
+                       {TFM_DUMMY, "DUMMY", 0, "Dummy", ""},
+                       {TFM_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
+                       {TFM_ROTATION, "ROTATION", 0, "Rotation", ""},
+                       {TFM_RESIZE, "RESIZE", 0, "Resize", ""},
+                       {TFM_TOSPHERE, "TOSPHERE", 0, "Tosphere", ""},
+                       {TFM_SHEAR, "SHEAR", 0, "Shear", ""},
+                       {TFM_WARP, "WARP", 0, "Warp", ""},
+                       {TFM_SHRINKFATTEN, "SHRINKFATTEN", 0, "Shrinkfatten", ""},
+                       {TFM_TILT, "TILT", 0, "Tilt", ""},
+                       {TFM_TRACKBALL, "TRACKBALL", 0, "Trackball", ""},
+                       {TFM_PUSHPULL, "PUSHPULL", 0, "Pushpull", ""},
+                       {TFM_CREASE, "CREASE", 0, "Crease", ""},
+                       {TFM_MIRROR, "MIRROR", 0, "Mirror", ""},
+                       {TFM_BONESIZE, "BONESIZE", 0, "Bonesize", ""},
+                       {TFM_BONE_ENVELOPE, "BONE_ENVELOPE", 0, "Bone_Envelope", ""},
+                       {TFM_CURVE_SHRINKFATTEN, "CURVE_SHRINKFATTEN", 0, "Curve_Shrinkfatten", ""},
+                       {TFM_BONE_ROLL, "BONE_ROLL", 0, "Bone_Roll", ""},
+                       {TFM_TIME_TRANSLATE, "TIME_TRANSLATE", 0, "Time_Translate", ""},
+                       {TFM_TIME_SLIDE, "TIME_SLIDE", 0, "Time_Slide", ""},
+                       {TFM_TIME_SCALE, "TIME_SCALE", 0, "Time_Scale", ""},
+                       {TFM_TIME_EXTEND, "TIME_EXTEND", 0, "Time_Extend", ""},
+                       {TFM_BAKE_TIME, "BAKE_TIME", 0, "Bake_Time", ""},
+                       {TFM_BEVEL, "BEVEL", 0, "Bevel", ""},
+                       {TFM_BWEIGHT, "BWEIGHT", 0, "Bweight", ""},
+                       {TFM_ALIGN, "ALIGN", 0, "Align", ""},
+                       {0, NULL, 0, NULL, NULL}
        };
 
        /* identifiers */
index 0b82efd..a42008b 100644 (file)
@@ -963,9 +963,9 @@ static int mirror_exec(bContext *C, wmOperator *op)
 void UV_OT_mirror(wmOperatorType *ot)
 {
        static EnumPropertyItem axis_items[] = {
-               {'x', "MIRROR_X", "Mirror X", "Mirror UVs over X axis."},
-               {'y', "MIRROR_Y", "Mirror Y", "Mirror UVs over Y axis."},
-               {0, NULL, NULL, NULL}};
+               {'x', "MIRROR_X", 0, "Mirror X", "Mirror UVs over X axis."},
+               {'y', "MIRROR_Y", 0, "Mirror Y", "Mirror UVs over Y axis."},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Mirror";
@@ -1068,10 +1068,10 @@ static int align_exec(bContext *C, wmOperator *op)
 void UV_OT_align(wmOperatorType *ot)
 {
        static EnumPropertyItem axis_items[] = {
-               {'a', "ALIGN_AUTO", "Align Auto", "Automatically choose the axis on which there is most alignment already."},
-               {'x', "ALIGN_X", "Align X", "Align UVs on X axis."},
-               {'y', "ALIGN_Y", "Align Y", "Align UVs on Y axis."},
-               {0, NULL, NULL, NULL}};
+               {'a', "ALIGN_AUTO", 0, "Align Auto", "Automatically choose the axis on which there is most alignment already."},
+               {'x', "ALIGN_X", 0, "Align X", "Align UVs on X axis."},
+               {'y', "ALIGN_Y", 0, "Align Y", "Align UVs on Y axis."},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Align";
@@ -2326,9 +2326,9 @@ static int snap_cursor_exec(bContext *C, wmOperator *op)
 void UV_OT_snap_cursor(wmOperatorType *ot)
 {
        static EnumPropertyItem target_items[] = {
-               {0, "PIXELS", "Pixels", ""},
-               {1, "SELECTION", "Selection", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "PIXELS", 0, "Pixels", ""},
+               {1, "SELECTION", 0, "Selection", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Snap Cursor";
@@ -2561,10 +2561,10 @@ static int snap_selection_exec(bContext *C, wmOperator *op)
 void UV_OT_snap_selection(wmOperatorType *ot)
 {
        static EnumPropertyItem target_items[] = {
-               {0, "PIXELS", "Pixels", ""},
-               {1, "CURSOR", "Cursor", ""},
-               {2, "ADJACENT_UNSELECTED", "Adjacent Unselected", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "PIXELS", 0, "Pixels", ""},
+               {1, "CURSOR", 0, "Cursor", ""},
+               {2, "ADJACENT_UNSELECTED", 0, "Adjacent Unselected", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Snap Selection";
index 27d0c68..95467d1 100644 (file)
@@ -639,15 +639,15 @@ static void uv_map_transform(bContext *C, wmOperator *op, float center[3], float
 static void uv_transform_properties(wmOperatorType *ot, int radius)
 {
        static EnumPropertyItem direction_items[]= {
-               {VIEW_ON_EQUATOR, "VIEW_ON_EQUATOR", "View on Equator", "3D view is on the equator."},
-               {VIEW_ON_POLES, "VIEW_ON_POLES", "View on Poles", "3D view is on the poles."},
-               {ALIGN_TO_OBJECT, "ALIGN_TO_OBJECT", "Align to Object", "Align according to object transform."},
-               {0, NULL, NULL, NULL}
+               {VIEW_ON_EQUATOR, "VIEW_ON_EQUATOR", 0, "View on Equator", "3D view is on the equator."},
+               {VIEW_ON_POLES, "VIEW_ON_POLES", 0, "View on Poles", "3D view is on the poles."},
+               {ALIGN_TO_OBJECT, "ALIGN_TO_OBJECT", 0, "Align to Object", "Align according to object transform."},
+               {0, NULL, 0, NULL, NULL}
        };
        static EnumPropertyItem align_items[]= {
-               {POLAR_ZX, "POLAR_ZX", "Polar ZX", "Polar 0 is X."},
-               {POLAR_ZY, "POLAR_ZY", "Polar ZY", "Polar 0 is Y."},
-               {0, NULL, NULL, NULL}
+               {POLAR_ZX, "POLAR_ZX", 0, "Polar ZX", "Polar 0 is X."},
+               {POLAR_ZY, "POLAR_ZY", 0, "Polar ZY", "Polar 0 is Y."},
+               {0, NULL, 0, NULL, NULL}
        };
 
        RNA_def_enum(ot->srna, "direction", direction_items, VIEW_ON_EQUATOR, "Direction", "Direction of the sphere or cylinder.");
@@ -820,9 +820,9 @@ static int unwrap_exec(bContext *C, wmOperator *op)
 void UV_OT_unwrap(wmOperatorType *ot)
 {
        static EnumPropertyItem method_items[] = {
-               {0, "ANGLE_BASED", "Angle Based", ""},
-               {1, "CONFORMAL", "Conformal", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "ANGLE_BASED", 0, "Angle Based", ""},
+               {1, "CONFORMAL", 0, "Conformal", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
        ot->name= "Unwrap";
index d827d10..f7b069d 100644 (file)
@@ -479,6 +479,8 @@ void RNA_pointer_create(struct ID *id, StructRNA *type, void *data, PointerRNA *
 
 void RNA_blender_rna_pointer_create(PointerRNA *r_ptr);
 
+extern PointerRNA PointerRNA_NULL;
+
 /* Structs */
 
 const char *RNA_struct_identifier(StructRNA *type);
@@ -527,6 +529,7 @@ int RNA_property_string_maxlength(PropertyRNA *prop);
 
 const char *RNA_property_ui_name(PropertyRNA *prop);
 const char *RNA_property_ui_description(PropertyRNA *prop);
+int RNA_property_ui_icon(PropertyRNA *prop);
 
 /* Dynamic Property Information */
 
index c40f50c..6cd8cce 100644 (file)
@@ -136,6 +136,7 @@ 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, int precision);
+void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive);
 
 void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *updatefunc);
 void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable);
index 7e62ea6..b527a4f 100644 (file)
@@ -91,9 +91,13 @@ typedef enum PropertyFlag {
         * and collections */
        PROP_ANIMATEABLE = 2,
 
+       /* icon */
+       PROP_ICONS_CONSECUTIVE = 4096,
+
        /* function paramater flags */
        PROP_REQUIRED = 4,
        PROP_RETURN = 8,
+       PROP_RNAPTR = 2048,
 
        /* registering */
        PROP_REGISTER = 16,
@@ -133,6 +137,7 @@ typedef struct CollectionPointerLink {
 typedef struct EnumPropertyItem {
        int value;
        const char *identifier;
+       int icon;
        const char *name;
        const char *description;
 } EnumPropertyItem;
index 7bf968a..967636f 100644 (file)
@@ -7,6 +7,6 @@ o = SConscript('intern/SConscript')
 objs += o
 
 incs = '#/intern/guardedalloc ../blenkernel ../blenlib ../makesdna intern .'
-incs += ' ../windowmanager ../editors/include'
+incs += ' ../windowmanager ../editors/include ../imbuf'
 
 env.BlenderLib ( 'bf_rna', objs, Split(incs), [], libtype=['core'], priority = [195] )
index bc3be44..2914e48 100644 (file)
@@ -38,7 +38,7 @@ SET(SRC
      ../../../../intern/guardedalloc/intern/mallocn.c
      ../../../../intern/guardedalloc/intern/mmap_win.c)
 
-INCLUDE_DIRECTORIES(../../../../intern/guardedalloc .. ../../makesdna ../../blenkernel ../../blenlib ../../windowmanager ../../editors/include .)
+INCLUDE_DIRECTORIES(../../../../intern/guardedalloc .. ../../makesdna ../../blenkernel ../../blenlib ../../windowmanager ../../editors/include ../../imbuf .)
 FILE(GLOB INC_FILES ../*.h ../../makesdna/*.h)
 
 IF(WITH_OPENEXR)
index cd1f27f..78757c4 100644 (file)
@@ -47,6 +47,7 @@ CFLAGS += $(LEVEL_1_C_WARNINGS)
 CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 CPPFLAGS += -I../../blenlib
 CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../imbuf
 CPPFLAGS += -I../../makesdna
 CPPFLAGS += -I../../windowmanager
 CPPFLAGS += -I../../editors/include
index 9c8e00d..041f743 100644 (file)
@@ -41,11 +41,15 @@ if env['WITH_BF_FFMPEG']:
 if env['WITH_BF_QUICKTIME']:
        defs.append('WITH_QUICKTIME')
 
+if env['WITH_BF_LCMS']:
+       defs.append('WITH_LCMS')
+
 makesrna_tool.Append(CPPDEFINES=defs)
 
 makesrna_tool.Append (CPPPATH = ['#/intern/guardedalloc',
                                                                 '../../blenlib',
                                                                 '../../blenkernel',
+                                                                '../../imbuf',
                                                                 '../../makesdna',
                                                                 '../../makesrna',
                                                                 '../../windowmanager',
index ea58717..dd438cf 100644 (file)
@@ -242,7 +242,7 @@ static const char *rna_parameter_type_name(PropertyRNA *parm)
                case PROP_POINTER:  {
                        PointerPropertyRNA *pparm= (PointerPropertyRNA*)parm;
 
-                       if(strcmp((char*)pparm->type, "AnyType") == 0)
+                       if(parm->flag & PROP_RNAPTR)
                                return "PointerRNA";
                        else
                                return rna_find_dna_type((const char *)pparm->type);
@@ -1146,9 +1146,7 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
                else if(dparm->prop->arraylength)
                        fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
                else if(dparm->prop->type == PROP_POINTER) {
-                       PointerPropertyRNA *pprop= (PointerPropertyRNA*)dparm->prop;
-
-                       if(strcmp((char*)pprop->type, "AnyType") == 0)
+                       if(dparm->prop->flag & PROP_RNAPTR)
                                fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
                        else
                                fprintf(f, "\t%s= *((%s%s**)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
@@ -1467,6 +1465,7 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                        for(i=0; i<eprop->totitem; i++) {
                                                fprintf(f, "{%d, ", eprop->item[i].value);
                                                rna_print_c_string(f, eprop->item[i].identifier); fprintf(f, ", ");
+                                               fprintf(f, "%d, ", eprop->item[i].icon);
                                                rna_print_c_string(f, eprop->item[i].name); fprintf(f, ", ");
                                                rna_print_c_string(f, eprop->item[i].description); fprintf(f, "}");
                                                if(i != eprop->totitem-1)
@@ -1565,6 +1564,7 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
        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");
+       fprintf(f, "%d, ", prop->icon);
        fprintf(f, "\t%s, %s, %d,\n", rna_property_typename(prop->type), rna_property_subtypename(prop->subtype), prop->arraylength);
        fprintf(f, "\t%s, %d, %s},\n", rna_function_string(prop->update), prop->noteflag, rna_function_string(prop->editable));
 
index 870fa4d..2413cd4 100644 (file)
@@ -53,6 +53,8 @@ void RNA_exit()
 
 /* Pointer */
 
+PointerRNA PointerRNA_NULL = {{0}, 0, 0};
+
 void RNA_main_pointer_create(struct Main *main, PointerRNA *r_ptr)
 {
        r_ptr->id.data= NULL;
@@ -677,6 +679,11 @@ const char *RNA_property_ui_description(PropertyRNA *prop)
        return rna_ensure_property(prop)->description;
 }
 
+int RNA_property_ui_icon(PropertyRNA *prop)
+{
+       return rna_ensure_property(prop)->icon;
+}
+
 int RNA_property_editable(PointerRNA *ptr, PropertyRNA *prop)
 {
        ID *id;
@@ -2674,7 +2681,7 @@ static int rna_function_parameter_parse(PointerRNA *ptr, PropertyRNA *prop, Prop
 
                        ptype= RNA_property_pointer_type(ptr, prop);
 
-                       if(ptype == &RNA_AnyType) {
+                       if(prop->flag & PROP_RNAPTR) {
                                *((PointerRNA*)dest)= *((PointerRNA*)src);
                        }
                        else if (ptype!=srna) {
index 531ae1e..3eb88e7 100644 (file)
@@ -41,25 +41,25 @@ void RNA_def_actuator(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem actuator_type_items[] ={
-               {ACT_OBJECT, "OBJECT", "Object", ""},
-               {ACT_IPO, "IPO", "IPO", ""},
-               {ACT_CAMERA, "CAMERA", "Camera", ""},
-               {ACT_SOUND, "SOUND", "Sound", ""},
-               {ACT_PROPERTY, "PROPERTY", "Property", ""},
-               {ACT_CONSTRAINT, "CONSTRAINT", "Constraint", ""},
-               {ACT_EDIT_OBJECT, "EDIT_OBJECT", "Edit Object", ""},
-               {ACT_SCENE, "SCENE", "Scene", ""},
-               {ACT_RANDOM, "RANDOM", "Random", ""},
-               {ACT_MESSAGE, "MESSAGE", "Message", ""},
-               {ACT_ACTION, "ACTION", "Action", ""},
-               {ACT_CD, "CD", "CD", ""},
-               {ACT_GAME, "GAME", "Game", ""},
-               {ACT_VISIBILITY, "VISIBILITY", "Visibility", ""},
-               {ACT_2DFILTER, "FILTER_2D", "2D Filter", ""},
-               {ACT_PARENT, "PARENT", "Parent", ""},
-               {ACT_SHAPEACTION, "SHAPE_ACTION", "Shape Action", ""},
-               {ACT_STATE, "STATE", "State", ""},
-               {0, NULL, NULL, NULL}};
+               {ACT_OBJECT, "OBJECT", 0, "Object", ""},
+               {ACT_IPO, "IPO", 0, "IPO", ""},
+               {ACT_CAMERA, "CAMERA", 0, "Camera", ""},
+               {ACT_SOUND, "SOUND", 0, "Sound", ""},
+               {ACT_PROPERTY, "PROPERTY", 0, "Property", ""},
+               {ACT_CONSTRAINT, "CONSTRAINT", 0, "Constraint", ""},
+               {ACT_EDIT_OBJECT, "EDIT_OBJECT", 0, "Edit Object", ""},
+               {ACT_SCENE, "SCENE", 0, "Scene", ""},
+               {ACT_RANDOM, "RANDOM", 0, "Random", ""},
+               {ACT_MESSAGE, "MESSAGE", 0, "Message", ""},
+               {ACT_ACTION, "ACTION", 0, "Action", ""},
+               {ACT_CD, "CD", 0, "CD", ""},
+               {ACT_GAME, "GAME", 0, "Game", ""},
+               {ACT_VISIBILITY, "VISIBILITY", 0, "Visibility", ""},
+               {ACT_2DFILTER, "FILTER_2D", 0, "2D Filter", ""},
+               {ACT_PARENT, "PARENT", 0, "Parent", ""},
+               {ACT_SHAPEACTION, "SHAPE_ACTION", 0, "Shape Action", ""},
+               {ACT_STATE, "STATE", 0, "State", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Actuator", NULL);
        RNA_def_struct_ui_text(srna, "Actuator", "Game engine logic brick to apply actions in the game engine.");
index 702dc9f..2ed47ef 100644 (file)
@@ -79,11 +79,11 @@ void rna_def_keyingset_path(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_mode_grouping_items[] = {
-               {KSP_GROUP_NAMED, "NAMED", "Named Group", ""},
-               {KSP_GROUP_NONE, "NONE", "None", ""},
-               {KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""},
-               {KSP_GROUP_TEMPLATE_ITEM, "TEMPLATE", "Innermost Context-Item Name", ""},
-               {0, NULL, NULL, NULL}};
+               {KSP_GROUP_NAMED, "NAMED", 0, "Named Group", ""},
+               {KSP_GROUP_NONE, "NONE", 0, "None", ""},
+               {KSP_GROUP_KSNAME, "KEYINGSET", 0, "Keying Set Name", ""},
+               {KSP_GROUP_TEMPLATE_ITEM, "TEMPLATE", 0, "Innermost Context-Item Name", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "KeyingSetPath", NULL);
        RNA_def_struct_sdna(srna, "KS_Path");
index aa74e74..6315509 100644 (file)
@@ -256,16 +256,16 @@ void rna_def_armature(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_drawtype_items[] = {
-               {ARM_OCTA, "OCTAHEDRAL", "Octahedral", "Draw bones as octahedral shape (default)."},
-               {ARM_LINE, "STICK", "Stick", "Draw bones as simple 2D lines with dots."},
-               {ARM_B_BONE, "BBONE", "B-Bone", "Draw bones as boxes, showing subdivision and B-Splines"},
-               {ARM_ENVELOPE, "ENVELOPE", "Envelope", "Draw bones as extruded spheres, showing defomation influence volume."},
-               {0, NULL, NULL, NULL}};
+               {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Draw bones as octahedral shape (default)."},
+               {ARM_LINE, "STICK", 0, "Stick", "Draw bones as simple 2D lines with dots."},
+               {ARM_B_BONE, "BBONE", 0, "B-Bone", "Draw bones as boxes, showing subdivision and B-Splines"},
+               {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope", "Draw bones as extruded spheres, showing defomation influence volume."},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_ghost_type_items[] = {
-               {ARM_GHOST_CUR, "CURRENT_FRAME", "Around Current Frame", "Draw Ghosts of poses within a fixed number of frames around the current frame."},
-               {ARM_GHOST_RANGE, "RANGE", "In Range", "Draw Ghosts of poses within specified range."},
-               {ARM_GHOST_KEYS, "KEYS", "On Keyframes", "Draw Ghosts of poses on Keyframes."},
-               {0, NULL, NULL, NULL}};
+               {ARM_GHOST_CUR, "CURRENT_FRAME", 0, "Around Current Frame", "Draw Ghosts of poses within a fixed number of frames around the current frame."},
+               {ARM_GHOST_RANGE, "RANGE", 0, "In Range", "Draw Ghosts of poses within specified range."},
+               {ARM_GHOST_KEYS, "KEYS", 0, "On Keyframes", "Draw Ghosts of poses on Keyframes."},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "Armature", "ID");
        RNA_def_struct_ui_text(srna, "Armature", "Armature datablock containing a hierarchy of bones, usually used for rigging characters.");
index 3deb38a..90617d0 100644 (file)
@@ -67,29 +67,29 @@ void rna_def_brush(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem prop_blend_items[] = {
-               {BRUSH_BLEND_MIX, "MIX", "Mix", "Use mix blending mode while painting."},
-               {BRUSH_BLEND_ADD, "ADD", "Add", "Use add blending mode while painting."},
-               {BRUSH_BLEND_SUB, "SUB", "Subtract", "Use subtract blending mode while painting."},
-               {BRUSH_BLEND_MUL, "MUL", "Multiply", "Use multiply blending mode while painting."},
-               {BRUSH_BLEND_LIGHTEN, "LIGHTEN", "Lighten", "Use lighten blending mode while painting."},
-               {BRUSH_BLEND_DARKEN, "DARKEN", "Darken", "Use darken blending mode while painting."},
-               {BRUSH_BLEND_ERASE_ALPHA, "ERASE_ALPHA", "Erase Alpha", "Erase alpha while painting."},
-               {BRUSH_BLEND_ADD_ALPHA, "ADD_ALPHA", "Add Alpha", "Add alpha while painting."},
-               {0, NULL, NULL, NULL}};
+               {BRUSH_BLEND_MIX, "MIX", 0, "Mix", "Use mix blending mode while painting."},
+               {BRUSH_BLEND_ADD, "ADD", 0, "Add", "Use add blending mode while painting."},
+               {BRUSH_BLEND_SUB, "SUB", 0, "Subtract", "Use subtract blending mode while painting."},
+               {BRUSH_BLEND_MUL, "MUL", 0, "Multiply", "Use multiply blending mode while painting."},
+               {BRUSH_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting."},
+               {BRUSH_BLEND_DARKEN, "DARKEN", 0, "Darken", "Use darken blending mode while painting."},
+               {BRUSH_BLEND_ERASE_ALPHA, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting."},
+               {BRUSH_BLEND_ADD_ALPHA, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting."},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_texture_mode_items[] = {
-               {BRUSH_TEX_DRAG, "TEX_DRAG", "Drag", ""},
-               {BRUSH_TEX_TILE, "TEX_TILE", "Tile", ""},
-               {BRUSH_TEX_3D, "TEX_3D", "3D", ""},
-               {0, NULL, NULL, NULL}};
+               {BRUSH_TEX_DRAG, "TEX_DRAG", 0, "Drag", ""},
+               {BRUSH_TEX_TILE, "TEX_TILE", 0, "Tile", ""},
+               {BRUSH_TEX_3D, "TEX_3D", 0, "3D", ""},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_sculpt_tool_items[] = {
-               {SCULPT_TOOL_DRAW, "DRAW", "Draw", ""},
-               {SCULPT_TOOL_SMOOTH, "SMOOTH", "Smooth", ""},
-               {SCULPT_TOOL_PINCH, "PINCH", "Pinch", ""},
-               {SCULPT_TOOL_INFLATE, "INFLATE", "Inflate", ""},
-               {SCULPT_TOOL_GRAB, "GRAB", "Grab", ""},
-               {SCULPT_TOOL_LAYER, "LAYER", "Layer", ""},
-               {SCULPT_TOOL_FLATTEN, "FLATTEN", "Flatten", ""},
-               {0, NULL, NULL, NULL}};
+               {SCULPT_TOOL_DRAW, "DRAW", 0, "Draw", ""},
+               {SCULPT_TOOL_SMOOTH, "SMOOTH", 0, "Smooth", ""},
+               {SCULPT_TOOL_PINCH, "PINCH", 0, "Pinch", ""},
+               {SCULPT_TOOL_INFLATE, "INFLATE", 0, "Inflate", ""},
+               {SCULPT_TOOL_GRAB, "GRAB", 0, "Grab", ""},
+               {SCULPT_TOOL_LAYER, "LAYER", 0, "Layer", ""},
+               {SCULPT_TOOL_FLATTEN, "FLATTEN", 0, "Flatten", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "Brush", "ID");
        RNA_def_struct_ui_text(srna, "Brush", "Brush datablock for storing brush settings for painting and sculpting.");
index e64f58e..4814f95 100644 (file)
@@ -42,13 +42,13 @@ void RNA_def_camera(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem prop_type_items[] = {
-               {CAM_PERSP, "PERSP", "Perspective", ""},
-               {CAM_ORTHO, "ORTHO", "Orthographic", ""},
-               {0, NULL, NULL, NULL}};
+               {CAM_PERSP, "PERSP", 0, "Perspective", ""},
+               {CAM_ORTHO, "ORTHO", 0, "Orthographic", ""},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_lens_unit_items[] = {
-               {0, "MILLIMETERS", "Millimeters", ""},
-               {CAM_ANGLETOGGLE, "DEGREES", "Degrees", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "MILLIMETERS", 0, "Millimeters", ""},
+               {CAM_ANGLETOGGLE, "DEGREES", 0, "Degrees", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Camera", "ID");
        RNA_def_struct_ui_text(srna, "Camera", "Camera datablock for storing camera settings.");
index dcd5a49..09b423e 100644 (file)
@@ -120,9 +120,9 @@ static void rna_def_curvemappoint(BlenderRNA *brna)
        StructRNA *srna;
     PropertyRNA *prop;
        static EnumPropertyItem prop_handle_type_items[] = {
-        {0, "AUTO", "Auto Handle", ""},
-        {CUMA_VECTOR, "VECTOR", "Vector Handle", ""},
-               {0, NULL, NULL, NULL}
+        {0, "AUTO", 0, "Auto Handle", ""},
+        {CUMA_VECTOR, "VECTOR", 0, "Vector Handle", ""},
+               {0, NULL, 0, NULL, NULL}
     };
 
        srna= RNA_def_struct(brna, "CurveMapPoint", NULL);
@@ -152,9 +152,9 @@ static void rna_def_curvemap(BlenderRNA *brna)
        StructRNA *srna;
     PropertyRNA *prop;
        static EnumPropertyItem prop_extend_items[] = {
-        {0, "HORIZONTAL", "Horizontal", ""},
-        {CUMA_EXTEND_EXTRAPOLATE, "EXTRAPOLATED", "Extrapolated", ""},
-               {0, NULL, NULL, NULL}
+        {0, "HORIZONTAL", 0, "Horizontal", ""},
+        {CUMA_EXTEND_EXTRAPOLATE, "EXTRAPOLATED", 0, "Extrapolated", ""},
+               {0, NULL, 0, NULL, NULL}
     };
 
        srna= RNA_def_struct(brna, "CurveMap", NULL);
index fd1a97a..80c1459 100644 (file)
 #include "WM_types.h"
 
 EnumPropertyItem constraint_type_items[] ={
-       {CONSTRAINT_TYPE_CHILDOF, "CHILD_OF", "Child Of", ""},
-       {CONSTRAINT_TYPE_TRANSFORM, "TRANSFORM", "Transformation", ""},
+       {CONSTRAINT_TYPE_CHILDOF, "CHILD_OF", 0, "Child Of", ""},
+       {CONSTRAINT_TYPE_TRANSFORM, "TRANSFORM", 0, "Transformation", ""},
        
-       {CONSTRAINT_TYPE_LOCLIKE, "COPY_LOCATION", "Copy Location", ""},
-       {CONSTRAINT_TYPE_ROTLIKE, "COPY_ROTATION", "Copy Rotation", ""},
-       {CONSTRAINT_TYPE_SIZELIKE, "COPY_SCALE", "Copy Scale", ""},
+       {CONSTRAINT_TYPE_LOCLIKE, "COPY_LOCATION", 0, "Copy Location", ""},
+       {CONSTRAINT_TYPE_ROTLIKE, "COPY_ROTATION", 0, "Copy Rotation", ""},
+       {CONSTRAINT_TYPE_SIZELIKE, "COPY_SCALE", 0, "Copy Scale", ""},
        
-       {CONSTRAINT_TYPE_LOCLIMIT, "LIMIT_LOCATION", "Limit Location", ""},
-       {CONSTRAINT_TYPE_ROTLIMIT, "LIMIT_ROTATION", "Limit Rotation", ""},
-       {CONSTRAINT_TYPE_SIZELIMIT, "LIMIT_SCALE", "Limit Scale", ""},
-       {CONSTRAINT_TYPE_DISTLIMIT, "LIMIT_DISTANCE", "Limit Distance", ""},
+       {CONSTRAINT_TYPE_LOCLIMIT, "LIMIT_LOCATION", 0, "Limit Location", ""},
+       {CONSTRAINT_TYPE_ROTLIMIT, "LIMIT_ROTATION", 0, "Limit Rotation", ""},
+       {CONSTRAINT_TYPE_SIZELIMIT, "LIMIT_SCALE", 0, "Limit Scale", ""},
+       {CONSTRAINT_TYPE_DISTLIMIT, "LIMIT_DISTANCE", 0, "Limit Distance", ""},
        
-       {CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", "Track To", ""},
-       {CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", "Locked Track", ""},
+       {CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", 0, "Track To", ""},
+       {CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", 0, "Locked Track", ""},
        
-       {CONSTRAINT_TYPE_MINMAX, "FLOOR", "Floor", ""},
-       {CONSTRAINT_TYPE_SHRINKWRAP, "SHRINKWRAP", "Shrinkwrap", ""},
-       {CONSTRAINT_TYPE_FOLLOWPATH, "FOLLOW_PATH", "Follow Path", ""},
+       {CONSTRAINT_TYPE_MINMAX, "FLOOR", 0, "Floor", ""},
+       {CONSTRAINT_TYPE_SHRINKWRAP, "SHRINKWRAP", 0, "Shrinkwrap", ""},
+       {CONSTRAINT_TYPE_FOLLOWPATH, "FOLLOW_PATH", 0, "Follow Path", ""},
        
-       {CONSTRAINT_TYPE_CLAMPTO, "CLAMP_TO", "Clamp To", ""},
-       {CONSTRAINT_TYPE_STRETCHTO, "STRETCH_TO", "Stretch To", ""},
+       {CONSTRAINT_TYPE_CLAMPTO, "CLAMP_TO", 0, "Clamp To", ""},
+       {CONSTRAINT_TYPE_STRETCHTO, "STRETCH_TO", 0, "Stretch To", ""},
        
-       {CONSTRAINT_TYPE_KINEMATIC, "IK", "IK", ""},
-       {CONSTRAINT_TYPE_RIGIDBODYJOINT, "RIGID_BODY_JOINT", "Rigid Body Joint", ""},
+       {CONSTRAINT_TYPE_KINEMATIC, "IK", 0, "IK", ""},
+       {CONSTRAINT_TYPE_RIGIDBODYJOINT, "RIGID_BODY_JOINT", 0, "Rigid Body Joint", ""},
        
-       {CONSTRAINT_TYPE_ACTION, "ACTION", "Action", ""},
+       {CONSTRAINT_TYPE_ACTION, "ACTION", 0, "Action", ""},
        
-       {CONSTRAINT_TYPE_PYTHON, "SCRIPT", "Script", ""},
+       {CONSTRAINT_TYPE_PYTHON, "SCRIPT", 0, "Script", ""},
        
-       {CONSTRAINT_TYPE_NULL, "NULL", "Null", ""},
-       {0, NULL, NULL, NULL}};
+       {CONSTRAINT_TYPE_NULL, "NULL", 0, "Null", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 
 #ifdef RNA_RUNTIME
@@ -167,16 +167,16 @@ static void rna_Constraint_influence_update(bContext *C, PointerRNA *ptr)
 }
 
 static EnumPropertyItem space_pchan_items[] = {
-       {0, "WORLD", "World Space", ""},
-       {2, "POSE", "Pose Space", ""},
-       {3, "LOCAL_WITH_PARENT", "Local With Parent", ""},
-       {1, "LOCAL", "Local Space", ""},
-       {0, NULL, NULL, NULL}};
+       {0, "WORLD", 0, "World Space", ""},
+       {2, "POSE", 0, "Pose Space", ""},
+       {3, "LOCAL_WITH_PARENT", 0, "Local With Parent", ""},
+       {1, "LOCAL", 0, "Local Space", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static EnumPropertyItem space_object_items[] = {
-       {0, "WORLD", "World Space", ""},
-       {1, "LOCAL", "Local (Without Parent) Space", ""},
-       {0, NULL, NULL, NULL}};
+       {0, "WORLD", 0, "World Space", ""},
+       {1, "LOCAL", 0, "Local (Without Parent) Space", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 static EnumPropertyItem *rna_Constraint_owner_space_itemf(PointerRNA *ptr)
 {
@@ -424,19 +424,19 @@ static void rna_def_constraint_track_to(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem track_items[] = {
-               {TRACK_X, "TRACK_X", "X", ""},
-               {TRACK_Y, "TRACK_Y", "Y", ""},
-               {TRACK_Z, "TRACK_Z", "Z", ""},
-               {TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
-               {TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
-               {TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "TRACK_X", 0, "X", ""},
+               {TRACK_Y, "TRACK_Y", 0, "Y", ""},
+               {TRACK_Z, "TRACK_Z", 0, "Z", ""},
+               {TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
+               {TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
+               {TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem up_items[] = {
-               {TRACK_X, "UP_X", "X", ""},
-               {TRACK_Y, "UP_Y", "Y", ""},
-               {TRACK_Z, "UP_Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "UP_X", 0, "X", ""},
+               {TRACK_Y, "UP_Y", 0, "Y", ""},
+               {TRACK_Z, "UP_Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "TrackToConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Track To Constraint", "Aims the constrained object toward the target.");
@@ -597,13 +597,13 @@ static void rna_def_constraint_minmax(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem minmax_items[] = {
-               {LOCLIKE_X, "FLOOR_X", "X", ""},
-               {LOCLIKE_Y, "FLOOR_Y", "Y", ""},
-               {LOCLIKE_Z, "FLOOR_Z", "Z", ""},
-               {LOCLIKE_X_INVERT, "FLOOR_NEGATIVE_X", "-X", ""},
-               {LOCLIKE_Y_INVERT, "FLOOR_NEGATIVE_Y", "-Y", ""},
-               {LOCLIKE_Z_INVERT, "FLOOR_NEGATIVE_Z", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {LOCLIKE_X, "FLOOR_X", 0, "X", ""},
+               {LOCLIKE_Y, "FLOOR_Y", 0, "Y", ""},
+               {LOCLIKE_Z, "FLOOR_Z", 0, "Z", ""},
+               {LOCLIKE_X_INVERT, "FLOOR_NEGATIVE_X", 0, "-X", ""},
+               {LOCLIKE_Y_INVERT, "FLOOR_NEGATIVE_Y", 0, "-Y", ""},
+               {LOCLIKE_Z_INVERT, "FLOOR_NEGATIVE_Z", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "FloorConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Floor Constraint", "Uses the target object for location limitation.");
@@ -690,16 +690,16 @@ static void rna_def_constraint_action(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem transform_channel_items[] = {
-               {00, "ROTATION_X", "Rotation X", ""},
-               {01, "ROTATION_Y", "Rotation Y", ""},
-               {02, "ROTATION_Z", "Rotation Z", ""},
-               {10, "SIZE_X", "Scale X", ""},
-               {11, "SIZE_Y", "Scale Y", ""},
-               {12, "SIZE_Z", "Scale Z", ""},
-               {20, "LOCATION_X", "Location X", ""},
-               {21, "LOCATION_Y", "Location Y", ""},
-               {22, "LOCATION_Z", "Location Z", ""},
-               {0, NULL, NULL, NULL}};
+               {00, "ROTATION_X", 0, "Rotation X", ""},
+               {01, "ROTATION_Y", 0, "Rotation Y", ""},
+               {02, "ROTATION_Z", 0, "Rotation Z", ""},
+               {10, "SIZE_X", 0, "Scale X", ""},
+               {11, "SIZE_Y", 0, "Scale Y", ""},
+               {12, "SIZE_Z", 0, "Scale Z", ""},
+               {20, "LOCATION_X", 0, "Location X", ""},
+               {21, "LOCATION_Y", 0, "Location Y", ""},
+               {22, "LOCATION_Z", 0, "Location Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "ActionConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Action Constraint", "Map an action to the transform axes of a bone.");
@@ -759,19 +759,19 @@ static void rna_def_constraint_locked_track(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem locktrack_items[] = {
-               {TRACK_X, "TRACK_X", "X", ""},
-               {TRACK_Y, "TRACK_Y", "Y", ""},
-               {TRACK_Z, "TRACK_Z", "Z", ""},
-               {TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
-               {TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
-               {TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "TRACK_X", 0, "X", ""},
+               {TRACK_Y, "TRACK_Y", 0, "Y", ""},
+               {TRACK_Z, "TRACK_Z", 0, "Z", ""},
+               {TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
+               {TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
+               {TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem lock_items[] = {
-               {TRACK_X, "LOCK_X", "X", ""},
-               {TRACK_Y, "LOCK_Y", "Y", ""},
-               {TRACK_Z, "LOCK_Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "LOCK_X", 0, "X", ""},
+               {TRACK_Y, "LOCK_Y", 0, "Y", ""},
+               {TRACK_Z, "LOCK_Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "LockedTrackConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Locked Track Constraint", "Points toward the target along the track axis, while locking the other axis.");
@@ -807,19 +807,19 @@ static void rna_def_constraint_follow_path(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem forwardpath_items[] = {
-               {TRACK_X, "FORWARD_X", "X", ""},
-               {TRACK_Y, "FORWARD_Y", "Y", ""},
-               {TRACK_Z, "FORWARD_Z", "Z", ""},
-               {TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
-               {TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
-               {TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "FORWARD_X", 0, "X", ""},
+               {TRACK_Y, "FORWARD_Y", 0, "Y", ""},
+               {TRACK_Z, "FORWARD_Z", 0, "Z", ""},
+               {TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
+               {TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
+               {TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem pathup_items[] = {
-               {TRACK_X, "UP_X", "X", ""},
-               {TRACK_Y, "UP_Y", "Y", ""},
-               {TRACK_Z, "UP_Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {TRACK_X, "UP_X", 0, "X", ""},
+               {TRACK_Y, "UP_Y", 0, "Y", ""},
+               {TRACK_Z, "UP_Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "FollowPathConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Follow Path Constraint", "Locks motion to the target path.");
@@ -860,16 +860,16 @@ static void rna_def_constraint_stretch_to(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem volume_items[] = {
-               {VOLUME_XZ, "VOLUME_XZX", "XZ", ""},
-               {VOLUME_X, "VOLUME_X", "Y", ""},
-               {VOLUME_Z, "VOLUME_Z", "Z", ""},
-               {NO_VOLUME, "NO_VOLUME", "None", ""},
-               {0, NULL, NULL, NULL}};
+               {VOLUME_XZ, "VOLUME_XZX", 0, "XZ", ""},
+               {VOLUME_X, "VOLUME_X", 0, "Y", ""},
+               {VOLUME_Z, "VOLUME_Z", 0, "Z", ""},
+               {NO_VOLUME, "NO_VOLUME", 0, "None", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem plane_items[] = {
-               {PLANE_X, "PLANE_X", "X", "Keep X Axis"},
-               {PLANE_Z, "PLANE_Z", "Z", "Keep Z Axis"},
-               {0, NULL, NULL, NULL}};
+               {PLANE_X, "PLANE_X", 0, "X", "Keep X Axis"},
+               {PLANE_Z, "PLANE_Z", 0, "Z", "Keep Z Axis"},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "StretchToConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Stretch To Constraint", "Stretches to meet the target object.");
@@ -911,11 +911,11 @@ static void rna_def_constraint_rigid_body_joint(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem pivot_items[] = {
-               {CONSTRAINT_RB_BALL, "BALL", "Ball", ""},
-               {CONSTRAINT_RB_HINGE, "HINGE", "Hinge", ""},
-               {CONSTRAINT_RB_CONETWIST, "CONE_TWIST", "Cone Twist", ""},
-               {CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", "Generic 6 DoF", ""},
-               {0, NULL, NULL, NULL}};
+               {CONSTRAINT_RB_BALL, "BALL", 0, "Ball", ""},
+               {CONSTRAINT_RB_HINGE, "HINGE", 0, "Hinge", ""},
+               {CONSTRAINT_RB_CONETWIST, "CONE_TWIST", 0, "Cone Twist", ""},
+               {CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", 0, "Generic 6 DoF", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "RigidBodyJointConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Rigid Body Joint Constraint", "For use with the Game Engine.");
@@ -995,11 +995,11 @@ static void rna_def_constraint_clamp_to(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem clamp_items[] = {
-               {CLAMPTO_AUTO, "CLAMPTO_AUTO", "Auto", ""},
-               {CLAMPTO_X, "CLAMPTO_X", "X", ""},
-               {CLAMPTO_Y, "CLAMPTO_Y", "Y", ""},
-               {CLAMPTO_Z, "CLAMPTO_Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {CLAMPTO_AUTO, "CLAMPTO_AUTO", 0, "Auto", ""},
+               {CLAMPTO_X, "CLAMPTO_X", 0, "X", ""},
+               {CLAMPTO_Y, "CLAMPTO_Y", 0, "Y", ""},
+               {CLAMPTO_Z, "CLAMPTO_Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "ClampToConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Clamp To Constraint", "Constrains an object's location to the nearest point along the target path.");
@@ -1029,16 +1029,16 @@ static void rna_def_constraint_transform(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem transform_items[] = {
-               {0, "LOCATION", "Loc", ""},
-               {1, "ROTATION", "Rot", ""},
-               {2, "SCALE", "Scale", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "LOCATION", 0, "Loc", ""},
+               {1, "ROTATION", 0, "Rot", ""},
+               {2, "SCALE", 0, "Scale", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem axis_map_items[] = {
-               {0, "X", "X", ""},
-               {1, "Y", "Y", ""},
-               {2, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "X", 0, "X", ""},
+               {1, "Y", 0, "Y", ""},
+               {2, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "TransformConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Transformation Constraint", "Maps transformations of the target to the object.");
@@ -1397,10 +1397,10 @@ static void rna_def_constraint_distance_limit(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem distance_items[] = {
-               {LIMITDIST_INSIDE, "LIMITDIST_INSIDE", "Inside", ""},
-               {LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", "Outside", ""},
-               {LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", "On Surface", ""},
-               {0, NULL, NULL, NULL}};
+               {LIMITDIST_INSIDE, "LIMITDIST_INSIDE", 0, "Inside", ""},
+               {LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", 0, "Outside", ""},
+               {LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", 0, "On Surface", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "LimitDistanceConstraint", "Constraint");
        RNA_def_struct_ui_text(srna, "Limit Distance Constraint", "Limits the distance from target object.");
@@ -1436,10 +1436,10 @@ static void rna_def_constraint_shrinkwrap(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", "Nearest Surface Point", ""},
-               {MOD_SHRINKWRAP_PROJECT, "PROJECT", "Project", ""},
-               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", "Nearest Vertex", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", 0, "Nearest Surface Point", ""},
+               {MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project", ""},
+               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "ShrinkwrapConstraint", "Constraint"); 
        RNA_def_struct_ui_text(srna, "Shrinkwrap Constraint", "Creates constraint-based shrinkwrap relationship."); 
index ed609c4..07a5023 100644 (file)
@@ -55,25 +55,33 @@ static PointerRNA rna_Context_screen_get(PointerRNA *ptr)
 static PointerRNA rna_Context_area_get(PointerRNA *ptr)
 {
        bContext *C= (bContext*)ptr->data;
-       return rna_pointer_inherit_refine(ptr, &RNA_Area, CTX_wm_area(C));
+       PointerRNA newptr;
+       RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Area, CTX_wm_area(C), &newptr);
+       return newptr;
 }
 
 static PointerRNA rna_Context_space_data_get(PointerRNA *ptr)
 {
        bContext *C= (bContext*)ptr->data;
-       return rna_pointer_inherit_refine(ptr, &RNA_Space, CTX_wm_space_data(C));
+       PointerRNA newptr;
+       RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Space, CTX_wm_space_data(C), &newptr);
+       return newptr;
 }
 
 static PointerRNA rna_Context_region_get(PointerRNA *ptr)
 {
        bContext *C= (bContext*)ptr->data;
-       return rna_pointer_inherit_refine(ptr, &RNA_Region, CTX_wm_region(C));
+       PointerRNA newptr;
+       RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Region, CTX_wm_region(C), &newptr);
+       return newptr;
 }
 
 /*static PointerRNA rna_Context_region_data_get(PointerRNA *ptr)
 {
        bContext *C= (bContext*)ptr->data;
-       return rna_pointer_inherit_refine(ptr, &RNA_RegionData, CTX_wm_region_data(C));
+       PointerRNA newptr;
+       RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_RegionData, CTX_wm_region_data(C), &newptr);
+       return newptr;
 }*/
 
 static PointerRNA rna_Context_main_get(PointerRNA *ptr)
index df603e7..4d5ef7a 100644 (file)
@@ -66,15 +66,15 @@ void RNA_def_controller(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem controller_type_items[] ={
-               {CONT_LOGIC_AND, "LOGIC_AND", "Logic And", ""},
-               {CONT_LOGIC_OR, "LOGIC_OR", "Logic Or", ""},
-               {CONT_LOGIC_NAND, "LOGIC_NAND", "Logic Nand", ""},
-               {CONT_LOGIC_NOR, "LOGIC_NOR", "Logic Nor", ""},
-               {CONT_LOGIC_XOR, "LOGIC_XOR", "Logic Xor", ""},
-               {CONT_LOGIC_XNOR, "LOGIC_XNOR", "Logic Xnor", ""},
-               {CONT_EXPRESSION, "EXPRESSION", "Expression", ""},
-               {CONT_PYTHON, "PYTHON", "Python Script", ""},
-               {0, NULL, NULL, NULL}};
+               {CONT_LOGIC_AND, "LOGIC_AND", 0, "Logic And", ""},
+               {CONT_LOGIC_OR, "LOGIC_OR", 0, "Logic Or", ""},
+               {CONT_LOGIC_NAND, "LOGIC_NAND", 0, "Logic Nand", ""},
+               {CONT_LOGIC_NOR, "LOGIC_NOR", 0, "Logic Nor", ""},
+               {CONT_LOGIC_XOR, "LOGIC_XOR", 0, "Logic Xor", ""},
+               {CONT_LOGIC_XNOR, "LOGIC_XNOR", 0, "Logic Xnor", ""},
+               {CONT_EXPRESSION, "EXPRESSION", 0, "Expression", ""},
+               {CONT_PYTHON, "PYTHON", 0, "Python Script", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* Controller */
        srna= RNA_def_struct(brna, "Controller", NULL);
index aac9d75..445a9b6 100644 (file)
 #include "DNA_material_types.h"
 
 EnumPropertyItem beztriple_handle_type_items[] = {
-               {HD_FREE, "FREE", "Free", ""},
-               {HD_AUTO, "AUTO", "Auto", ""},
-               {HD_VECT, "VECTOR", "Vector", ""},
-               {HD_ALIGN, "ALIGNED", "Aligned", ""},
-               {HD_AUTO_ANIM, "AUTO_CLAMPED", "Auto Clamped", ""},
-               {0, NULL, NULL, NULL}};
+               {HD_FREE, "FREE", 0, "Free", ""},
+               {HD_AUTO, "AUTO", 0, "Auto", ""},
+               {HD_VECT, "VECTOR", 0, "Vector", ""},
+               {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
+               {HD_AUTO_ANIM, "AUTO_CLAMPED", 0, "Auto Clamped", ""},
+               {0, NULL, 0, NULL, NULL}};
 
 EnumPropertyItem beztriple_interpolation_mode_items[] = {
-               {BEZT_IPO_CONST, "CONSTANT", "Constant", ""},
-               {BEZT_IPO_LIN, "LINEAR", "Linear", ""},
-               {BEZT_IPO_BEZ, "BEZIER", "Bezier", ""},
-               {0, NULL, NULL, NULL}};
+               {BEZT_IPO_CONST, "CONSTANT", 0, "Constant", ""},
+               {BEZT_IPO_LIN, "LINEAR", 0, "Linear", ""},
+               {BEZT_IPO_BEZ, "BEZIER", 0, "Bezier", ""},
+               {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
 
@@ -307,12 +307,12 @@ static void rna_def_font(BlenderRNA *brna, StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_align_items[] = {
-               {CU_LEFT, "LEFT", "Left", "Align text to the left"},
-               {CU_MIDDLE, "CENTRAL", "Center", "Center text"},
-               {CU_RIGHT, "RIGHT", "Right", "Align text to the right"},
-               {CU_JUSTIFY, "JUSTIFY", "Justify", "Align to the left and the right"},
-               {CU_FLUSH, "FLUSH", "Flush", "Align to the left and the right, with equal character spacing"},
-               {0, NULL, NULL, NULL}};
+               {CU_LEFT, "LEFT", 0, "Left", "Align text to the left"},
+               {CU_MIDDLE, "CENTRAL", 0, "Center", "Center text"},
+               {CU_RIGHT, "RIGHT", 0, "Right", "Align text to the right"},
+               {CU_JUSTIFY, "JUSTIFY", 0, "Justify", "Align to the left and the right"},
+               {CU_FLUSH, "FLUSH", 0, "Flush", "Align to the left and the right, with equal character spacing"},
+               {0, NULL, 0, NULL, NULL}};
                
        /* Enums */
        prop= RNA_def_property(srna, "spacemode", PROP_ENUM, PROP_NONE);
@@ -590,11 +590,11 @@ static void rna_def_curve(BlenderRNA *brna)
 static void rna_def_curve_nurb(BlenderRNA *brna)
 {
        static EnumPropertyItem spline_interpolation_items[] = {
-               {BEZT_IPO_CONST, "LINEAR", "Linear", ""},
-               {BEZT_IPO_LIN, "CARDINAL", "Cardinal", ""},
-               {BEZT_IPO_BEZ, "BSPLINE", "BSpline", ""},
-               {BEZT_IPO_BEZ, "EASE", "Ease", ""},
-               {0, NULL, NULL, NULL}};
+               {BEZT_IPO_CONST, "LINEAR", 0, "Linear", ""},
+               {BEZT_IPO_LIN, "CARDINAL", 0, "Cardinal", ""},
+               {BEZT_IPO_BEZ, "BSPLINE", 0, "BSpline", ""},
+               {BEZT_IPO_BEZ, "EASE", 0, "Ease", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        StructRNA *srna;
        PropertyRNA *prop;
index 33d94e8..05439f7 100644 (file)
@@ -976,6 +976,13 @@ void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *d
        prop->description= description;
 }
 
+void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
+{
+       prop->icon= icon;
+       if(consecutive)
+               prop->flag |= PROP_ICONS_CONSECUTIVE;
+}
+
 void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
 {
        StructRNA *srna= DefRNA.laststruct;
@@ -2219,15 +2226,13 @@ int rna_parameter_size(PropertyRNA *parm)
                        case PROP_STRING:
                                return sizeof(char *);
                        case PROP_POINTER: {
-                               PointerPropertyRNA *pprop= (PointerPropertyRNA*)parm;
-
 #ifdef RNA_RUNTIME
-                               if(pprop->type == &RNA_AnyType)
+                               if(parm->flag & PROP_RNAPTR)
                                        return sizeof(PointerRNA);
                                else
                                        return sizeof(void *);
 #else
-                               if(strcmp((char*)pprop->type, "AnyType") == 0)
+                               if(parm->flag & PROP_RNAPTR)
                                        return sizeof(PointerRNA);
                                else
                                        return sizeof(void *);
index ea26118..806219e 100644 (file)
 #include "MEM_guardedalloc.h"
 
 EnumPropertyItem fmodifier_type_items[] = {
-       {FMODIFIER_TYPE_NULL, "NULL", "Invalid", ""},
-       {FMODIFIER_TYPE_GENERATOR, "GENERATOR", "Generator", ""},
-       {FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", "Envelope", ""},
-       {FMODIFIER_TYPE_CYCLES, "CYCLES", "Cycles", ""},
-       {FMODIFIER_TYPE_NOISE, "NOISE", "Noise", ""},
-       {FMODIFIER_TYPE_FILTER, "FILTER", "Filter", ""},
-       {FMODIFIER_TYPE_PYTHON, "PYTHON", "Python", ""},
-       {FMODIFIER_TYPE_LIMITS, "LIMITS", "Limits", ""},
-       {0, NULL, NULL, NULL}};
+       {FMODIFIER_TYPE_NULL, "NULL", 0, "Invalid", ""},
+       {FMODIFIER_TYPE_GENERATOR, "GENERATOR", 0, "Generator", ""},
+       {FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", 0, "Envelope", ""},
+       {FMODIFIER_TYPE_CYCLES, "CYCLES", 0, "Cycles", ""},
+       {FMODIFIER_TYPE_NOISE, "NOISE", 0, "Noise", ""},
+       {FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},
+       {FMODIFIER_TYPE_PYTHON, "PYTHON", 0, "Python", ""},
+       {FMODIFIER_TYPE_LIMITS, "LIMITS", 0, "Limits", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
 
@@ -220,11 +220,11 @@ static void rna_def_fmodifier_generator_common(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_mode_items[] = {
-               {FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", "Expanded Polynomial", ""},
-               {FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", "Factorised Polynomial", ""},
-               {FCM_GENERATOR_FUNCTION, "FUNCTION", "Built-In Function", ""},
-               {FCM_GENERATOR_EXPRESSION, "EXPRESSION", "Expression", ""},
-               {0, NULL, NULL, NULL}};
+               {FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", 0, "Expanded Polynomial", ""},
+               {FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", 0, "Factorised Polynomial", ""},
+               {FCM_GENERATOR_FUNCTION, "FUNCTION", 0, "Built-In Function", ""},
+               {FCM_GENERATOR_EXPRESSION, "EXPRESSION", 0, "Expression", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        /* struct wrapping settings */
        RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");       
@@ -279,12 +279,12 @@ static void rna_def_fmodifier_generator_function(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_type_items[] = {
-               {0, "SIN", "Sine", ""},
-               {1, "COS", "Cosine", ""},
-               {2, "TAN", "Tangent", ""},
-               {3, "SQRT", "Square Root", ""},
-               {4, "LN", "Natural Logarithm", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "SIN", 0, "Sine", ""},
+               {1, "COS", 0, "Cosine", ""},
+               {2, "TAN", 0, "Tangent", ""},
+               {3, "SQRT", 0, "Square Root", ""},
+               {4, "LN", 0, "Natural Logarithm", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        
        srna= RNA_def_struct(brna, "FModifierGenerator_Function", "FModifier");
@@ -336,11 +336,11 @@ static void rna_def_fmodifier_cycles(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_type_items[] = {
-               {FCM_EXTRAPOLATE_NONE, "NONE", "No Cycles", "Don't do anything."},
-               {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", "Repeat Motion", "Repeat keyframe range as-is."},
-               {FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
-               {FCM_EXTRAPOLATE_MIRROR, "MIRROR", "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
-               {0, NULL, NULL, NULL}};
+               {FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything."},
+               {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is."},
+               {FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", 0, "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
+               {FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "FModifierCycles", "FModifier");
        RNA_def_struct_ui_text(srna, "Cycles F-Curve Modifier", "Repeats the values of the modified F-Curve.");
@@ -428,11 +428,11 @@ static void rna_def_fmodifier_noise(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_modification_items[] = {
-               {FCM_NOISE_MODIF_REPLACE, "REPLACE", "Replace", ""},
-               {FCM_NOISE_MODIF_ADD, "ADD", "Add", ""},
-               {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", "Subtract", ""},
-               {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", "Multiply", ""},
-               {0, NULL, NULL, NULL}};
+               {FCM_NOISE_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
+               {FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
+               {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
+               {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "FModifierNoise", "FModifier");
        RNA_def_struct_ui_text(srna, "Noise F-Curve Modifier", "Gives randomness to the modified F-Curve.");
@@ -542,10 +542,10 @@ void rna_def_channeldriver(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_type_items[] = {
-               {DRIVER_TYPE_AVERAGE, "AVERAGE", "Averaged Value", ""},
-               {DRIVER_TYPE_PYTHON, "SCRIPTED", "Scripted Expression", ""},
-               {DRIVER_TYPE_ROTDIFF, "ROTDIFF", "Rotational Difference", ""},
-               {0, NULL, NULL, NULL}};
+               {DRIVER_TYPE_AVERAGE, "AVERAGE", 0, "Averaged Value", ""},
+               {DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
+               {DRIVER_TYPE_ROTDIFF, "ROTDIFF", 0, "Rotational Difference", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Driver", NULL);
        RNA_def_struct_sdna(srna, "ChannelDriver");
@@ -575,14 +575,14 @@ void rna_def_fcurve(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_mode_extend_items[] = {
-               {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant", ""},
-               {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear", ""},
-               {0, NULL, NULL, NULL}};
+               {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant", ""},
+               {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear", ""},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_mode_color_items[] = {
-               {FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", "Automatic Rainbow", ""},
-               {FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", "Automatic XYZ to RGB", ""},
-               {FCURVE_COLOR_CUSTOM, "CUSTOM", "User Defined", ""},
-               {0, NULL, NULL, NULL}};
+               {FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", 0, "Automatic Rainbow", ""},
+               {FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", 0, "Automatic XYZ to RGB", ""},
+               {FCURVE_COLOR_CUSTOM, "CUSTOM", 0, "User Defined", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "FCurve", NULL);
        RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time.");
index 210024f..4e047ff 100644 (file)
@@ -64,10 +64,10 @@ static void rna_def_fluidsim_slip(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem slip_items[] = {
-               {OB_FSBND_NOSLIP, "NOSLIP", "No Slip", "Obstacle causes zero normal and tangential velocity (=sticky). Default for all. Only option for moving objects."},
-               {OB_FSBND_PARTSLIP, "PARTIALSLIP", "Partial Slip", "Mix between no-slip and free-slip. Non moving objects only!"},
-               {OB_FSBND_FREESLIP, "FREESLIP", "Free Slip", "Obstacle only causes zero normal velocity (=not sticky). Non moving objects only!"},
-               {0, NULL, NULL, NULL}};
+               {OB_FSBND_NOSLIP, "NOSLIP", 0, "No Slip", "Obstacle causes zero normal and tangential velocity (=sticky). Default for all. Only option for moving objects."},
+               {OB_FSBND_PARTSLIP, "PARTIALSLIP", 0, "Partial Slip", "Mix between no-slip and free-slip. Non moving objects only!"},
+               {OB_FSBND_FREESLIP, "FREESLIP", 0, "Free Slip", "Obstacle only causes zero normal velocity (=not sticky). Non moving objects only!"},
+               {0, NULL, 0, NULL, NULL}};
 
        prop= RNA_def_property(srna, "slip_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "typeFlags");
@@ -86,17 +86,17 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem quality_items[] = {
-               {OB_FSDOM_GEOM, "GEOMETRY", "Geometry", "Display geometry."},
-               {OB_FSDOM_PREVIEW, "PREVIEW", "Preview", "Display preview quality results."},
-               {OB_FSDOM_FINAL, "FINAL", "Final", "Display final quality results."},
-               {0, NULL, NULL, NULL}};
+               {OB_FSDOM_GEOM, "GEOMETRY", 0, "Geometry", "Display geometry."},
+               {OB_FSDOM_PREVIEW, "PREVIEW", 0, "Preview", "Display preview quality results."},
+               {OB_FSDOM_FINAL, "FINAL", 0, "Final", "Display final quality results."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem viscosity_items[] = {
-               {1, "MANUAL", "Manual", "Manual viscosity settings."},
-               {2, "WATER", "Water", "Viscosity of 1.0 * 10^-6."},
-               {3, "OIL", "Oil", "Viscosity of 5.0 * 10^-5."},
-               {4, "HONEY", "Honey", "Viscosity of 2.0 * 10^-3."},
-               {0, NULL, NULL, NULL}};
+               {1, "MANUAL", 0, "Manual", "Manual viscosity settings."},
+               {2, "WATER", 0, "Water", "Viscosity of 1.0 * 10^-6."},
+               {3, "OIL", 0, "Oil", "Viscosity of 5.0 * 10^-5."},
+               {4, "HONEY", 0, "Honey", "Viscosity of 2.0 * 10^-3."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "DomainFluidSettings", "FluidSettings");
        RNA_def_struct_sdna(srna, "FluidsimSettings");
@@ -217,10 +217,10 @@ static void rna_def_fluidsim_volume(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem volume_type_items[] = {
-               {1, "VOLUME", "Volume", "Use only the inner volume of the mesh."},
-               {2, "SHELL", "Shell", "Use only the outer shell of the mesh."},
-               {3, "BOTH", "Both", "Use both the inner volume and the outer shell of the mesh."},
-               {0, NULL, NULL, NULL}};
+               {1, "VOLUME", 0, "Volume", "Use only the inner volume of the mesh."},
+               {2, "SHELL", 0, "Shell", "Use only the outer shell of the mesh."},
+               {3, "BOTH", 0, "Both", "Use both the inner volume and the outer shell of the mesh."},
+               {0, NULL, 0, NULL, NULL}};
 
        prop= RNA_def_property(srna, "volume_initialization", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "volumeInitType");
@@ -393,15 +393,15 @@ void RNA_def_fluidsim(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_fluid_type_items[] = {
-               {0, "NONE", "None", ""},
-               {OB_FLUIDSIM_DOMAIN, "DOMAIN", "Domain", "Bounding box of this object represents the computational domain of the fluid simulation."},
-               {OB_FLUIDSIM_FLUID, "FLUID", "Fluid", "Object represents a volume of fluid in the simulation."},
-               {OB_FLUIDSIM_OBSTACLE, "OBSTACLE", "Obstacle", "Object is a fixed obstacle."},
-               {OB_FLUIDSIM_INFLOW, "INFLOW", "Inflow", "Object adds fluid to the simulation."},
-               {OB_FLUIDSIM_OUTFLOW, "OUTFLOW", "Outflow", "Object removes fluid from the simulation."},
-               {OB_FLUIDSIM_PARTICLE, "PARTICLE", "Particle", "Object is made a particle system to display particles generated by a fluidsim domain object."},
-               {OB_FLUIDSIM_CONTROL, "CONTROL", "Control", "Object is made a fluid control mesh, which influences the fluid."},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {OB_FLUIDSIM_DOMAIN, "DOMAIN", 0, "Domain", "Bounding box of this object represents the computational domain of the fluid simulation."},
+               {OB_FLUIDSIM_FLUID, "FLUID", 0, "Fluid", "Object represents a volume of fluid in the simulation."},
+               {OB_FLUIDSIM_OBSTACLE, "OBSTACLE", 0, "Obstacle", "Object is a fixed obstacle."},
+               {OB_FLUIDSIM_INFLOW, "INFLOW", 0, "Inflow", "Object adds fluid to the simulation."},
+               {OB_FLUIDSIM_OUTFLOW, "OUTFLOW", 0, "Outflow", "Object removes fluid from the simulation."},
+               {OB_FLUIDSIM_PARTICLE, "PARTICLE", 0, "Particle", "Object is made a particle system to display particles generated by a fluidsim domain object."},
+               {OB_FLUIDSIM_CONTROL, "CONTROL", 0, "Control", "Object is made a fluid control mesh, which influences the fluid."},
+               {0, NULL, 0, NULL, NULL}};
 
 
        srna= RNA_def_struct(brna, "FluidSettings", NULL);
index 8620a93..e045c76 100644 (file)
 #include "DNA_image_types.h"
 #include "DNA_scene_types.h"
 
+#include "BKE_context.h"
 #include "BKE_image.h"
 
 #ifdef RNA_RUNTIME
 
+static void rna_Image_animated_update(bContext *C, PointerRNA *ptr)
+{
+       Image *ima= (Image*)ptr->data;
+       int  nr;
+
+       if(ima->flag & IMA_TWINANIM) {
+               nr= ima->xrep*ima->yrep;
+               if(ima->twsta>=nr) ima->twsta= 1;
+               if(ima->twend>=nr) ima->twend= nr-1;
+               if(ima->twsta>ima->twend) ima->twsta= 1;
+       }
+}
+
 #else
 
 static void rna_def_imageuser(BlenderRNA *brna)
@@ -89,27 +103,27 @@ static void rna_def_image(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static const EnumPropertyItem prop_type_items[]= {
-               {IMA_TYPE_IMAGE, "IMAGE", "Image", ""},
-               {IMA_TYPE_MULTILAYER, "MULTILAYER", "Multilayer", ""},
-               {IMA_TYPE_UV_TEST, "UVTEST", "UV Test", ""},
-               {IMA_TYPE_R_RESULT, "RENDERRESULT", "Render Result", ""},
-               {IMA_TYPE_COMPOSITE, "COMPOSITING", "Compositing", ""},
-               {0, NULL, NULL, NULL}};
+               {IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
+               {IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
+               {IMA_TYPE_UV_TEST, "UVTEST", 0, "UV Test", ""},
+               {IMA_TYPE_R_RESULT, "RENDERRESULT", 0, "Render Result", ""},
+               {IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
+               {0, NULL, 0, NULL, NULL}};
        static const EnumPropertyItem prop_source_items[]= {
-               {IMA_SRC_FILE, "FILE", "File", "Single image file"},
-               {IMA_SRC_SEQUENCE, "SEQUENCE", "Sequence", "Multiple image files, as a sequence"},
-               {IMA_SRC_MOVIE, "MOVIE", "Movie", "Movie file"},
-               {IMA_SRC_GENERATED, "GENERATED", "Generated", "Generated image"},
-               {IMA_SRC_VIEWER, "VIEWER", "Viewer", "Compositing node viewer"},
-               {0, NULL, NULL, NULL}};
+               {IMA_SRC_FILE, "FILE", 0, "File", "Single image file"},
+               {IMA_SRC_SEQUENCE, "SEQUENCE", 0, "Sequence", "Multiple image files, as a sequence"},
+               {IMA_SRC_MOVIE, "MOVIE", 0, "Movie", "Movie file"},
+               {IMA_SRC_GENERATED, "GENERATED", 0, "Generated", "Generated image"},
+               {IMA_SRC_VIEWER, "VIEWER", 0, "Viewer", "Compositing node viewer"},
+               {0, NULL, 0, NULL, NULL}};
        static const EnumPropertyItem prop_generated_type_items[]= {
-               {0, "BLANK", "Blank", "Generate a blank image"},
-               {1, "UVTESTGRID", "UV Test Grid", "Generated grid to test UV mappings"},
-               {0, NULL, NULL, NULL}};
+               {0, "BLANK", 0, "Blank", "Generate a blank image"},
+               {1, "UVTESTGRID", 0, "UV Test Grid", "Generated grid to test UV mappings"},
+               {0, NULL, 0, NULL, NULL}};
        static const EnumPropertyItem prop_mapping_items[]= {
-               {0, "UV", "UV Coordinates", "Use UV coordinates for mapping the image"},
-               {IMA_REFLECT, "REFLECTION", "Reflection", "Use reflection mapping for mapping the image"},
-               {0, NULL, NULL, NULL}};
+               {0, "UV", 0, "UV Coordinates", "Use UV coordinates for mapping the image"},
+               {IMA_REFLECT, "REFLECTION", 0, "Reflection", "Use reflection mapping for mapping the image"},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Image", "ID");
        RNA_def_struct_ui_text(srna, "Image", "Image datablock referencing an external or packed image.");
@@ -180,19 +194,21 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Display Aspect", "Display Aspect for this image, does not affect rendering.");
 
        prop= RNA_def_property(srna, "animated", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* B_TWINANIM */
        RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TWINANIM);
        RNA_def_property_ui_text(prop, "Animated", "Use as animated texture in the game engine.");
+       RNA_def_property_update(prop, 0, "rna_Image_animated_update");
 
        prop= RNA_def_property(srna, "animation_start", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "twsta");
        RNA_def_property_range(prop, 0, 128);
        RNA_def_property_ui_text(prop, "Animation Start", "Start frame of an animated texture.");
+       RNA_def_property_update(prop, 0, "rna_Image_animated_update");
 
        prop= RNA_def_property(srna, "animation_end", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "twend");
        RNA_def_property_range(prop, 0, 128);
        RNA_def_property_ui_text(prop, "Animation End", "End frame of an animated texture.");
+       RNA_def_property_update(prop, 0, "rna_Image_animated_update");
 
        prop= RNA_def_property(srna, "animation_speed", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "animspeed");
@@ -200,8 +216,8 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Animation Speed", "Speed of the animation in frames per second.");
 
        prop= RNA_def_property(srna, "tiles", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* B_SIMAGETILE */
        RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TILES);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_tile_set */
        RNA_def_property_ui_text(prop, "Tiles", "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces).");
 
        prop= RNA_def_property(srna, "tiles_x", PROP_INT, PROP_NONE);
index d690251..3a5a4fa 100644 (file)
@@ -128,6 +128,8 @@ struct PropertyRNA {
        const char *name;
        /* single line description, displayed in the tooltip for example */
        const char *description;
+       /* icon ID */
+       int icon;
 
        /* property type as it appears to the outside */
        PropertyType type;
index ae03cca..896f660 100644 (file)
@@ -277,10 +277,10 @@ static void rna_def_keyblock(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_keyblock_type_items[] = {
-               {KEY_LINEAR, "KEY_LINEAR", "Linear", ""},
-               {KEY_CARDINAL, "KEY_CARDINAL", "Cardinal", ""},
-               {KEY_BSPLINE, "KEY_BSPLINE", "BSpline", ""},
-               {0, NULL, NULL, NULL}};
+               {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
+               {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
+               {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "ShapeKey", NULL);
        RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock.");
index 97ad5b7..092a580 100644 (file)
@@ -91,10 +91,10 @@ static void rna_def_lamp_mtex(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_texture_coordinates_items[] = {
-               {TEXCO_GLOB, "GLOBAL", "Global", "Uses global coordinates for the texture coordinates."},
-               {TEXCO_VIEW, "VIEW", "View", "Uses view coordinates for the texture coordinates."},
-               {TEXCO_OBJECT, "OBJECT", "Object", "Uses linked object's coordinates for texture coordinates."},
-               {0, NULL, NULL, NULL}};
+               {TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
+               {TEXCO_VIEW, "VIEW", 0, "View", "Uses view coordinates for the texture coordinates."},
+               {TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "LampTextureSlot", "TextureSlot");
        RNA_def_struct_sdna(srna, "MTex");
@@ -126,29 +126,29 @@ static void rna_def_lamp_sky_settings(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_skycolorspace_items[] = {
-               {0, "SMPTE", "SMPTE", ""},
-               {1, "REC709", "REC709", ""},
-               {2, "CIE", "CIE", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "SMPTE", 0, "SMPTE", ""},
+               {1, "REC709", 0, "REC709", ""},
+               {2, "CIE", 0, "CIE", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_blendmode_items[] = {
-               {0, "MIX", "Mix", ""},
-               {1, "ADD", "Add", ""},
-               {2, "MULTIPLY", "Multiply", ""},
-               {3, "SUBTRACT", "Subtract", ""},
-               {4, "SCREEN", "Screen", ""},
-               {5, "DIVIDE", "Divide", ""},
-               {6, "DIFFERENCE", "Difference", ""},
-               {7, "DARKEN", "Darken", ""},
-               {8, "LIGHTEN", "Lighten", ""},
-               {9, "OVERLAY", "Overlay", ""},
-               {10, "DODGE", "Dodge", ""},
-               {11, "BURN", "Burn", ""},
-               {12, "HUE", "Hue", ""},
-               {13, "SATURATION", "Saturation", ""},
-               {14, "VALUE", "Value", ""},
-               {15, "COLOR", "Color", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "MIX", 0, "Mix", ""},
+               {1, "ADD", 0, "Add", ""},
+               {2, "MULTIPLY", 0, "Multiply", ""},
+               {3, "SUBTRACT", 0, "Subtract", ""},
+               {4, "SCREEN", 0, "Screen", ""},
+               {5, "DIVIDE", 0, "Divide", ""},
+               {6, "DIFFERENCE", 0, "Difference", ""},
+               {7, "DARKEN", 0, "Darken", ""},
+               {8, "LIGHTEN", 0, "Lighten", ""},
+               {9, "OVERLAY", 0, "Overlay", ""},
+               {10, "DODGE", 0, "Dodge", ""},
+               {11, "BURN", 0, "Burn", ""},
+               {12, "HUE", 0, "Hue", ""},
+               {13, "SATURATION", 0, "Saturation", ""},
+               {14, "VALUE", 0, "Value", ""},
+               {15, "COLOR", 0, "Color", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        srna= RNA_def_struct(brna, "LampSkySettings", NULL);
        RNA_def_struct_sdna(srna, "Lamp");
@@ -253,12 +253,12 @@ static void rna_def_lamp(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_type_items[] = {
-               {LA_LOCAL, "POINT", "Point", "Omnidirectional point light source."},
-               {LA_SUN, "SUN", "Sun", "Constant direction parallel ray light source."},
-               {LA_SPOT, "SPOT", "Spot", "Directional cone light source."},
-               {LA_HEMI, "HEMI", "Hemi", "180 degree constant light source."},
-               {LA_AREA, "AREA", "Area", "Directional area light source."},
-               {0, NULL, NULL, NULL}};
+               {LA_LOCAL, "POINT", 0, "Point", "Omnidirectional point light source."},
+               {LA_SUN, "SUN", 0, "Sun", "Constant direction parallel ray light source."},
+               {LA_SPOT, "SPOT", 0, "Spot", "Directional cone light source."},
+               {LA_HEMI, "HEMI", 0, "Hemi", "180 degree constant light source."},
+               {LA_AREA, "AREA", 0, "Area", "Directional area light source."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Lamp", "ID");
        RNA_def_struct_refine_func(srna, "rna_Lamp_refine");
@@ -322,12 +322,12 @@ static void rna_def_lamp_falloff(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_fallofftype_items[] = {
-               {LA_FALLOFF_CONSTANT, "CONSTANT", "Constant", ""},
-               {LA_FALLOFF_INVLINEAR, "INVERSE_LINEAR", "Inverse Linear", ""},
-               {LA_FALLOFF_INVSQUARE, "INVERSE_SQUARE", "Inverse Square", ""},
-               {LA_FALLOFF_CURVE, "CUSTOM_CURVE", "Custom Curve", ""},
-               {LA_FALLOFF_SLIDERS, "LINEAR_QUADRATIC_WEIGHTED", "Lin/Quad Weighted", ""},
-               {0, NULL, NULL, NULL}};
+               {LA_FALLOFF_CONSTANT, "CONSTANT", 0, "Constant", ""},
+               {LA_FALLOFF_INVLINEAR, "INVERSE_LINEAR", 0, "Inverse Linear", ""},
+               {LA_FALLOFF_INVSQUARE, "INVERSE_SQUARE", 0, "Inverse Square", ""},
+               {LA_FALLOFF_CURVE, "CUSTOM_CURVE", 0, "Custom Curve", ""},
+               {LA_FALLOFF_SLIDERS, "LINEAR_QUADRATIC_WEIGHTED", 0, "Lin/Quad Weighted", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        prop= RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, prop_fallofftype_items);
@@ -362,26 +362,26 @@ static void rna_def_lamp_shadow(StructRNA *srna, int spot, int area)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_shadow_items[] = {
-               {0, "NOSHADOW", "No Shadow", ""},
-               {LA_SHAD_RAY, "RAY_SHADOW", "Ray Shadow", "Use ray tracing for shadow."},
-               {0, NULL, NULL, NULL}};
+               {0, "NOSHADOW", 0, "No Shadow", ""},
+               {LA_SHAD_RAY, "RAY_SHADOW", 0, "Ray Shadow", "Use ray tracing for shadow."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_spot_shadow_items[] = {
-               {0, "NOSHADOW", "No Shadow", ""},
-               {LA_SHAD_BUF, "BUFFER_SHADOW", "Buffer Shadow", "Lets spotlight produce shadows using shadow buffer."},
-               {LA_SHAD_RAY, "RAY_SHADOW", "Ray Shadow", "Use ray tracing for shadow."},
-               {0, NULL, NULL, NULL}};
+               {0, "NOSHADOW", 0, "No Shadow", ""},
+               {LA_SHAD_BUF, "BUFFER_SHADOW", 0, "Buffer Shadow", "Lets spotlight produce shadows using shadow buffer."},
+               {LA_SHAD_RAY, "RAY_SHADOW", 0, "Ray Shadow", "Use ray tracing for shadow."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_ray_sampling_method_items[] = {
-               {LA_SAMP_HALTON, "ADAPTIVE_QMC", "Adaptive QMC", ""},
-               {LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", "Constant QMC", ""},
-               {0, NULL, NULL, NULL}};
+               {LA_SAMP_HALTON, "ADAPTIVE_QMC", 0, "Adaptive QMC", ""},
+               {LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", 0, "Constant QMC", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        static EnumPropertyItem prop_spot_ray_sampling_method_items[] = {
-               {LA_SAMP_HALTON, "ADAPTIVE_QMC", "Adaptive QMC", ""},
-               {LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", "Constant QMC", ""},
-               {LA_SAMP_CONSTANT, "CONSTANT_JITTERED", "Constant Jittered", ""},
-               {0, NULL, NULL, NULL}};
+               {LA_SAMP_HALTON, "ADAPTIVE_QMC", 0, "Adaptive QMC", ""},
+               {LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", 0, "Constant QMC", ""},
+               {LA_SAMP_CONSTANT, "CONSTANT_JITTERED", 0, "Constant Jittered", ""},
+               {0, NULL, 0, NULL, NULL}};
 
 
        prop= RNA_def_property(srna, "shadow_method", PROP_ENUM, PROP_NONE);
@@ -457,9 +457,9 @@ static void rna_def_area_lamp(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_areashape_items[] = {
-               {LA_AREA_SQUARE, "SQUARE", "Square", ""},
-               {LA_AREA_RECT, "RECTANGLE", "Rectangle", ""},
-               {0, NULL, NULL, NULL}};
+               {LA_AREA_SQUARE, "SQUARE", 0, "Square", ""},
+               {LA_AREA_RECT, "RECTANGLE", 0, "Rectangle", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "AreaLamp", "Lamp");
        RNA_def_struct_sdna(srna, "Lamp");
@@ -513,22 +513,22 @@ static void rna_def_spot_lamp(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_shadbuftype_items[] = {
-               {LA_SHADBUF_REGULAR     , "REGULAR", "Classical", "Classic shadow buffer."},
-               {LA_SHADBUF_HALFWAY, "HALFWAY", "Classic-Halfway", "Regular buffer, averaging the closest and 2nd closest Z value to reducing bias artifaces."},
-               {LA_SHADBUF_IRREGULAR, "IRREGULAR", "Irregular", "Irregular buffer produces sharp shadow always, but it doesn't show up for raytracing."},
-               {0, NULL, NULL, NULL}};
+               {LA_SHADBUF_REGULAR     , "REGULAR", 0, "Classical", "Classic shadow buffer."},
+               {LA_SHADBUF_HALFWAY, "HALFWAY", 0, "Classic-Halfway", "Regular buffer, averaging the closest and 2nd closest Z value to reducing bias artifaces."},
+               {LA_SHADBUF_IRREGULAR, "IRREGULAR", 0, "Irregular", "Irregular buffer produces sharp shadow always, but it doesn't show up for raytracing."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_shadbuffiltertype_items[] = {
-               {LA_SHADBUF_BOX , "BOX", "Box", "Apply the Box filter to shadow buffer samples."},
-               {LA_SHADBUF_TENT, "TENT", "Tent", "Apply the Tent Filter to shadow buffer samples."},
-               {LA_SHADBUF_GAUSS, "GAUSS", "Gauss", "Apply the Gauss filter to shadow buffer samples."},
-               {0, NULL, NULL, NULL}};
+               {LA_SHADBUF_BOX , "BOX", 0, "Box", "Apply the Box filter to shadow buffer samples."},
+               {LA_SHADBUF_TENT, "TENT", 0, "Tent", "Apply the Tent Filter to shadow buffer samples."},
+               {LA_SHADBUF_GAUSS, "GAUSS", 0, "Gauss", "Apply the Gauss filter to shadow buffer samples."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_numbuffer_items[] = {
-               {1, "BUFFERS_1", "1", "Only one buffer rendered."},
-               {4, "BUFFERS_4", "4", "Renders 4 buffers for better AA, this quadruples memory usage."},
-               {9, "BUFFERS_9", "9", "Renders 9 buffers for better AA, this uses nine times more memory."},
-               {0, NULL, NULL, NULL}};
+               {1, "BUFFERS_1", 0, "1", "Only one buffer rendered."},
+               {4, "BUFFERS_4", 0, "4", "Renders 4 buffers for better AA, this quadruples memory usage."},
+               {9, "BUFFERS_9", 0, "9", "Renders 9 buffers for better AA, this uses nine times more memory."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "SpotLamp", "Lamp");
        RNA_def_struct_sdna(srna, "Lamp");
index 26c4ebb..0e341fc 100644 (file)
@@ -110,10 +110,10 @@ static void rna_def_lattice(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_keyblock_type_items[] = {
-               {KEY_LINEAR, "KEY_LINEAR", "Linear", ""},
-               {KEY_CARDINAL, "KEY_CARDINAL", "Cardinal", ""},
-               {KEY_BSPLINE, "KEY_BSPLINE", "BSpline", ""},
-               {0, NULL, NULL, NULL}};
+               {KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
+               {KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
+               {KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Lattice", "ID");
        RNA_def_struct_ui_text(srna, "Lattice", "Lattice datablock defining a grid for deforming other objects.");
index 3facfab..1c16e79 100644 (file)
@@ -112,6 +112,35 @@ static void rna_MaterialStrand_end_size_range(PointerRNA *ptr, float *min, float
        }
 }
 
+static int rna_MaterialTextureSlot_enabled_get(PointerRNA *ptr)
+{
+       Material *ma= (Material*)ptr->id.data;
+       MTex *mtex= (MTex*)ptr->data;
+       int a;
+
+       for(a=0; a<MAX_MTEX; a++)
+               if(ma->mtex[a] == mtex)
+                       return (ma->septex & (1<<a)) == 0;
+       
+       return 0;
+}
+
+static void rna_MaterialTextureSlot_enabled_set(PointerRNA *ptr, int value)
+{
+       Material *ma= (Material*)ptr->id.data;
+       MTex *mtex= (MTex*)ptr->data;
+       int a;
+
+       for(a=0; a<MAX_MTEX; a++) {
+               if(ma->mtex[a] == mtex) {
+                       if(value)
+                               ma->septex &= ~(1<<a);
+                       else
+                               ma->septex |= (1<<a);
+               }
+       }
+}
+
 #else
 
 static void rna_def_material_mtex(BlenderRNA *brna)
@@ -120,54 +149,54 @@ static void rna_def_material_mtex(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_texture_coordinates_items[] = {
-               {TEXCO_GLOB, "GLOBAL", "Global", "Uses global coordinates for the texture coordinates."},
-               {TEXCO_OBJECT, "OBJECT", "Object", "Uses linked object's coordinates for texture coordinates."},
-               {TEXCO_UV, "UV", "UV", "Uses UV coordinates for texture coordinates."},
-               {TEXCO_ORCO, "ORCO", "Generated", "Uses the original undeformed coordinates of the object."},
-               {TEXCO_STRAND, "STRAND", "Strand", "Uses normalized strand texture coordinate (1D)."},
-               {TEXCO_STICKY, "STICKY", "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
-               {TEXCO_WINDOW, "WINDOW", "Window", "Uses screen coordinates as texture coordinates."},
-               {TEXCO_NORM, "NORMAL", "Normal", "Uses normal vector as texture coordinates."},
-               {TEXCO_REFL, "REFLECTION", "Reflection", "Uses reflection vector as texture coordinates."},
-               {TEXCO_STRESS, "STRESS", "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
-               {TEXCO_SPEED, "TANGENT", "Tangent", "Uses the optional tangent vector as texture coordinates."},
-
-               {0, NULL, NULL, NULL}};
+               {TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
+               {TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
+               {TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates."},
+               {TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object."},
+               {TEXCO_STRAND, "STRAND", 0, "Strand", "Uses normalized strand texture coordinate (1D)."},
+               {TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
+               {TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates."},
+               {TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates."},
+               {TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates."},
+               {TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
+               {TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates."},
+
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_mapping_items[] = {
-               {MTEX_FLAT, "FLAT", "Flat", "Maps X and Y coordinates directly."},
-               {MTEX_CUBE, "CUBE", "Cube", "Maps using the normal vector."},
-               {MTEX_TUBE, "TUBE", "Tube", "Maps with Z as central axis."},
-               {MTEX_SPHERE, "SPHERE", "Sphere", "Maps with Z as central axis."},
-               {0, NULL, NULL, NULL}};
+               {MTEX_FLAT, "FLAT", 0, "Flat", "Maps X and Y coordinates directly."},
+               {MTEX_CUBE, "CUBE", 0, "Cube", "Maps using the normal vector."},
+               {MTEX_TUBE, "TUBE", 0, "Tube", "Maps with Z as central axis."},
+               {MTEX_SPHERE, "SPHERE", 0, "Sphere", "Maps with Z as central axis."},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_x_mapping_items[] = {
-               {0, "NONE", "None", ""},
-               {1, "X", "X", ""},
-               {2, "Y", "Y", ""},
-               {3, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {1, "X", 0, "X", ""},
+               {2, "Y", 0, "Y", ""},
+               {3, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_y_mapping_items[] = {
-               {0, "NONE", "None", ""},
-               {1, "X", "X", ""},
-               {2, "Y", "Y", ""},
-               {3, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {1, "X", 0, "X", ""},
+               {2, "Y", 0, "Y", ""},
+               {3, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_z_mapping_items[] = {
-               {0, "NONE", "None", ""},
-               {1, "X", "X", ""},
-               {2, "Y", "Y", ""},
-               {3, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {1, "X", 0, "X", ""},
+               {2, "Y", 0, "Y", ""},
+               {3, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_normal_map_space_items[] = {
-               {MTEX_NSPACE_CAMERA, "CAMERA", "Camera", ""},
-               {MTEX_NSPACE_WORLD, "WORLD", "World", ""},
-               {MTEX_NSPACE_OBJECT, "OBJECT", "Object", ""},
-               {MTEX_NSPACE_TANGENT, "TANGENT", "Tangent", ""},
-               {0, NULL, NULL, NULL}};
+               {MTEX_NSPACE_CAMERA, "CAMERA", 0, "Camera", ""},
+               {MTEX_NSPACE_WORLD, "WORLD", 0, "World", ""},
+               {MTEX_NSPACE_OBJECT, "OBJECT", 0, "Object", ""},
+               {MTEX_NSPACE_TANGENT, "TANGENT", 0, "Tangent", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "MaterialTextureSlot", "TextureSlot");
        RNA_def_struct_sdna(srna, "MTex");
@@ -287,6 +316,12 @@ static void rna_def_material_mtex(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "warpfac");
        RNA_def_property_range(prop, 0, 1);
        RNA_def_property_ui_text(prop, "Warp Factor", "Amount texture affects color values.");
+
+       prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_MaterialTextureSlot_enabled_get", "rna_MaterialTextureSlot_enabled_set");
+       RNA_def_property_ui_text(prop, "Enabled", "Enable this material texture slot.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
+
 }
 
 static void rna_def_material_colors(StructRNA *srna)
@@ -333,12 +368,12 @@ static void rna_def_material_diffuse(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_diff_shader_items[] = {
-               {MA_DIFF_LAMBERT, "LAMBERT", "Lambert", ""},
-               {MA_DIFF_ORENNAYAR, "OREN_NAYAR", "Oren-Nayar", ""},
-               {MA_DIFF_TOON, "TOON", "Toon", ""},
-               {MA_DIFF_MINNAERT, "MINNAERT", "Minnaert", ""},
-               {MA_DIFF_FRESNEL, "FRESNEL", "Fresnel", ""},
-               {0, NULL, NULL, NULL}};
+               {MA_DIFF_LAMBERT, "LAMBERT", 0, "Lambert", ""},
+               {MA_DIFF_ORENNAYAR, "OREN_NAYAR", 0, "Oren-Nayar", ""},
+               {MA_DIFF_TOON, "TOON", 0, "Toon", ""},
+               {MA_DIFF_MINNAERT, "MINNAERT", 0, "Minnaert", ""},
+               {MA_DIFF_FRESNEL, "FRESNEL", 0, "Fresnel", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        prop= RNA_def_property(srna, "diffuse_shader", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "diff_shader");
@@ -356,12 +391,29 @@ static void rna_def_material_diffuse(StructRNA *srna)
        RNA_def_property_range(prop, 0.0f, 3.14f);
        RNA_def_property_ui_text(prop, "Roughness", "Oren-Nayar Roughness");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
-       
-       prop= RNA_def_property(srna, "params1_4", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_sdna(prop, NULL, "param");
-       RNA_def_property_array(prop, 4);
+
+       prop= RNA_def_property(srna, "diffuse_toon_size", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[0]");
+       RNA_def_property_range(prop, 0.0f, 3.14f);
+       RNA_def_property_ui_text(prop, "Diffuse Toon Size", "Size of diffuse toon area.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
+
+       prop= RNA_def_property(srna, "diffuse_toon_smooth", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[1]");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Diffuse Toon Smooth", "Smoothness of diffuse toon area.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
+
+       prop= RNA_def_property(srna, "diffuse_fresnel", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[1]");
        RNA_def_property_range(prop, 0.0f, 5.0f);
-       RNA_def_property_ui_text(prop, "Params 1-4", "Parameters used for diffuse and specular Toon, and diffuse Fresnel shaders. Check documentation for details.");
+       RNA_def_property_ui_text(prop, "Diffuse Fresnel", "Power of Fresnel.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
+
+       prop= RNA_def_property(srna, "diffuse_fresnel_factor", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[0]");
+       RNA_def_property_range(prop, 0.0f, 5.0f);
+       RNA_def_property_ui_text(prop, "Diffuse Fresnel Factor", "Blending factor of Frensel.");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
        
        prop= RNA_def_property(srna, "darkness", PROP_FLOAT, PROP_NONE);
@@ -376,9 +428,9 @@ static void rna_def_material_raymirror(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_fadeto_mir_items[] = {
-               {MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", "Fade to Sky Color", ""},
-               {MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", "Fade to Material Color", ""},
-               {0, NULL, NULL, NULL}};
+               {MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", 0, "Fade to Sky Color", ""},
+               {MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", 0, "Fade to Material Color", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "MaterialRaytraceMirror", NULL);
        RNA_def_struct_sdna(srna, "Material");
@@ -736,12 +788,12 @@ void rna_def_material_specularity(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_spec_shader_items[] = {
-               {MA_SPEC_COOKTORR, "COOKTORR", "CookTorr", ""},
-               {MA_SPEC_PHONG, "PHONG", "Phong", ""},
-               {MA_SPEC_BLINN, "BLINN", "Blinn", ""},
-               {MA_SPEC_TOON, "TOON", "Toon", ""},
-               {MA_SPEC_WARDISO, "WARDISO", "WardIso", ""},
-               {0, NULL, NULL, NULL}};
+               {MA_SPEC_COOKTORR, "COOKTORR", 0, "CookTorr", ""},
+               {MA_SPEC_PHONG, "PHONG", 0, "Phong", ""},
+               {MA_SPEC_BLINN, "BLINN", 0, "Blinn", ""},
+               {MA_SPEC_TOON, "TOON", 0, "Toon", ""},
+               {MA_SPEC_WARDISO, "WARDISO", 0, "WardIso", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        prop= RNA_def_property(srna, "spec_shader", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "spec_shader");
@@ -749,27 +801,40 @@ void rna_def_material_specularity(StructRNA *srna)
        RNA_def_property_ui_text(prop, "Specular Shader Model", "");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
        
-       prop= RNA_def_property(srna, "specularity", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "specular_reflection", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "spec");
        RNA_def_property_range(prop, 0, 1);
        RNA_def_property_ui_text(prop, "Specularity Intensity", "");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
-       /* XXX: this field is also used for Halo hardness. should probably be fixed in DNA */
-       /* I guess it's fine. Specular is disabled when mat type is Halo. --DingTo */
+       /* NOTE: "har", "param", etc are used for multiple purposes depending on
+        * settings. This should be fixed in DNA once, for RNA we just expose them
+        * multiple times, which may give somewhat strange changes in the outliner,
+        * but in the UI they are never visible at the same time. */
+
        prop= RNA_def_property(srna, "specular_hardness", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "har");
        RNA_def_property_range(prop, 1, 511);
        RNA_def_property_ui_text(prop, "Specular Hardness", "");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
-       prop= RNA_def_property(srna, "specular_refraction", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "specular_ior", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "refrac");
        RNA_def_property_range(prop, 1, 10);
        RNA_def_property_ui_text(prop, "Specular IOR", "");
        RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
-       /* XXX: evil "param" field also does specular stuff */
+       prop= RNA_def_property(srna, "specular_toon_size", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[2]");
+       RNA_def_property_range(prop, 0.0f, 1.53f);
+       RNA_def_property_ui_text(prop, "Specular Toon Size", "Size of specular toon area.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
+
+       prop= RNA_def_property(srna, "specular_toon_smooth", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "param[3]");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Specular Toon Smooth", "Ssmoothness of specular toon area.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
        prop= RNA_def_property(srna, "specular_slope", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rms");
@@ -851,10 +916,10 @@ void RNA_def_material(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_type_items[] = {
-               {MA_TYPE_SURFACE, "SURFACE", "Surface", "Render object as a surface."},
-               {MA_TYPE_VOLUME, "VOLUME", "Volume", "Render object as a volume."},
-               {MA_TYPE_HALO, "HALO", "Halo", "Render object as halo particles."},
-               {0, NULL, NULL, NULL}};
+               {MA_TYPE_SURFACE, "SURFACE", 0, "Surface", "Render object as a surface."},
+               {MA_TYPE_VOLUME, "VOLUME", 0, "Volume", "Render object as a volume."},
+               {MA_TYPE_HALO, "HALO", 0, "Halo", "Render object as halo particles."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Material", "ID");
        RNA_def_struct_ui_text(srna, "Material", "Material datablock to defined the appearance of geometric objects for rendering.");
@@ -876,6 +941,7 @@ void RNA_def_material(BlenderRNA *brna)
        prop= RNA_def_property(srna, "emit", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0, 2);
        RNA_def_property_ui_text(prop, "Emit", "Amount of light to emit.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
        prop= RNA_def_property(srna, "translucency", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0, 1);
@@ -885,10 +951,12 @@ void RNA_def_material(BlenderRNA *brna)
        prop= RNA_def_property(srna, "cubic", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_CUBIC);
        RNA_def_property_ui_text(prop, "Cubic Interpolation", "Use cubic interpolation for diffuse values, for smoother transitions.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
        
        prop= RNA_def_property(srna, "object_color", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_OBCOLOR);
        RNA_def_property_ui_text(prop, "Object Color", "Modulate the result with a per-object color.");
+       RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 
        prop= RNA_def_property(srna, "shadow_ray_bias", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sbias");
@@ -1054,8 +1122,6 @@ void RNA_def_material(BlenderRNA *brna)
        RNA_def_property_pointer_sdna(prop, NULL, "scriptlink");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Script Link", "Scripts linked to this material.");
-
-       /* XXX: does Material.septex get RNA? */
        
        rna_def_material_colors(srna);
        rna_def_material_diffuse(srna);
index e58b3c5..3499ee1 100644 (file)
@@ -734,11 +734,11 @@ static void rna_def_mtface(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static const EnumPropertyItem transp_items[]= {
-               {TF_SOLID, "OPAQUE", "Opaque", "Render color of textured face as color"},
-               {TF_ADD, "ADD", "Add", "Render face transparent and add color of face"},
-               {TF_ALPHA, "ALPHA", "Alpha", "Render polygon transparent, depending on alpha channel of the texture"},
-               {TF_CLIP, "CLIPALPHA", "Clip Alpha", "Use the images alpha values clipped with no blending (binary alpha)"},
-               {0, NULL, NULL, NULL}};
+               {TF_SOLID, "OPAQUE", 0, "Opaque", "Render color of textured face as color"},
+               {TF_ADD, "ADD", 0, "Add", "Render face transparent and add color of face"},
+               {TF_ALPHA, "ALPHA", 0, "Alpha", "Render polygon transparent, depending on alpha channel of the texture"},
+               {TF_CLIP, "CLIPALPHA", 0, "Clip Alpha", "Use the images alpha values clipped with no blending (binary alpha)"},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "MeshTextureFaceLayer", NULL);
        RNA_def_struct_ui_text(srna, "Mesh Texture Face Layer", "Layer of texture faces in a Mesh datablock.");
@@ -779,10 +779,6 @@ static void rna_def_mtface(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TEX);
        RNA_def_property_ui_text(prop, "Tex", "Render face with texture");
 
-       prop= RNA_def_property(srna, "tiles", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TILES);
-       RNA_def_property_ui_text(prop, "Tiles", "Use tilemode for face");
-
        prop= RNA_def_property(srna, "light", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_LIGHT);
        RNA_def_property_ui_text(prop, "Light", "Use light for face");
index 472e776..5f95336 100644 (file)
@@ -47,12 +47,12 @@ void rna_def_metaelement(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem prop_type_items[] = {
-               {MB_BALL, "BALL", "Ball", ""},
-               {MB_TUBE, "TUBE", "Tube", ""},
-               {MB_PLANE, "PLANE", "Plane", ""},
-               {MB_ELIPSOID, "ELLIPSOID", "Ellipsoid", ""}, // NOTE: typo at original definition!
-               {MB_CUBE, "CUBE", "Cube", ""},
-               {0, NULL, NULL, NULL}};
+               {MB_BALL, "BALL", 0, "Ball", ""},
+               {MB_TUBE, "TUBE", 0, "Tube", ""},
+               {MB_PLANE, "PLANE", 0, "Plane", ""},
+               {MB_ELIPSOID, "ELLIPSOID", 0, "Ellipsoid", ""}, // NOTE: typo at original definition!
+               {MB_CUBE, "CUBE", 0, "Cube", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "MetaElement", NULL);
        RNA_def_struct_sdna(srna, "MetaElem");
@@ -105,11 +105,11 @@ void rna_def_metaball(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem prop_update_items[] = {
-               {MB_UPDATE_ALWAYS, "UPDATE_ALWAYS", "Always", "While editing, update metaball always."},
-               {MB_UPDATE_HALFRES, "HALFRES", "Half Resolution", "While editing, update metaball in half resolution."},
-               {MB_UPDATE_FAST, "FAST", "Fast", "While editing, update metaball without polygonization."},
-               {MB_UPDATE_NEVER, "NEVER", "Never", "While editing, don't update metaball at all."},
-               {0, NULL, NULL, NULL}};
+               {MB_UPDATE_ALWAYS, "UPDATE_ALWAYS", 0, "Always", "While editing, update metaball always."},
+               {MB_UPDATE_HALFRES, "HALFRES", 0, "Half Resolution", "While editing, update metaball in half resolution."},
+               {MB_UPDATE_FAST, "FAST", 0, "Fast", "While editing, update metaball without polygonization."},
+               {MB_UPDATE_NEVER, "NEVER", 0, "Never", "While editing, don't update metaball at all."},
+               {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "MetaBall", "ID");
        RNA_def_struct_ui_text(srna, "MetaBall", "Metaball datablock to defined blobby surfaces.");
index fe5bd6a..30f4936 100644 (file)
 #include "WM_types.h"
 
 EnumPropertyItem modifier_type_items[] ={
-       {eModifierType_Armature, "ARMATURE", "Armature", ""},
-       {eModifierType_Array, "ARRAY", "Array", ""},
-       {eModifierType_Bevel, "BEVEL", "Bevel", ""},
-       {eModifierType_Boolean, "BOOLEAN", "Boolean", ""},
-       {eModifierType_Build, "BUILD", "Build", ""},
-       {eModifierType_Cast, "CAST", "Cast", ""},
-       {eModifierType_Cloth, "CLOTH", "Cloth", ""},
-       {eModifierType_Collision, "COLLISION", "Collision", ""},
-       {eModifierType_Curve, "CURVE", "Curve", ""},
-       {eModifierType_Decimate, "DECIMATE", "Decimate", ""},
-       {eModifierType_Displace, "DISPLACE", "Displace", ""},
-       {eModifierType_EdgeSplit, "EDGE_SPLIT", "Edge Split", ""},
-       {eModifierType_Explode, "EXPLODE", "Explode", ""},
-       {eModifierType_Fluidsim, "FLUID_SIMULATION", "Fluid Simulation", ""},
-       {eModifierType_Hook, "HOOK", "Hook", ""},
-       {eModifierType_Lattice, "LATTICE", "Lattice", ""},
-       {eModifierType_Mask, "MASK", "Mask", ""},
-       {eModifierType_MeshDeform, "MESH_DEFORM", "Mesh Deform", ""},
-       {eModifierType_Mirror, "MIRROR", "Mirror", ""},
-       {eModifierType_Multires, "MULTIRES", "Multires", ""},
-       {eModifierType_ParticleInstance, "PARTICLE_INSTANCE", "Particle Instance", ""},
-       {eModifierType_ParticleSystem, "PARTICLE_SYSTEM", "Particle System", ""},
-       {eModifierType_Shrinkwrap, "SHRINKWRAP", "Shrinkwrap", ""},
-       {eModifierType_SimpleDeform, "SIMPLE_DEFORM", "Simple Deform", ""},
-       {eModifierType_Smooth, "SMOOTH", "Smooth", ""},
-       {eModifierType_Softbody, "SOFTBODY", "Softbody", ""},
-       {eModifierType_Subsurf, "SUBSURF", "Subsurf", ""},
-       {eModifierType_UVProject, "UV_PROJECT", "UV Project", ""},
-       {eModifierType_Wave, "WAVE", "Wave", ""},
-       {0, NULL, NULL, NULL}};
+       {eModifierType_Armature, "ARMATURE", 0, "Armature", ""},
+       {eModifierType_Array, "ARRAY", 0, "Array", ""},
+       {eModifierType_Bevel, "BEVEL", 0, "Bevel", ""},
+       {eModifierType_Boolean, "BOOLEAN", 0, "Boolean", ""},
+       {eModifierType_Build, "BUILD", 0, "Build", ""},
+       {eModifierType_Cast, "CAST", 0, "Cast", ""},
+       {eModifierType_Cloth, "CLOTH", 0, "Cloth", ""},
+       {eModifierType_Collision, "COLLISION", 0, "Collision", ""},
+       {eModifierType_Curve, "CURVE", 0, "Curve", ""},
+       {eModifierType_Decimate, "DECIMATE", 0, "Decimate", ""},
+       {eModifierType_Displace, "DISPLACE", 0, "Displace", ""},
+       {eModifierType_EdgeSplit, "EDGE_SPLIT", 0, "Edge Split", ""},
+       {eModifierType_Explode, "EXPLODE", 0, "Explode", ""},
+       {eModifierType_Fluidsim, "FLUID_SIMULATION", 0, "Fluid Simulation", ""},
+       {eModifierType_Hook, "HOOK", 0, "Hook", ""},
+       {eModifierType_Lattice, "LATTICE", 0, "Lattice", ""},
+       {eModifierType_Mask, "MASK", 0, "Mask", ""},
+       {eModifierType_MeshDeform, "MESH_DEFORM", 0, "Mesh Deform", ""},
+       {eModifierType_Mirror, "MIRROR", 0, "Mirror", ""},
+       {eModifierType_Multires, "MULTIRES", 0, "Multires", ""},
+       {eModifierType_ParticleInstance, "PARTICLE_INSTANCE", 0, "Particle Instance", ""},
+       {eModifierType_ParticleSystem, "PARTICLE_SYSTEM", 0, "Particle System", ""},
+       {eModifierType_Shrinkwrap, "SHRINKWRAP", 0, "Shrinkwrap", ""},
+       {eModifierType_SimpleDeform, "SIMPLE_DEFORM", 0, "Simple Deform", ""},
+       {eModifierType_Smooth, "SMOOTH", 0, "Smooth", ""},
+       {eModifierType_Softbody, "SOFTBODY", 0, "Softbody", ""},
+       {eModifierType_Subsurf, "SUBSURF", 0, "Subsurf", ""},
+       {eModifierType_UVProject, "UV_PROJECT", 0, "UV Project", ""},
+       {eModifierType_Wave, "WAVE", 0, "Wave", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 
 #ifdef RNA_RUNTIME
@@ -353,9 +353,9 @@ static void rna_ArrayModifier_curve_set(PointerRNA *ptr, PointerRNA value)
 static void rna_def_property_subdivision_common(StructRNA *srna, const char type[])
 {
        static EnumPropertyItem prop_subdivision_type_items[] = {
-               {0, "CATMULL_CLARK", "Catmull-Clark", ""},
-               {1, "SIMPLE", "Simple", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "CATMULL_CLARK", 0, "Catmull-Clark", ""},
+               {1, "SIMPLE", 0, "Simple", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        PropertyRNA *prop= RNA_def_property(srna, "subdivision_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, type);
@@ -448,13 +448,13 @@ static void rna_def_modifier_curve(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_deform_axis_items[] = {
-               {MOD_CURVE_POSX, "POS_X", "X", ""},
-               {MOD_CURVE_POSY, "POS_Y", "Y", ""},
-               {MOD_CURVE_POSZ, "POS_Z", "Z", ""},
-               {MOD_CURVE_NEGX, "NEG_X", "-X", ""},
-               {MOD_CURVE_NEGY, "NEG_Y", "-Y", ""},
-               {MOD_CURVE_NEGZ, "NEG_Z", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_CURVE_POSX, "POS_X", 0, "X", ""},
+               {MOD_CURVE_POSY, "POS_Y", 0, "Y", ""},
+               {MOD_CURVE_POSZ, "POS_Z", 0, "Z", ""},
+               {MOD_CURVE_NEGX, "NEG_X", 0, "-X", ""},
+               {MOD_CURVE_NEGY, "NEG_Y", 0, "-Y", ""},
+               {MOD_CURVE_NEGZ, "NEG_Z", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "CurveModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Curve Modifier", "Curve deformation modifier.");
@@ -597,11 +597,11 @@ static void rna_def_modifier_wave(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_texture_coordinates_items[] = {
-               {MOD_WAV_MAP_LOCAL, "LOCAL", "Local", ""},
-               {MOD_WAV_MAP_GLOBAL, "GLOBAL", "Global", ""},
-               {MOD_WAV_MAP_OBJECT, "OBJECT", "Object", ""},
-               {MOD_WAV_MAP_UV, "MAP_UV", "UV", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_WAV_MAP_LOCAL, "LOCAL", 0, "Local", ""},
+               {MOD_WAV_MAP_GLOBAL, "GLOBAL", 0, "Global", ""},
+               {MOD_WAV_MAP_OBJECT, "OBJECT", 0, "Object", ""},
+               {MOD_WAV_MAP_UV, "MAP_UV", 0, "UV", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "WaveModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Wave Modifier", "Wave effect modifier.");
@@ -844,10 +844,10 @@ static void rna_def_modifier_boolean(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_operation_items[] = {
-               {eBooleanModifierOp_Intersect, "INTERSECT", "Intersect", ""},
-               {eBooleanModifierOp_Union, "UNION", "Union", ""},
-               {eBooleanModifierOp_Difference, "DIFFERENCE", "Difference", ""},
-               {0, NULL, NULL, NULL}};
+               {eBooleanModifierOp_Intersect, "INTERSECT", 0, "Intersect", ""},
+               {eBooleanModifierOp_Union, "UNION", 0, "Union", ""},
+               {eBooleanModifierOp_Difference, "DIFFERENCE", 0, "Difference", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "BooleanModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Boolean Modifier", "Boolean operations modifier.");
@@ -872,10 +872,10 @@ static void rna_def_modifier_array(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_fit_type_items[] = {
-               {MOD_ARR_FIXEDCOUNT, "FIXED_COUNT", "Fixed Count", ""},
-               {MOD_ARR_FITLENGTH, "FIT_LENGTH", "Fit Length", ""},
-               {MOD_ARR_FITCURVE, "FIT_CURVE", "Fit Curve", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_ARR_FIXEDCOUNT, "FIXED_COUNT", 0, "Fixed Count", ""},
+               {MOD_ARR_FITLENGTH, "FIT_LENGTH", 0, "Fit Length", ""},
+               {MOD_ARR_FITCURVE, "FIT_CURVE", 0, "Fit Curve", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "ArrayModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Array Modifier", "Array duplication modifier.");
@@ -1005,19 +1005,19 @@ static void rna_def_modifier_displace(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_direction_items[] = {
-               {MOD_DISP_DIR_X, "X", "X", ""},
-               {MOD_DISP_DIR_Y, "Y", "Y", ""},
-               {MOD_DISP_DIR_Z, "Z", "Z", ""},
-               {MOD_DISP_DIR_NOR, "NORMAL", "Normal", ""},
-               {MOD_DISP_DIR_RGB_XYZ, "RGB_TO_XYZ", "RGB to XYZ", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_DISP_DIR_X, "X", 0, "X", ""},
+               {MOD_DISP_DIR_Y, "Y", 0, "Y", ""},
+               {MOD_DISP_DIR_Z, "Z", 0, "Z", ""},
+               {MOD_DISP_DIR_NOR, "NORMAL", 0, "Normal", ""},
+               {MOD_DISP_DIR_RGB_XYZ, "RGB_TO_XYZ", 0, "RGB to XYZ", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_texture_coordinates_items[] = {
-               {MOD_DISP_MAP_LOCAL, "LOCAL", "Map", ""},
-               {MOD_DISP_MAP_GLOBAL, "GLOBAL", "Global", ""},
-               {MOD_DISP_MAP_OBJECT, "OBJECT", "Object", ""},
-               {MOD_DISP_MAP_UV, "UV", "UV", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_DISP_MAP_LOCAL, "LOCAL", 0, "Map", ""},
+               {MOD_DISP_MAP_GLOBAL, "GLOBAL", 0, "Global", ""},
+               {MOD_DISP_MAP_OBJECT, "OBJECT", 0, "Object", ""},
+               {MOD_DISP_MAP_UV, "UV", 0, "UV", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "DisplaceModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Displace Modifier", "Displacement modifier.");
@@ -1167,10 +1167,10 @@ static void rna_def_modifier_cast(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_cast_type_items[] = {
-               {MOD_CAST_TYPE_SPHERE, "SPHERE", "Sphere", ""},
-               {MOD_CAST_TYPE_CYLINDER, "CYLINDER", "Cylinder", ""},
-               {MOD_CAST_TYPE_CUBOID, "CUBOID", "Cuboid", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_CAST_TYPE_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {MOD_CAST_TYPE_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
+               {MOD_CAST_TYPE_CUBOID, "CUBOID", 0, "Cuboid", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "CastModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Cast Modifier", "Cast modifier to cast to other shapes.");
@@ -1412,16 +1412,16 @@ static void rna_def_modifier_bevel(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_limit_method_items[] = {
-               {0, "NONE", "None", "Bevel the entire mesh by a constant amount."},
-               {BME_BEVEL_ANGLE, "ANGLE", "Angle", "Only bevel edges with sharp enough angles between faces."},
-               {BME_BEVEL_WEIGHT, "WEIGHT", "Weight", "Use bevel weights to determine how much bevel is applied; apply them separately in vert/edge select mode."},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", "Bevel the entire mesh by a constant amount."},
+               {BME_BEVEL_ANGLE, "ANGLE", 0, "Angle", "Only bevel edges with sharp enough angles between faces."},
+               {BME_BEVEL_WEIGHT, "WEIGHT", 0, "Weight", "Use bevel weights to determine how much bevel is applied; apply them separately in vert/edge select mode."},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem prop_edge_weight_method_items[] = {
-               {0, "AVERAGE", "Average", ""},
-               {BME_BEVEL_EMIN, "SHARPEST", "Sharpest", ""},
-               {BME_BEVEL_EMAX, "LARGEST", "Largest", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "AVERAGE", 0, "Average", ""},
+               {BME_BEVEL_EMIN, "SHARPEST", 0, "Sharpest", ""},
+               {BME_BEVEL_EMAX, "LARGEST", 0, "Largest", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "BevelModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Bevel Modifier", "Bevel modifier to make edges and vertices more rounded.");
@@ -1465,10 +1465,10 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_mode_items[] = {
-               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACEPOINT", "Nearest Surface Point", ""},
-               {MOD_SHRINKWRAP_PROJECT, "PROJECT", "Project", ""},
-               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", "Nearest Vertex", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACEPOINT", 0, "Nearest Surface Point", ""},
+               {MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project", ""},
+               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "ShrinkwrapModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Shrinkwrap Modifier", "Shrink wrapping modifier to shrink wrap and object to a target.");
@@ -1576,9 +1576,9 @@ static void rna_def_modifier_mask(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_mode_items[] = {
-               {MOD_MASK_MODE_VGROUP, "VERTEX_GROUP", "Vertex Group", ""},
-               {MOD_MASK_MODE_ARM, "ARMATURE", "Armature", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_MASK_MODE_VGROUP, "VERTEX_GROUP", 0, "Vertex Group", ""},
+               {MOD_MASK_MODE_ARM, "ARMATURE", 0, "Armature", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "MaskModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "Mask Modifier", "Mask modifier to hide parts of the mesh.");
@@ -1615,11 +1615,11 @@ static void rna_def_modifier_simpledeform(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem prop_mode_items[] = {
-               {MOD_SIMPLEDEFORM_MODE_TWIST, "TWIST", "Twist", ""},
-               {MOD_SIMPLEDEFORM_MODE_BEND, "BEND", "Bend", ""},
-               {MOD_SIMPLEDEFORM_MODE_TAPER, "TAPER", "Taper", ""},
-               {MOD_SIMPLEDEFORM_MODE_STRETCH, "STRETCH", "Stretch", ""},
-               {0, NULL, NULL, NULL}};
+               {MOD_SIMPLEDEFORM_MODE_TWIST, "TWIST", 0, "Twist", ""},
+               {MOD_SIMPLEDEFORM_MODE_BEND, "BEND", 0, "Bend", ""},
+               {MOD_SIMPLEDEFORM_MODE_TAPER, "TAPER", 0, "Taper", ""},
+               {MOD_SIMPLEDEFORM_MODE_STRETCH, "STRETCH", 0, "Stretch", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "SimpleDeformModifier", "Modifier");
        RNA_def_struct_ui_text(srna, "SimpleDeform Modifier", "Simple deformation modifier to apply effects such as twisting and bending.");
index 8a90af6..b35b02b 100644 (file)
@@ -76,6 +76,7 @@ typedef struct NodeInfo
        const char *enum_name;
        const char *struct_name;
        const char *base_name;
+       int icon;
        const char *ui_name;
        const char *ui_desc;
 } NodeInfo;
@@ -146,6 +147,7 @@ static EnumPropertyItem* alloc_node_type_items(int category)
                if(node->defined && node->category == category) {
                        item->value = i;
                        item->identifier = node->enum_name;
+                       item->icon = node->icon;
                        item->name = node->ui_name;
                        item->description = node->ui_desc;
                
@@ -173,25 +175,25 @@ static void def_math(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem items[] = {
-               { 0, "ADD",          "Add",          ""},
-               { 1, "SUBTRACT",     "Subtract",     ""},
-               { 2, "MULTIPLY",     "Multiply",     ""},
-               { 3, "DIVIDE",       "Divide",       ""},
-               { 4, "SINE",         "Sine",         ""},
-               { 5, "COSINE",       "Cosine",       ""},
-               { 6, "TANGENT",      "Tangent",      ""},
-               { 7, "ARCSINE",      "Arcsine",      ""},
-               { 8, "ARCCOSINE",    "Arccosine",    ""},
-               { 9, "ARCTANGENT",   "Arctangent",   ""},
-               {10, "POWER",        "Power",        ""},
-               {11, "LOGARITHM",    "Logarithm",    ""},
-               {12, "MINIMUM",      "Minimum",      ""},
-               {13, "MAXIMUM",      "Maximum",      ""},
-               {14, "ROUND",        "Round",        ""},
-               {15, "LESS_THAN",    "Less Than",    ""},
-               {16, "GREATER_THAN", "Greater Than", ""},
+               { 0, "ADD",          0, "Add",          ""},
+               { 1, "SUBTRACT",     0, "Subtract",     ""},
+               { 2, "MULTIPLY",     0, "Multiply",     ""},
+               { 3, "DIVIDE",       0, "Divide",       ""},
+               { 4, "SINE",         0, "Sine",         ""},
+               { 5, "COSINE",       0, "Cosine",       ""},
+               { 6, "TANGENT",      0, "Tangent",      ""},
+               { 7, "ARCSINE",      0, "Arcsine",      ""},
+               { 8, "ARCCOSINE",    0, "Arccosine",    ""},
+               { 9, "ARCTANGENT",   0, "Arctangent",   ""},
+               {10, "POWER",        0, "Power",        ""},
+               {11, "LOGARITHM",    0, "Logarithm",    ""},
+               {12, "MINIMUM",      0, "Minimum",      ""},
+               {13, "MAXIMUM",      0, "Maximum",      ""},
+               {14, "ROUND",        0, "Round",        ""},
+               {15, "LESS_THAN",    0, "Less Than",    ""},
+               {16, "GREATER_THAN", 0, "Greater Than", ""},
                
-               {0, NULL, NULL, NULL}
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@@ -205,14 +207,14 @@ static void def_vector_math(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem items[] = {
-               {0, "ADD",           "Add",           ""},
-               {1, "SUBTRACT",      "Subtract",      ""},
-               {2, "AVERAGE",       "Average",       ""},
-               {3, "DOT_PRODUCT",   "Dot Product",   ""},
-               {4, "CROSS_PRODUCT", "Cross Product", ""},
-               {5, "NORMALIZE",     "Normalize",     ""},
+               {0, "ADD",           0, "Add",           ""},
+               {1, "SUBTRACT",      0, "Subtract",      ""},
+               {2, "AVERAGE",       0, "Average",       ""},
+               {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
+               {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
+               {5, "NORMALIZE",     0, "Normalize",     ""},
                
-               {0, NULL, NULL, NULL}
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@@ -275,23 +277,23 @@ static void def_mix_rgb(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem blend_type_items[] = {
-               { 0, "MIX",        "Mix",         ""},
-               { 1, "ADD",        "Add",         ""},
-               { 3, "SUBTRACT",   "Subtract",    ""},
-               { 2, "MULTIPLY",   "Multiply",    ""},
-               { 4, "SCREEN",     "Screen",      ""},
-               { 9, "OVERLAY",    "Overlay",     ""},
-               { 5, "DIVIDE",     "Divide",      ""},
-               { 6, "DIFFERENCE", "Difference",  ""},
-               { 7, "DARKEN",     "Darken",      ""},
-               { 8, "LIGHTEN",    "Lighten",     ""},
-               {10, "DODGE",      "Dodge",       ""},
-               {11, "BURN",       "Burn",        ""},
-               {15, "COLOR",      "Color",       ""},
-               {14, "VALUE",      "Value",       ""},
-               {13, "SATURATION", "Saturation",  ""},
-               {12, "HUE",        "Hue",         ""},
-               {0, NULL, NULL, NULL}
+               { 0, "MIX",        0, "Mix",         ""},
+               { 1, "ADD",        0, "Add",         ""},
+               { 3, "SUBTRACT",   0, "Subtract",    ""},
+               { 2, "MULTIPLY",   0, "Multiply",    ""},
+               { 4, "SCREEN",     0, "Screen",      ""},
+               { 9, "OVERLAY",    0, "Overlay",     ""},
+               { 5, "DIVIDE",     0, "Divide",      ""},
+               { 6, "DIFFERENCE", 0, "Difference",  ""},
+               { 7, "DARKEN",     0, "Darken",      ""},
+               { 8, "LIGHTEN",    0, "Lighten",     ""},
+               {10, "DODGE",      0, "Dodge",       ""},
+               {11, "BURN",       0, "Burn",        ""},
+               {15, "COLOR",      0, "Color",       ""},
+               {14, "VALUE",      0, "Value",       ""},
+               {13, "SATURATION", 0, "Saturation",  ""},
+               {12, "HUE",        0, "Hue",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
@@ -393,15 +395,15 @@ static void def_cmp_blur(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem filter_type_items[] = {
-               {R_FILTER_BOX,        "FLAT",       "Flat",          ""},
-               {R_FILTER_TENT,       "TENT",       "Tent",          ""},
-               {R_FILTER_QUAD,       "QUAD",       "Quadratic",     ""},
-               {R_FILTER_CUBIC,      "CUBIC",      "Cubic",         ""},
-               {R_FILTER_GAUSS,      "GAUSS",      "Gaussian",      ""},
-               {R_FILTER_FAST_GAUSS, "FAST_GAUSS", "Fast Gaussian", ""},
-               {R_FILTER_CATROM,     "CATROM",     "Catrom",        ""},
-               {R_FILTER_MITCH,      "MITCH",      "Mitch",         ""},
-               {0, NULL, NULL, NULL}
+               {R_FILTER_BOX,        "FLAT",       0, "Flat",          ""},
+               {R_FILTER_TENT,       "TENT",       0, "Tent",          ""},
+               {R_FILTER_QUAD,       "QUAD",       0, "Quadratic",     ""},
+               {R_FILTER_CUBIC,      "CUBIC",      0, "Cubic",         ""},
+               {R_FILTER_GAUSS,      "GAUSS",      0, "Gaussian",      ""},
+               {R_FILTER_FAST_GAUSS, "FAST_GAUSS", 0, "Fast Gaussian", ""},
+               {R_FILTER_CATROM,     "CATROM",     0, "Catrom",        ""},
+               {R_FILTER_MITCH,      "MITCH",      0, "Mitch",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
@@ -471,14 +473,14 @@ static void def_cmp_filter(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem type_items[] = {
-               {0, "SOFTEN",  "Soften",  ""},
-               {1, "SHARPEN", "Sharpen", ""},
-               {2, "LAPLACE", "Laplace", ""},
-               {3, "SOBEL",   "Sobel",   ""},
-               {4, "PREWITT", "Prewitt", ""},
-               {5, "KIRSCH",  "Kirsch",  ""},
-               {6, "SHADOW",  "Shadow",  ""},
-               {0, NULL, NULL, NULL}
+               {0, "SOFTEN",  0, "Soften",  ""},
+               {1, "SHARPEN", 0, "Sharpen", ""},
+               {2, "LAPLACE", 0, "Laplace", ""},
+               {3, "SOBEL",   0, "Sobel",   ""},
+               {4, "PREWITT", 0, "Prewitt", ""},
+               {5, "KIRSCH",  0, "Kirsch",  ""},
+               {6, "SHADOW",  0, "Shadow",  ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
@@ -550,11 +552,11 @@ static void def_cmp_image(StructRNA *srna)
        PropertyRNA *prop;
        
        /*static EnumPropertyItem type_items[] = {
-               {IMA_SRC_FILE,      "IMAGE",     "Image",     ""},
+               {IMA_SRC_FILE,      "IMAGE",     0, "Image",     ""},
                {IMA_SRC_MOVIE,     "MOVIE",     "Movie",     ""},
                {IMA_SRC_SEQUENCE,  "SEQUENCE",  "Sequence",  ""},
                {IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
-               {0, NULL, NULL, NULL}
+               {0, NULL, 0, NULL, NULL}
        };*/
        
        prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
@@ -627,26 +629,26 @@ static void def_cmp_output_file(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {R_TARGA,   "TARGA",        "Targa",        ""},
-               {R_RAWTGA,  "RAW_TARGA",    "Targa Raw",    ""},
-               {R_PNG,     "PNG",          "PNG",          ""},
-               {R_BMP,     "BMP",          "BMP",          ""},
-               {R_JPEG90,  "JPEG",         "JPEG",         ""},
-               {R_IRIS,    "IRIS",         "IRIS",         ""},
-               {R_RADHDR,  "RADIANCE_HDR", "Radiance HDR", ""},
-               {R_CINEON,  "CINEON",       "Cineon",       ""},
-               {R_DPX,     "DPX",          "DPX",          ""},
-               {R_OPENEXR, "OPENEXR",      "OpenEXR",      ""},
-               {0, NULL, NULL, NULL}
+               {R_TARGA,   "TARGA",        0, "Targa",        ""},
+               {R_RAWTGA,  "RAW_TARGA",    0, "Targa Raw",    ""},
+               {R_PNG,     "PNG",          0, "PNG",          ""},
+               {R_BMP,     "BMP",          0, "BMP",          ""},
+               {R_JPEG90,  "JPEG",         0, "JPEG",         ""},
+               {R_IRIS,    "IRIS",         0, "IRIS",         ""},
+               {R_RADHDR,  "RADIANCE_HDR", 0, "Radiance HDR", ""},
+               {R_CINEON,  "CINEON",       0, "Cineon",       ""},
+               {R_DPX,     "DPX",          0, "DPX",          ""},
+               {R_OPENEXR, "OPENEXR",      0, "OpenEXR",      ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        static EnumPropertyItem openexr_codec_items[] = {
-               {0, "NONE",  "None",           ""},
-               {1, "PXR24", "Pxr24 (lossy)",  ""},
-               {2, "ZIP",   "ZIP (lossless)", ""},
-               {3, "PIZ",   "PIX (lossless)", ""},
-               {4, "RLE",   "RLE (lossless)", ""},
-               {0, NULL, NULL, NULL}
+               {0, "NONE",  0, "None",           ""},
+               {1, "PXR24", 0, "Pxr24 (lossy)",  ""},
+               {2, "ZIP",   0, "ZIP (lossless)", ""},
+               {3, "PIZ",   0, "PIX (lossless)", ""},
+               {4, "RLE",   0, "RLE (lossless)", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeImageFile", "storage");
@@ -702,10 +704,10 @@ static void def_cmp_scale(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem space_items[] = {
-               {0, "RELATIVE",   "Relative",   ""},
-               {1, "ABSOLUTE",   "Absolute",   ""},
-               {2, "SCENE_SIZE", "Scene Size", ""},
-               {0, NULL, NULL, NULL}
+               {0, "RELATIVE",   0, "Relative",   ""},
+               {1, "ABSOLUTE",   0, "Absolute",   ""},
+               {2, "SCENE_SIZE", 0, "Scene Size", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
@@ -719,11 +721,11 @@ static void def_cmp_diff_matte(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem color_space_items[] = {
-               {1, "RGB", "RGB",   ""},
-               {2, "HSV", "HSV",   ""},
-               {3, "YUV", "YUV",   ""},
-               {4, "YCC", "YCbCr", ""},
-               {0, NULL, NULL, NULL}
+               {1, "RGB", 0, "RGB",   ""},
+               {2, "HSV", 0, "HSV",   ""},
+               {3, "YUV", 0, "YUV",   ""},
+               {4, "YCC", 0, "YCbCr", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
@@ -757,10 +759,10 @@ static void def_cmp_color_spill(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem channel_items[] = {
-               {1, "R", "Red",   ""},
-               {2, "G", "Green", ""},
-               {3, "B", "Blue",  ""},
-               {0, NULL, NULL, NULL}
+               {1, "R", 0, "Red",   ""},
+               {2, "G", 0, "Green", ""},
+               {3, "B", 0, "Blue",  ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
@@ -812,11 +814,11 @@ static void def_cmp_channel_matte(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem color_space_items[] = {
-               {1, "RGB", "RGB",   ""},
-               {2, "HSV", "HSV",   ""},
-               {3, "YUV", "YUV",   ""},
-               {4, "YCC", "YCbCr", ""},
-               {0, NULL, NULL, NULL}
+               {1, "RGB", 0, "RGB",   ""},
+               {2, "HSV", 0, "HSV",   ""},
+               {3, "YUV", 0, "YUV",   ""},
+               {4, "YCC", 0, "YCbCr", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
@@ -850,10 +852,10 @@ static void def_cmp_flip(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem axis_items[] = {
-               {0, "X",  "X",     ""},
-               {1, "Y",  "Y",     ""},
-               {2, "XY", "X & Y", ""},
-               {0, NULL, NULL, NULL}
+               {0, "X",  0, "X",     ""},
+               {1, "Y",  0, "Y",     ""},
+               {2, "XY", 0, "X & Y", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@@ -867,9 +869,9 @@ static void def_cmp_splitviewer(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem axis_items[] = {
-               {0, "X",  "X",     ""},
-               {1, "Y",  "Y",     ""},
-               {0, NULL, NULL, NULL}
+               {0, "X",  0, "X",     ""},
+               {1, "Y",  0, "Y",     ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@@ -907,14 +909,14 @@ static void def_cmp_defocus(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem bokeh_items[] = {
-               {8, "OCTAGON",  "Octagonal",  "8 sides"},
-               {7, "HEPTAGON", "Heptagonal", "7 sides"},
-               {6, "HEXAGON",  "Hexagonal",  "6 sides"},
-               {5, "PENTAGON", "Pentagonal", "5 sides"},
-               {4, "SQUARE",   "Square",     "4 sides"},
-               {3, "TRIANGLE", "Triangular", "3 sides"},
-               {0, "CIRCLE",   "Circular",   ""},
-               {0, NULL, NULL, NULL}
+               {8, "OCTAGON",  0, "Octagonal",  "8 sides"},
+               {7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
+               {6, "HEXAGON",  0, "Hexagonal",  "6 sides"},
+               {5, "PENTAGON", 0, "Pentagonal", "5 sides"},
+               {4, "SQUARE",   0, "Square",     "4 sides"},
+               {3, "TRIANGLE", 0, "Triangular", "3 sides"},
+               {0, "CIRCLE",   0, "Circular",   ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
@@ -1085,9 +1087,9 @@ static void def_cmp_premul_key(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {0, "KEY_TO_PREMUL", "Key to Premul", ""},
-               {1, "PREMUL_TO_KEY", "Premul to Key", ""},
-               {0, NULL, NULL, NULL}
+               {0, "KEY_TO_PREMUL", 0, "Key to Premul", ""},
+               {1, "PREMUL_TO_KEY", 0, "Premul to Key", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
@@ -1102,18 +1104,18 @@ static void def_cmp_glare(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {3, "GHOSTS",      "Ghosts",      ""},
-               {2, "STREAKS",     "Streaks",     ""},
-               {1, "FOG_GLOW",    "Fog Glow",    ""},
-               {0, "SIMPLE_STAR", "Simple Star", ""},
-               {0, NULL, NULL, NULL}
+               {3, "GHOSTS",      0, "Ghosts",      ""},
+               {2, "STREAKS",     0, "Streaks",     ""},
+               {1, "FOG_GLOW",    0, "Fog Glow",    ""},
+               {0, "SIMPLE_STAR", 0, "Simple Star", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        /*static EnumPropertyItem quality_items[] = {
-               {0, "HIGH",   "High",   ""},
-               {1, "MEDIUM", "Medium", ""},
-               {2, "LOW",    "Low",    ""},
-               {0, NULL, NULL, NULL}
+               {0, "HIGH",   0, "High",   ""},
+               {1, "MEDIUM", 0, "Medium", ""},
+               {2, "LOW",    0, "Low",    ""},
+               {0, NULL, 0, NULL, NULL}
        };*/
        
        RNA_def_struct_sdna_from(srna, "NodeGlare", "storage");
@@ -1172,9 +1174,9 @@ static void def_cmp_tonemap(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {1, "RD_PHOTORECEPTOR", "R/D Photoreceptor", ""},
-               {0, "RH_SIMPLE",        "Rh Simple",         ""},
-               {0, NULL, NULL, NULL}
+               {1, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
+               {0, "RH_SIMPLE",        0, "Rh Simple",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");
index 08eca7b..9d7da40 100644 (file)
@@ -392,9 +392,9 @@ static void rna_def_material_slot(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem link_items[] = {
-               {0, "DATA", "Data", ""},
-               {1, "OBJECT", "Object", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "DATA", 0, "Data", ""},
+               {1, "OBJECT", 0, "Object", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        /* NOTE: there is no MaterialSlot equivalent in DNA, so the internal
         * pointer data points to ob->mat + index, and we manually implement
@@ -428,22 +428,22 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem body_type_items[] = {
-               {OB_BODY_TYPE_NO_COLLISION, "NO_COLLISION", "No Collision", ""},
-               {OB_BODY_TYPE_STATIC, "STATIC", "Static", ""},
-               {OB_BODY_TYPE_DYNAMIC, "DYNAMIC", "Dynamic", ""},
-               {OB_BODY_TYPE_RIGID, "RIGID_BODY", "Rigid Body", ""},
-               {OB_BODY_TYPE_SOFT, "SOFT_BODY", "Soft Body", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_BODY_TYPE_NO_COLLISION, "NO_COLLISION", 0, "No Collision", ""},
+               {OB_BODY_TYPE_STATIC, "STATIC", 0, "Static", ""},
+               {OB_BODY_TYPE_DYNAMIC, "DYNAMIC", 0, "Dynamic", ""},
+               {OB_BODY_TYPE_RIGID, "RIGID_BODY", 0, "Rigid Body", ""},
+               {OB_BODY_TYPE_SOFT, "SOFT_BODY", 0, "Soft Body", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem collision_bounds_items[] = {
-               {OB_BOUND_BOX, "BOX", "Box", ""},
-               {OB_BOUND_SPHERE, "SPHERE", "Sphere", ""},
-               {OB_BOUND_CYLINDER, "CYLINDER", "Cylinder", ""},
-               {OB_BOUND_CONE, "CONE", "Cone", ""},
-               {OB_BOUND_POLYH, "CONVEX_HULL", "Convex Hull", ""},
-               {OB_BOUND_POLYT, "TRIANGLE_MESH", "Triangle Mesh", ""},
-               //{OB_DYN_MESH, "DYNAMIC_MESH", "Dynamic Mesh", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_BOUND_BOX, "BOX", 0, "Box", ""},
+               {OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
+               {OB_BOUND_CONE, "CONE", 0, "Cone", ""},
+               {OB_BOUND_POLYH, "CONVEX_HULL", 0, "Convex Hull", ""},
+               {OB_BOUND_POLYT, "TRIANGLE_MESH", 0, "Triangle Mesh", ""},
+               //{OB_DYN_MESH, "DYNAMIC_MESH", 0, "Dynamic Mesh", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "GameObjectSettings", NULL);
        RNA_def_struct_sdna(srna, "Object");
@@ -590,78 +590,78 @@ static StructRNA *rna_def_object(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem parent_type_items[] = {
-               {PAROBJECT, "OBJECT", "Object", ""},
-               {PARCURVE, "CURVE", "Curve", ""},
-               //{PARKEY, "KEY", "Key", ""},
-               {PARSKEL, "ARMATURE", "Armature", ""},
-               {PARSKEL, "LATTICE", "Lattice", ""}, // PARSKEL reuse will give issues
-               {PARVERT1, "VERTEX", "Vertex", ""},
-               {PARVERT3, "VERTEX_3", "3 Vertices", ""},
-               {PARBONE, "BONE", "Bone", ""},
-               {0, NULL, NULL, NULL}};
+               {PAROBJECT, "OBJECT", 0, "Object", ""},
+               {PARCURVE, "CURVE", 0, "Curve", ""},
+               //{PARKEY, "KEY", 0, "Key", ""},
+               {PARSKEL, "ARMATURE", 0, "Armature", ""},
+               {PARSKEL, "LATTICE", 0, "Lattice", ""}, // PARSKEL reuse will give issues
+               {PARVERT1, "VERTEX", 0, "Vertex", ""},
+               {PARVERT3, "VERTEX_3", 0, "3 Vertices", ""},
+               {PARBONE, "BONE", 0, "Bone", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        static EnumPropertyItem object_type_items[] = {
-               {OB_EMPTY, "EMPTY", "Empty", ""},
-               {OB_MESH, "MESH", "Mesh", ""},
-               {OB_CURVE, "CURVE", "Curve", ""},
-               {OB_SURF, "SURFACE", "Surface", ""},
-               {OB_FONT, "TEXT", "Text", ""},
-               {OB_MBALL, "META", "Meta", ""},
-               {OB_LAMP, "LAMP", "Lamp", ""},
-               {OB_CAMERA, "CAMERA", "Camera", ""},
-               {OB_WAVE, "WAVE", "Wave", ""},
-               {OB_LATTICE, "LATTICE", "Lattice", ""},
-               {OB_ARMATURE, "ARMATURE", "Armature", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_EMPTY, "EMPTY", 0, "Empty", ""},
+               {OB_MESH, "MESH", 0, "Mesh", ""},
+               {OB_CURVE, "CURVE", 0, "Curve", ""},
+               {OB_SURF, "SURFACE", 0, "Surface", ""},
+               {OB_FONT, "TEXT", 0, "Text", ""},
+               {OB_MBALL, "META", 0, "Meta", ""},
+               {OB_LAMP, "LAMP", 0, "Lamp", ""},
+               {OB_CAMERA, "CAMERA", 0, "Camera", ""},
+               {OB_WAVE, "WAVE", 0, "Wave", ""},
+               {OB_LATTICE, "LATTICE", 0, "Lattice", ""},
+               {OB_ARMATURE, "ARMATURE", 0, "Armature", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem empty_drawtype_items[] = {
-               {OB_ARROWS, "ARROWS", "Arrows", ""},
-               {OB_SINGLE_ARROW, "SINGLE_ARROW", "Single Arrow", ""},
-               {OB_PLAINAXES, "PLAIN_AXES", "Plain Axes", ""},
-               {OB_CIRCLE, "CIRCLE", "Circle", ""},
-               {OB_CUBE, "CUBE", "Cube", ""},
-               {OB_EMPTY_SPHERE, "SPHERE", "Sphere", ""},
-               {OB_EMPTY_CONE, "CONE", "Cone", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_ARROWS, "ARROWS", 0, "Arrows", ""},
+               {OB_SINGLE_ARROW, "SINGLE_ARROW", 0, "Single Arrow", ""},
+               {OB_PLAINAXES, "PLAIN_AXES", 0, "Plain Axes", ""},
+               {OB_CIRCLE, "CIRCLE", 0, "Circle", ""},
+               {OB_CUBE, "CUBE", 0, "Cube", ""},
+               {OB_EMPTY_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {OB_EMPTY_CONE, "CONE", 0, "Cone", ""},
+               {0, NULL, 0, NULL, NULL}};
        
        static EnumPropertyItem track_items[] = {
-               {OB_POSX, "POSX", "+X", ""},
-               {OB_POSY, "POSY", "+Y", ""},
-               {OB_POSZ, "POSZ", "+Z", ""},
-               {OB_NEGX, "NEGX", "-X", ""},
-               {OB_NEGY, "NEGY", "-Y", ""},
-               {OB_NEGZ, "NEGZ", "-Z", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_POSX, "POSX", 0, "+X", ""},
+               {OB_POSY, "POSY", 0, "+Y", ""},
+               {OB_POSZ, "POSZ", 0, "+Z", ""},
+               {OB_NEGX, "NEGX", 0, "-X", ""},
+               {OB_NEGY, "NEGY", 0, "-Y", ""},
+               {OB_NEGZ, "NEGZ", 0, "-Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem up_items[] = {
-               {OB_POSX, "X", "X", ""},
-               {OB_POSY, "Y", "Y", ""},
-               {OB_POSZ, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_POSX, "X", 0, "X", ""},
+               {OB_POSY, "Y", 0, "Y", ""},
+               {OB_POSZ, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem drawtype_items[] = {
-               {OB_BOUNDBOX, "BOUNDS", "Bounds", ""},
-               {OB_WIRE, "WIRE", "Wire", ""},
-               {OB_SOLID, "SOLID", "Solid", ""},
-               {OB_SHADED, "SHADED", "Shaded", ""},
-               {OB_TEXTURE, "TEXTURED", "Textured", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_BOUNDBOX, "BOUNDS", 0, "Bounds", ""},
+               {OB_WIRE, "WIRE", 0, "Wire", ""},
+               {OB_SOLID, "SOLID", 0, "Solid", ""},
+               {OB_SHADED, "SHADED", 0, "Shaded", ""},
+               {OB_TEXTURE, "TEXTURED", 0, "Textured", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem boundtype_items[] = {
-               {OB_BOUND_BOX, "BOX", "Box", ""},
-               {OB_BOUND_SPHERE, "SPHERE", "Sphere", ""},
-               {OB_BOUND_CYLINDER, "CYLINDER", "Cylinder", ""},
-               {OB_BOUND_CONE, "CONE", "Cone", ""},
-               {OB_BOUND_POLYH, "POLYHEDER", "Polyheder", ""},
-               {0, NULL, NULL, NULL}};
+               {OB_BOUND_BOX, "BOX", 0, "Box", ""},
+               {OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
+               {OB_BOUND_CONE, "CONE", 0, "Cone", ""},
+               {OB_BOUND_POLYH, "POLYHEDER", 0, "Polyheder", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem dupli_items[] = {
-               {0, "NONE", "None", ""},
-               {OB_DUPLIFRAMES, "FRAMES", "Frames", "Make copy of object for every frame."},
-               {OB_DUPLIVERTS, "VERTS", "Verts", "Duplicate child objects on all vertices."},
-               {OB_DUPLIFACES, "FACES", "Faces", "Duplicate child objects on all faces."},
-               {OB_DUPLIGROUP, "GROUP", "Group", "Enable group instancing."},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {OB_DUPLIFRAMES, "FRAMES", 0, "Frames", "Make copy of object for every frame."},
+               {OB_DUPLIVERTS, "VERTS", 0, "Verts", "Duplicate child objects on all vertices."},
+               {OB_DUPLIFACES, "FACES", 0, "Faces", "Duplicate child objects on all faces."},
+               {OB_DUPLIGROUP, "GROUP", 0, "Group", "Enable group instancing."},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Object", "ID");
        RNA_def_struct_ui_text(srna, "Object", "Object datablock defining an object in a scene..");
index 4f4530e..d144ed5 100644 (file)
@@ -136,29 +136,29 @@ static void rna_def_field(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem field_type_items[] = {
-               {0, "NONE", "None", ""},
-               {PFIELD_FORCE, "SPHERICAL", "Spherical", ""},
-               {PFIELD_VORTEX, "VORTEX", "Vortex", ""},
-               {PFIELD_MAGNET, "MAGNET", "Magnetic", ""},
-               {PFIELD_WIND, "WIND", "Wind", ""},
-               {PFIELD_GUIDE, "GUIDE", "Curve Guide", ""},
-               {PFIELD_TEXTURE, "TEXTURE", "Texture", ""},
-               {PFIELD_HARMONIC, "HARMONIC", "Harmonic", ""},
-               {PFIELD_CHARGE, "CHARGE", "Charge", ""},
-               {PFIELD_LENNARDJ, "LENNARDJ", "Lennard-Jones", ""},
-               {0, NULL, NULL, NULL}};
+               {0, "NONE", 0, "None", ""},
+               {PFIELD_FORCE, "SPHERICAL", 0, "Spherical", ""},
+               {PFIELD_VORTEX, "VORTEX", 0, "Vortex", ""},
+               {PFIELD_MAGNET, "MAGNET", 0, "Magnetic", ""},
+               {PFIELD_WIND, "WIND", 0, "Wind", ""},
+               {PFIELD_GUIDE, "GUIDE", 0, "Curve Guide", ""},
+               {PFIELD_TEXTURE, "TEXTURE", 0, "Texture", ""},
+               {PFIELD_HARMONIC, "HARMONIC", 0, "Harmonic", ""},
+               {PFIELD_CHARGE, "CHARGE", 0, "Charge", ""},
+               {PFIELD_LENNARDJ, "LENNARDJ", 0, "Lennard-Jones", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem falloff_items[] = {
-               {PFIELD_FALL_SPHERE, "SPHERE", "Sphere", ""},
-               {PFIELD_FALL_TUBE, "TUBE", "Tube", ""},
-               {PFIELD_FALL_CONE, "CONE", "Cone", ""},
-               {0, NULL, NULL, NULL}};
+               {PFIELD_FALL_SPHERE, "SPHERE", 0, "Sphere", ""},
+               {PFIELD_FALL_TUBE, "TUBE", 0, "Tube", ""},
+               {PFIELD_FALL_CONE, "CONE", 0, "Cone", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem texture_items[] = {
-               {PFIELD_TEX_RGB, "RGB", "RGB", ""},
-               {PFIELD_TEX_GRAD, "GRADIENT", "Gradient", ""},
-               {PFIELD_TEX_CURL, "CURL", "Curl", ""},
-               {0, NULL, NULL, NULL}};
+               {PFIELD_TEX_RGB, "RGB", 0, "RGB", ""},
+               {PFIELD_TEX_GRAD, "GRADIENT", 0, "Gradient", ""},
+               {PFIELD_TEX_CURL, "CURL", 0, "Curl", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "FieldSettings", NULL);
        RNA_def_struct_sdna(srna, "PartDeflect");
index 8d23f95..8ee71b6 100644 (file)
@@ -160,18 +160,18 @@ static void rna_ParticleSystem_name_get(PointerRNA *ptr, char *str)
 }
 
 static EnumPropertyItem from_items[] = {
-       {PART_FROM_VERT, "VERT", "Vertexes", ""},
-       {PART_FROM_FACE, "FACE", "Faces", ""},
-       {PART_FROM_VOLUME, "VOLUME", "Volume", ""},
-       {0, NULL, NULL, NULL}
+       {PART_FROM_VERT, "VERT", 0, "Vertexes", ""},
+       {PART_FROM_FACE, "FACE", 0, "Faces", ""},
+       {PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem reactor_from_items[] = {
-       {PART_FROM_VERT, "VERT", "Vertexes", ""},
-       {PART_FROM_FACE, "FACE", "Faces", ""},
-       {PART_FROM_VOLUME, "VOLUME", "Volume", ""},
-       {PART_FROM_PARTICLE, "PARTICLE", "Particle", ""},
-       {0, NULL, NULL, NULL}
+       {PART_FROM_VERT, "VERT", 0, "Vertexes", ""},
+       {PART_FROM_FACE, "FACE", 0, "Faces", ""},
+       {PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
+       {PART_FROM_PARTICLE, "PARTICLE", 0, "Particle", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem *rna_Particle_from_itemf(PointerRNA *ptr)
@@ -185,39 +185,39 @@ static EnumPropertyItem *rna_Particle_from_itemf(PointerRNA *ptr)
 }
 
 static EnumPropertyItem draw_as_items[] = {
-       {PART_DRAW_NOT, "NONE", "None", ""},
-       {PART_DRAW_REND, "RENDER", "Rendered", ""},
-       {PART_DRAW_DOT, "DOT", "Point", ""},
-       {PART_DRAW_CIRC, "CIRC", "Circle", ""},
-       {PART_DRAW_CROSS, "CROSS", "Cross", ""},
-       {PART_DRAW_AXIS, "AXIS", "Axis", ""},
-       {0, NULL, NULL, NULL}
+       {PART_DRAW_NOT, "NONE", 0, "None", ""},
+       {PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
+       {PART_DRAW_DOT, "DOT", 0, "Point", ""},
+       {PART_DRAW_CIRC, "CIRC", 0, "Circle", ""},
+       {PART_DRAW_CROSS, "CROSS", 0, "Cross", ""},
+       {PART_DRAW_AXIS, "AXIS", 0, "Axis", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem hair_draw_as_items[] = {
-       {PART_DRAW_NOT, "NONE", "None", ""},
-       {PART_DRAW_REND, "RENDER", "Rendered", ""},
-       {PART_DRAW_PATH, "PATH", "Path", ""},
-       {0, NULL, NULL, NULL}
+       {PART_DRAW_NOT, "NONE", 0, "None", ""},
+       {PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
+       {PART_DRAW_PATH, "PATH", 0, "Path", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem ren_as_items[] = {
-       {PART_DRAW_NOT, "NONE", "None", ""},
-       {PART_DRAW_HALO, "HALO", "Halo", ""},
-       {PART_DRAW_LINE, "LINE", "Line", ""},
-       {PART_DRAW_PATH, "PATH", "Path", ""},
-       {PART_DRAW_OB, "OBJECT", "Object", ""},
-       {PART_DRAW_GR, "GROUP", "Group", ""},
-       {PART_DRAW_BB, "BILLBOARD", "Billboard", ""},
-       {0, NULL, NULL, NULL}
+       {PART_DRAW_NOT, "NONE", 0, "None", ""},
+       {PART_DRAW_HALO, "HALO", 0, "Halo", ""},
+       {PART_DRAW_LINE, "LINE", 0, "Line", ""},
+       {PART_DRAW_PATH, "PATH", 0, "Path", ""},
+       {PART_DRAW_OB, "OBJECT", 0, "Object", ""},
+       {PART_DRAW_GR, "GROUP", 0, "Group", ""},
+       {PART_DRAW_BB, "BILLBOARD", 0, "Billboard", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem hair_ren_as_items[] = {
-       {PART_DRAW_NOT, "NONE", "None", ""},
-       {PART_DRAW_PATH, "PATH", "Path", ""},
-       {PART_DRAW_OB, "OBJECT", "Object", ""},
-       {PART_DRAW_GR, "GROUP", "Group", ""},
-       {0, NULL, NULL, NULL}
+       {PART_DRAW_NOT, "NONE", 0, "None", ""},
+       {PART_DRAW_PATH, "PATH", 0, "Path", ""},
+       {PART_DRAW_OB, "OBJECT", 0, "Object", ""},
+       {PART_DRAW_GR, "GROUP", 0, "Group", ""},
+       {0, NULL, 0, NULL, NULL}
 };
 
 static EnumPropertyItem *rna_Particle_draw_as_itemf(PointerRNA *ptr)
@@ -313,12 +313,12 @@ static void rna_def_particle(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem alive_items[] = {
-               {PARS_KILLED, "KILLED", "Killed", ""},
-               {PARS_DEAD, "DEAD", "Dead", ""},
-               {PARS_UNBORN, "UNBORN", "Unborn", ""},
-               {PARS_ALIVE, "ALIVE", "Alive", ""},
-               {PARS_DYING, "DYING", "Dying", ""},
-               {0, NULL, NULL, NULL}
+               {PARS_KILLED, "KILLED", 0, "Killed", ""},
+               {PARS_DEAD, "DEAD", 0, "Dead", ""},
+               {PARS_UNBORN, "UNBORN", 0, "Unborn", ""},
+               {PARS_ALIVE, "ALIVE", 0, "Alive", ""},
+               {PARS_DYING, "DYING", 0, "Dying", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        srna = RNA_def_struct(brna, "Particle", NULL);
@@ -453,115 +453,115 @@ static void rna_def_particle_settings(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem type_items[] = {
-               {PART_EMITTER, "EMITTER", "Emitter", ""},
-               {PART_REACTOR, "REACTOR", "Reactor", ""},
-               {PART_HAIR, "HAIR", "Hair", ""},
-               {0, NULL, NULL, NULL}
+               {PART_EMITTER, "EMITTER", 0, "Emitter", ""},
+               {PART_REACTOR, "REACTOR", 0, "Reactor", ""},
+               {PART_HAIR, "HAIR", 0, "Hair", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem dist_items[] = {
-               {PART_DISTR_JIT, "JIT", "Jittered", ""},
-               {PART_DISTR_RAND, "RAND", "Random", ""},
-               {PART_DISTR_GRID, "GRID", "Grid", ""},
-               {0, NULL, NULL, NULL}
+               {PART_DISTR_JIT, "JIT", 0, "Jittered", ""},
+               {PART_DISTR_RAND, "RAND", 0, "Random", ""},
+               {PART_DISTR_GRID, "GRID", 0, "Grid", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem phys_type_items[] = {
-               {PART_PHYS_NO, "NO", "No", ""},
-               {PART_PHYS_NEWTON, "NEWTON", "Newtonian", ""},
-               {PART_PHYS_KEYED, "KEYED", "Keyed", ""},
-               {PART_PHYS_BOIDS, "BOIDS", "Boids", ""},
-               {0, NULL, NULL, NULL}
+               {PART_PHYS_NO, "NO", 0, "No", ""},
+               {PART_PHYS_NEWTON, "NEWTON", 0, "Newtonian", ""},
+               {PART_PHYS_KEYED, "KEYED", 0, "Keyed", ""},
+               {PART_PHYS_BOIDS, "BOIDS", 0, "Boids", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem rot_mode_items[] = {
-               {0, "NONE", "None", ""},
-               {PART_ROT_NOR, "NOR", "Normal", ""},
-               {PART_ROT_VEL, "VEL", "Velocity", ""},
-               {PART_ROT_GLOB_X, "GLOB_X", "Global X", ""},
-               {PART_ROT_GLOB_Y, "GLOB_Y", "Global Y", ""},
-               {PART_ROT_GLOB_Z, "GLOB_Z", "Global Z", ""},
-               {PART_ROT_OB_X, "OB_X", "Object X", ""},
-               {PART_ROT_OB_Y, "OB_Y", "Object Y", ""},
-               {PART_ROT_OB_Z, "OB_Z", "Object Z", ""},
-               {0, NULL, NULL, NULL}
+               {0, "NONE", 0, "None", ""},
+               {PART_ROT_NOR, "NOR", 0, "Normal", ""},
+               {PART_ROT_VEL, "VEL", 0, "Velocity", ""},
+               {PART_ROT_GLOB_X, "GLOB_X", 0, "Global X", ""},
+               {PART_ROT_GLOB_Y, "GLOB_Y", 0, "Global Y", ""},
+               {PART_ROT_GLOB_Z, "GLOB_Z", 0, "Global Z", ""},
+               {PART_ROT_OB_X, "OB_X", 0, "Object X", ""},
+               {PART_ROT_OB_Y, "OB_Y", 0, "Object Y", ""},
+               {PART_ROT_OB_Z, "OB_Z", 0, "Object Z", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem ave_mode_items[] = {
-               {0, "NONE", "None", ""},
-               {PART_AVE_SPIN, "SPIN", "Spin", ""},
-               {PART_AVE_RAND, "RAND", "Random", ""} ,
-               {0, NULL, NULL, NULL}
+               {0, "NONE", 0, "None", ""},
+               {PART_AVE_SPIN, "SPIN", 0, "Spin", ""},
+               {PART_AVE_RAND, "RAND", 0, "Random", ""} ,
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem react_event_items[] = {
-               {PART_EVENT_DEATH, "DEATH", "Death", ""},
-               {PART_EVENT_COLLIDE, "COLLIDE", "Collision", ""},
-               {PART_EVENT_NEAR, "NEAR", "Near", ""},
-               {0, NULL, NULL, NULL}
+               {PART_EVENT_DEATH, "DEATH", 0, "Death", ""},
+               {PART_EVENT_COLLIDE, "COLLIDE", 0, "Collision", ""},
+               {PART_EVENT_NEAR, "NEAR", 0, "Near", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem child_type_items[] = {
-               {0, "NONE", "None", ""},
-               {PART_CHILD_PARTICLES, "PARTICLES", "Particles", ""},
-               {PART_CHILD_FACES, "FACES", "Faces", ""},
-               {0, NULL, NULL, NULL}
+               {0, "NONE", 0, "None", ""},
+               {PART_CHILD_PARTICLES, "PARTICLES", 0, "Particles", ""},
+               {PART_CHILD_FACES, "FACES", 0, "Faces", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        //TODO: names, tooltips
        static EnumPropertyItem rot_from_items[] = {
-               {PART_ROT_KEYS, "KEYS", "keys", ""},
-               {PART_ROT_ZINCR, "ZINCR", "zincr", ""},
-               {PART_ROT_IINCR, "IINCR", "iincr", ""},
-               {0, NULL, NULL, NULL}
+               {PART_ROT_KEYS, "KEYS", 0, "keys", ""},
+               {PART_ROT_ZINCR, "ZINCR", 0, "zincr", ""},
+               {PART_ROT_IINCR, "IINCR", 0, "iincr", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem integrator_type_items[] = {
-               {PART_INT_EULER, "EULER", "Euler", ""},
-               {PART_INT_MIDPOINT, "MIDPOINT", "Midpoint", ""},
-               {PART_INT_RK4, "RK4", "RK4", ""},
-               {0, NULL, NULL, NULL}
+               {PART_INT_EULER, "EULER", 0, "Euler", ""},
+               {PART_INT_MIDPOINT, "MIDPOINT", 0, "Midpoint", ""},
+               {PART_INT_RK4, "RK4", 0, "RK4", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem kink_type_items[] = {
-               {PART_KINK_NO, "NO", "Nothing", ""},
-               {PART_KINK_CURL, "CURL", "Curl", ""},
-               {PART_KINK_RADIAL, "RADIAL", "Radial", ""},
-               {PART_KINK_WAVE, "WAVE", "Wave", ""},
-               {PART_KINK_BRAID, "BRAID", "Braid", ""},
-               {0, NULL, NULL, NULL}
+               {PART_KINK_NO, "NO", 0, "Nothing", ""},
+               {PART_KINK_CURL, "CURL", 0, "Curl", ""},
+               {PART_KINK_RADIAL, "RADIAL", 0, "Radial", ""},
+               {PART_KINK_WAVE, "WAVE", 0, "Wave", ""},
+               {PART_KINK_BRAID, "BRAID", 0, "Braid", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem kink_axis_items[] = {
-               {0, "X", "X", ""},
-               {1, "Y", "Y", ""},
-               {2, "Z", "Z", ""},
-               {0, NULL, NULL, NULL}
+               {0, "X", 0, "X", ""},
+               {1, "Y", 0, "Y", ""},
+               {2, "Z", 0, "Z", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem bb_align_items[] = {
-               {PART_BB_X, "X", "X", ""},
-               {PART_BB_Y, "Y", "Y", ""},
-               {PART_BB_Z, "Z", "Z", ""},
-               {PART_BB_VIEW, "VIEW", "View", ""},
-               {PART_BB_VEL, "VEL", "Velocity", ""},
-               {0, NULL, NULL, NULL}
+               {PART_BB_X, "X", 0, "X", ""},
+               {PART_BB_Y, "Y", 0, "Y", ""},
+               {PART_BB_Z, "Z", 0, "Z", ""},
+               {PART_BB_VIEW, "VIEW", 0, "View", ""},
+               {PART_BB_VEL, "VEL", 0, "Velocity", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem bb_anim_items[] = {
-               {PART_BB_ANIM_NONE, "NONE", "None", ""},
-               {PART_BB_ANIM_TIME, "TIME", "Time", ""},
-               {PART_BB_ANIM_ANGLE, "ANGLE", "Angle", ""},
-               //{PART_BB_ANIM_OFF_TIME, "OFF_TIME", "off_time", ""},
-               //{PART_BB_ANIM_OFF_ANGLE, "OFF_ANGLE", "off_angle", ""},
-               {0, NULL, NULL, NULL}
+               {PART_BB_ANIM_NONE, "NONE", 0, "None", ""},
+               {PART_BB_ANIM_TIME, "TIME", 0, "Time", ""},
+               {PART_BB_ANIM_ANGLE, "ANGLE", 0, "Angle", ""},
+               //{PART_BB_ANIM_OFF_TIME, "OFF_TIME", 0, "off_time", ""},
+               //{PART_BB_ANIM_OFF_ANGLE, "OFF_ANGLE", 0, "off_angle", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        static EnumPropertyItem bb_split_offset_items[] = {
-               {PART_BB_OFF_NONE, "NONE", "None", ""},
-               {PART_BB_OFF_LINEAR, "LINEAR", "Linear", ""},
-               {PART_BB_OFF_RANDOM, "RANDOM", "Random", ""},
-               {0, NULL, NULL, NULL}
+               {PART_BB_OFF_NONE, "NONE", 0, "None", ""},
+               {PART_BB_OFF_LINEAR, "LINEAR", 0, "Linear", ""},
+               {PART_BB_OFF_RANDOM, "RANDOM", 0, "Random", ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        srna= RNA_def_struct(brna, "ParticleSettings", "ID");
index 8edcc4c..b886354 100644 (file)
@@ -69,9 +69,9 @@ IDProperty *rna_PoseChannel_idproperties(PointerRNA *ptr, int create)
 static void rna_def_pose_channel(BlenderRNA *brna)
 {
        static EnumPropertyItem prop_rotmode_items[] = {
-               {PCHAN_ROT_QUAT, "QUATERNION", "Quaternion (WXYZ)", "No Gimbal Lock (default)"},
-               {PCHAN_ROT_EUL, "EULER", "Euler (XYZ)", "Prone to Gimbal Lock"},
-               {0, NULL, NULL, NULL}};
+               {PCHAN_ROT_QUAT, "QUATERNION", 0, "Quaternion (WXYZ)", "No Gimbal Lock (default)"},
+               {PCHAN_ROT_EUL, "EULER", 0, "Euler (XYZ)", "Prone to Gimbal Lock"},
+               {0, NULL, 0, NULL, NULL}};
        
        StructRNA *srna;
        PropertyRNA *prop;
index c38b634..a840552 100644 (file)
@@ -75,12 +75,12 @@ void RNA_def_gameproperty(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem gameproperty_type_items[] ={
-               {GPROP_BOOL, "BOOL", "Boolean", ""},
-               {GPROP_INT, "INT", "Integer", ""},
-               {GPROP_FLOAT, "FLOAT", "Float", ""},
-               {GPROP_STRING, "STRING", "String", ""},
-               {GPROP_TIME, "TIMER", "Timer", ""},
-               {0, NULL, NULL, NULL}};
+               {GPROP_BOOL, "BOOL", 0, "Boolean", ""},
+               {GPROP_INT, "INT", 0, "Integer", ""},
+               {GPROP_FLOAT, "FLOAT", 0, "Float", ""},
+               {GPROP_STRING, "STRING", 0, "String", ""},
+               {GPROP_TIME, "TIMER", 0, "Timer", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        /* Base Struct for GameProperty */
        srna= RNA_def_struct(brna, "GameProperty", NULL);
index 54dbd59..8b862b4 100644 (file)
@@ -40,10 +40,10 @@ void RNA_def_radio(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem prop_drawtype_items[] = { 
-               {RAD_WIREFRAME, "WIREFRAME", "Wireframe", "Enables Wireframe draw mode"},
-               {RAD_SOLID, "SOLID", "Solid", "Enables Solid draw mode"},
-               {RAD_GOURAUD, "GOURAUD", "Gouraud", "Enables Gouraud draw mode"},
-               {0, NULL, NULL, NULL}};
+               {RAD_WIREFRAME, "WIREFRAME", 0, "Wireframe", "Enables Wireframe draw mode"},
+               {RAD_SOLID, "SOLID", 0, "Solid", "Enables Solid draw mode"},
+               {RAD_GOURAUD, "GOURAUD", 0, "Gouraud", "Enables Gouraud draw mode"},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Radiosity", NULL);
        RNA_def_struct_ui_text(srna, "Radiosity", "Settings for radiosity simulation of indirect diffuse lighting.");
index 8ea8844..329175a 100644 (file)
@@ -626,26 +626,26 @@ static void rna_def_property(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
        static EnumPropertyItem 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, NULL}};
+               {PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
+               {PROP_INT, "INT", 0, "Integer", ""},
+               {PROP_FLOAT, "FLOAT", 0, "Float", ""},
+               {PROP_STRING, "STRING", 0, "String", ""},
+               {PROP_ENUM, "ENUM", 0, "Enumeration", ""},
+               {PROP_POINTER, "POINTER", 0, "Pointer", ""},
+               {PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
+               {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem subtype_items[] = {
-               {PROP_NONE, "NONE", "None", ""},
-               {PROP_UNSIGNED, "UNSIGNED", "Unsigned Number", ""},
-               {PROP_FILEPATH, "FILE_PATH", "File Path", ""},
-               {PROP_DIRPATH, "DIRECTORY_PATH", "Directory Path", ""},
-               {PROP_COLOR, "COLOR", "Color", ""},
-               {PROP_VECTOR, "VECTOR", "Vector", ""},
-               {PROP_MATRIX, "MATRIX", "Matrix", ""},
-               {PROP_ROTATION, "ROTATION", "Rotation", ""},
-               {PROP_NEVER_NULL, "NEVER_NULL", "Never Null", ""},
-               {PROP_PERCENTAGE, "PERCENTAGE", "Percentage", ""},
-               {0, NULL, NULL, NULL}};
+               {PROP_NONE, "NONE", 0, "None", ""},
+               {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
+               {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
+               {PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
+               {PROP_COLOR, "COLOR", 0, "Color", ""},
+               {PROP_VECTOR, "VECTOR", 0, "Vector", ""},
+               {PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
+               {PROP_ROTATION, "ROTATION", 0, "Rotation", ""},
+               {PROP_NEVER_NULL, "NEVER_NULL", 0, "Never Null", ""},
+               {PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "Property", NULL);
        RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition.");
index 3907a63..64ba6e1 100644 (file)
 
 /* prop_mode needs to be accessible from transform operator */
 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, NULL}};
+       {PROP_SMOOTH, "SMOOTH", 0, "Smooth", ""},
+       {PROP_SPHERE, "SPHERE", 0, "Sphere", ""},
+       {PROP_ROOT, "ROOT", 0, "Root", ""},
+       {PROP_SHARP, "SHARP", 0, "Sharp", ""},
+       {PROP_LIN, "LINEAR", 0, "Linear", ""},
+       {PROP_CONST, "CONSTANT", 0, "Constant", ""},
+       {PROP_RANDOM, "RANDOM", 0, "Random", ""},
+       {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
 
@@ -172,161 +172,161 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem pixel_filter_items[] ={
-               {R_FILTER_BOX, "BOX", "Box", ""},
-               {R_FILTER_TENT, "TENT", "Tent", ""},
-               {R_FILTER_QUAD, "QUADRATIC", "Quadratic", ""},
-               {R_FILTER_CUBIC, "CUBIC", "Cubic", ""},
-               {R_FILTER_CATROM, "CATMULLROM", "Catmull-Rom", ""},
-               {R_FILTER_GAUSS, "GAUSSIAN", "Gaussian", ""},
-               {R_FILTER_MITCH, "MITCHELL", "Mitchell-Netravali", ""},
-               {0, NULL, NULL, NULL}};
+               {R_FILTER_BOX, "BOX", 0, "Box", ""},
+               {R_FILTER_TENT, "TENT", 0, "Tent", ""},
+               {R_FILTER_QUAD, "QUADRATIC", 0, "Quadratic", ""},
+               {R_FILTER_CUBIC, "CUBIC", 0, "Cubic", ""},
+               {R_FILTER_CATROM, "CATMULLROM", 0, "Catmull-Rom", ""},
+               {R_FILTER_GAUSS, "GAUSSIAN", 0, "Gaussian", ""},
+               {R_FILTER_MITCH, "MITCHELL", 0, "Mitchell-Netravali", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem alpha_mode_items[] ={
-               {R_ADDSKY, "SKY", "Sky", "Transparent pixels are filled with sky color"},
-               {R_ALPHAPREMUL, "PREMUL", "Premultiplied", "Transparent RGB pixels are multiplied by the alpha channel"},
-               {R_ALPHAKEY, "STRAIGHT", "Straight Alpha", "Transparent RGB and alpha pixels are unmodified"},
-               {0, NULL, NULL, NULL}};
+               {R_ADDSKY, "SKY", 0, "Sky", "Transparent pixels are filled with sky color"},
+               {R_ALPHAPREMUL, "PREMUL", 0, "Premultiplied", "Transparent RGB pixels are multiplied by the alpha channel"},
+               {R_ALPHAKEY, "STRAIGHT", 0, "Straight Alpha", "Transparent RGB and alpha pixels are unmodified"},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem color_mode_items[] ={
-               {R_PLANESBW, "BW", "BW", "Images are saved with BW (grayscale) data"},
-               {R_PLANES24, "RGB", "RGB", "Images are saved with RGB (color) data"},
-               {R_PLANES32, "RGBA", "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
-               {0, NULL, NULL, NULL}};
+               {R_PLANESBW, "BW", 0, "BW", "Images are saved with BW (grayscale) data"},
+               {R_PLANES24, "RGB", 0, "RGB", "Images are saved with RGB (color) data"},
+               {R_PLANES32, "RGBA", 0, "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem octree_resolution_items[] = {
-               {64, "OCTREE_RES_64", "64", ""},
-               {128, "OCTREE_RES_128", "128", ""},
-               {256, "OCTREE_RES_256", "256", ""},
-               {512, "OCTREE_RES_512", "512", ""},
-               {0, NULL, NULL, NULL}};
+               {64, "OCTREE_RES_64", 0, "64", ""},
+               {128, "OCTREE_RES_128", 0, "128", ""},
+               {256, "OCTREE_RES_256", 0, "256", ""},
+               {512, "OCTREE_RES_512", 0, "512", ""},
+               {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem fixed_oversample_items[] = {
-               {5, "OVERSAMPLE_5", "5", ""},
-               {8, "OVERSAMPLE_8", "8", ""},
-               {11, "OVERSAMPLE_11", "11", ""},