merge with/from trunk at r35190
[blender.git] / source / blender / makesrna / intern / rna_fcurve.c
index 9549dfe78fdcfa9ff5ec681280d28bc2d9a3337d..72f74f5a3e9f0c23f0b8f323329a00c14f10e131 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
@@ -44,7 +44,7 @@
 
 #include "ED_keyframing.h"
 #include "ED_keyframes_edit.h"
-
 EnumPropertyItem fmodifier_type_items[] = {
        {FMODIFIER_TYPE_NULL, "NULL", 0, "Invalid", ""},
        {FMODIFIER_TYPE_GENERATOR, "GENERATOR", 0, "Generator", ""},
@@ -53,7 +53,7 @@ EnumPropertyItem fmodifier_type_items[] = {
        {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_PYTHON, "PYTHON", 0, "Python", ""},   // FIXME: not implemented yet!
        {FMODIFIER_TYPE_LIMITS, "LIMITS", 0, "Limits", ""},
        {FMODIFIER_TYPE_STEPPED, "STEPPED", 0, "Stepped Interpolation", ""},
        {0, NULL, 0, NULL, NULL}};
@@ -62,6 +62,7 @@ EnumPropertyItem beztriple_keyframe_type_items[] = {
        {BEZT_KEYTYPE_KEYFRAME, "KEYFRAME", 0, "Keyframe", ""},
        {BEZT_KEYTYPE_BREAKDOWN, "BREAKDOWN", 0, "Breakdown", ""},
        {BEZT_KEYTYPE_EXTREME, "EXTREME", 0, "Extreme", ""},
+       {BEZT_KEYTYPE_JITTER, "JITTER", 0, "Jitter", ""},
        {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
@@ -111,7 +112,7 @@ static void rna_ChannelDriver_update_data(Main *bmain, Scene *scene, PointerRNA
        
        // TODO: this really needs an update guard...
        DAG_scene_sort(bmain, scene);
-       DAG_id_flush_update(id, OB_RECALC_OB|OB_RECALC_DATA);
+       DAG_id_tag_update(id, OB_RECALC_OB|OB_RECALC_DATA);
        
        WM_main_add_notifier(NC_SCENE|ND_FRAME, scene);
 }
@@ -324,27 +325,46 @@ static void rna_FCurve_RnaPath_set(PointerRNA *ptr, const char *value)
        if (fcu->rna_path)
                MEM_freeN(fcu->rna_path);
        
-       if (strlen(value))
+       if (strlen(value)) {
                fcu->rna_path= BLI_strdup(value);
+               fcu->flag &= ~FCURVE_DISABLED;
+       }
        else 
                fcu->rna_path= NULL;
 }
 
 static void rna_FCurve_group_set(PointerRNA *ptr, PointerRNA value)
 {
-       AnimData *adt= BKE_animdata_from_id(ptr->id.data);
-       bAction *act= (adt) ? adt->action : NULL;
+       ID *pid = (ID *)ptr->id.data;
+       ID *vid = (ID *)value.id.data;
        FCurve *fcu= ptr->data;
-
-       /* same ID? */
-       if (value.data && (ptr->id.data != value.id.data)) {
+       bAction *act = NULL;
+       
+       /* get action */
+       if (ELEM(NULL, pid, vid)) {
+               printf("ERROR: one of the ID's for the groups to assign to is invalid (ptr=%p, val=%p)\n", pid, vid);
+               return;
+       }
+       else if (value.data && (pid != vid)) {
                /* id's differ, cant do this, should raise an error */
+               printf("ERROR: ID's differ - ptr=%p vs value=%p \n", pid, vid);
                return;
        }
+       
+       if (GS(pid->name)==ID_AC && GS(vid->name)==ID_AC) {
+               /* the ID given is the action already - usually when F-Curve is obtained from an action's pointer */
+               act = (bAction *)pid;
+       }
+       else {
+               /* the ID given is the owner of the F-Curve (for drivers) */
+               AnimData *adt = BKE_animdata_from_id(ptr->id.data);
+               act = (adt)? adt->action : NULL;
+       }
+       
        /* already belongs to group? */
        if (fcu->grp == value.data) {
                /* nothing to do */
-               printf("ERROR: F-Curve already belongs to the group\n");
+               printf("ERROR: F-Curve already belongs to this group\n");
                return; 
        }
        
@@ -355,18 +375,16 @@ static void rna_FCurve_group_set(PointerRNA *ptr, PointerRNA value)
                /* can't change the grouping of F-Curve when it doesn't belong to an action */
                printf("ERROR: cannot assign F-Curve to group, since F-Curve is not attached to any ID\n");
                return;
-       }       
-       
-       /* try to remove F-Curve from action (including from any existing groups) 
-        *      - if after this op it is still attached to something, then it is a driver 
-        *        not an animation curve as we thought, and we should exit
-        */
-       action_groups_remove_channel(act, fcu);
-       if (fcu->next) {
-               /* F-Curve is not one that exists in the action, since the above op couldn't remove it from the list */
+       }
+       /* make sure F-Curve exists in this action first, otherwise we could still have been tricked */
+       else if (BLI_findindex(&act->curves, fcu) == -1) {
+               printf("ERROR: F-Curve (%p) doesn't exist in action '%s'\n", fcu, act->id.name);
                return;
        }
        
+       /* try to remove F-Curve from action (including from any existing groups) */
+       action_groups_remove_channel(act, fcu);
+       
        /* add the F-Curve back to the action now in the right place */
        // TODO: make the api function handle the case where there isn't any group to assign to 
        if (value.data) {
@@ -385,9 +403,13 @@ DriverVar *rna_Driver_new_variable(ChannelDriver *driver)
        return driver_add_new_variable(driver);
 }
 
-void rna_Driver_remove_variable(ChannelDriver *driver, DriverVar *dvar)
+void rna_Driver_remove_variable(ChannelDriver *driver, ReportList *reports, DriverVar *dvar)
 {
-       /* call the API function for this */
+       if(BLI_findindex(&driver->variables, dvar) == -1) {
+               BKE_report(reports, RPT_ERROR, "Variable does not exist in this driver.");
+               return;
+       }
+
        driver_free_variable(driver, dvar);
 }
 
@@ -410,9 +432,13 @@ static FModifier *rna_FCurve_modifiers_new(FCurve *fcu, int type)
        return add_fmodifier(&fcu->modifiers, type);
 }
 
-static int rna_FCurve_modifiers_remove(FCurve *fcu, int index)
+static void rna_FCurve_modifiers_remove(FCurve *fcu, ReportList *reports, FModifier *fcm)
 {
-       return remove_fmodifier_index(&fcu->modifiers, index);
+       if(BLI_findindex(&fcu->modifiers, fcm) == -1) {
+               BKE_reportf(reports, RPT_ERROR, "FCurveModifier '%s' not found in fcurve.", fcm->name);
+               return;
+       }
+       remove_fmodifier(&fcu->modifiers, fcm);
 }
 
 static void rna_FModifier_active_set(PointerRNA *ptr, int value)
@@ -521,25 +547,34 @@ static void rna_FModifierStepped_end_frame_range(PointerRNA *ptr, float *min, fl
        *max= MAXFRAMEF;
 }
 
-static BezTriple *rna_FKeyframe_points_add(FCurve *fcu, float frame, float value, int do_replace, int do_needed, int do_fast)
+static BezTriple *rna_FKeyframe_points_insert(FCurve *fcu, float frame, float value, int flag)
 {
-       int index;
-       int flag= 0;
-
-       if(do_replace) flag |= INSERTKEY_REPLACE;
-       if(do_needed) flag |= INSERTKEY_NEEDED;
-       if(do_fast) flag |= INSERTKEY_FAST;
+       int index= insert_vert_fcurve(fcu, frame, value, flag);
+       return ((fcu->bezt) && (index >= 0))? (fcu->bezt + index) : NULL;
+}
 
+static void rna_FKeyframe_points_add(FCurve *fcu, int tot)
+{
+       if(tot > 0) {
+               if(fcu->totvert) {
+                       BezTriple *nbezt= MEM_callocN(sizeof(BezTriple) * (fcu->totvert + tot), "rna_FKeyframe_points_add");
+                       memcpy(nbezt, fcu->bezt, sizeof(BezTriple) * fcu->totvert);
+                       MEM_freeN(fcu->bezt);
+                       fcu->bezt= nbezt;
+               }
+               else {
+                       fcu->bezt= MEM_callocN(sizeof(BezTriple) * tot, "rna_FKeyframe_points_add");
+               }
 
-       index= insert_vert_fcurve(fcu, frame, value, flag);
-       return index >= 0 ? fcu->bezt + index : NULL;
+               fcu->totvert += tot;
+       }
 }
 
 static void rna_FKeyframe_points_remove(FCurve *fcu, ReportList *reports, BezTriple *bezt, int do_fast)
 {
        int index= (int)(bezt - fcu->bezt);
        if (index < 0 || index >= fcu->totvert) {
-               BKE_report(reports, RPT_ERROR, "bezier not in fcurve.");
+               BKE_report(reports, RPT_ERROR, "Keyframe not in F-Curve.");
                return;
        }
 
@@ -568,7 +603,7 @@ static void rna_def_fmodifier_generator(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");
        
        /* define common props */
-       prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
        RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -633,7 +668,7 @@ static void rna_def_fmodifier_function_generator(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
        /* flags */
-       prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
        RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -660,12 +695,12 @@ static void rna_def_fmodifier_envelope_ctrl(BlenderRNA *brna)
         *      - for now, these are allowed to go past each other, so that we can have inverted action
         *      - technically, the range is limited by the settings in the envelope-modifier data, not here...
         */
-       prop= RNA_def_property(srna, "minimum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min");
        RNA_def_property_ui_text(prop, "Minimum Value", "Lower bound of envelope at this control-point");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "maximum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max");
        RNA_def_property_ui_text(prop, "Maximum Value", "Upper bound of envelope at this control-point");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -701,12 +736,12 @@ static void rna_def_fmodifier_envelope(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Reference Value", "Value that envelope's influence is centered around / based on");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "default_minimum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "default_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min");
        RNA_def_property_ui_text(prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "default_maximum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "default_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max");
        RNA_def_property_ui_text(prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -731,22 +766,26 @@ static void rna_def_fmodifier_cycles(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Cycles", "data");
        
        /* before */
-       prop= RNA_def_property(srna, "before_mode", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "mode_before", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "before_mode");
        RNA_def_property_enum_items(prop, prop_type_items);
        RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "before_cycles", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "cycles_before", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "before_cycles");
        RNA_def_property_ui_text(prop, "Before Cycles", "Maximum number of cycles to allow before first keyframe. (0 = infinite)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
        /* after */
-       prop= RNA_def_property(srna, "after_mode", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "mode_after", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "after_mode");
        RNA_def_property_enum_items(prop, prop_type_items);
        RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "after_cycles", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "cycles_after", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "after_cycles");
        RNA_def_property_ui_text(prop, "After Cycles", "Maximum number of cycles to allow after last keyframe. (0 = infinite)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 }
@@ -774,45 +813,45 @@ static void rna_def_fmodifier_limits(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Limits F-Modifier", "Limits the time/value ranges of the modified F-Curve");
        RNA_def_struct_sdna_from(srna, "FMod_Limits", "data");
        
-       prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
        RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
        RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
        RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
        RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_minx_range");
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_miny_range");
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxx_range");
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxy_range");
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
@@ -837,14 +876,15 @@ static void rna_def_fmodifier_noise(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Noise F-Modifier", "Gives randomness to the modified F-Curve");
        RNA_def_struct_sdna_from(srna, "FMod_Noise", "data");
        
-       prop= RNA_def_property(srna, "modification", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "modification");
        RNA_def_property_enum_items(prop, prop_modification_items);
-       RNA_def_property_ui_text(prop, "Modification", "Method of modifying the existing F-Curve");
+       RNA_def_property_ui_text(prop, "Blend Type", "Method of modifying the existing F-Curve");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "size");
-       RNA_def_property_ui_text(prop, "Size", "Scaling (in time) of the noise");
+       RNA_def_property_ui_text(prop, "Scale", "Scaling (in time) of the noise");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
        prop= RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
@@ -876,11 +916,12 @@ static void rna_def_fmodifier_stepped(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Stepped", "data");
        
        /* properties */
-       prop= RNA_def_property(srna, "step_size", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "frame_step", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "step_size");
        RNA_def_property_ui_text(prop, "Step Size", "Number of frames to hold each value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "frame_offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "offset");
        RNA_def_property_ui_text(prop, "Offset", "Reference number of frames before frames get held. Use to get hold for '1-3' vs '5-7' holding patterns");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -946,9 +987,9 @@ static void rna_def_fmodifier(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
        RNA_def_property_ui_icon(prop, ICON_MUTE_IPO_OFF, 1);
        
-       prop= RNA_def_property(srna, "disabled", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-       RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
        RNA_def_property_ui_text(prop, "Disabled", "F-Curve Modifier has invalid settings and will not be evaluated");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
        
@@ -1019,7 +1060,7 @@ static void rna_def_drivertarget(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Type", "Driver variable type");
        RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
        
-       prop= RNA_def_property(srna, "use_local_space_transforms", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_local_space_transform", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", DTAR_FLAG_LOCALSPACE);
        RNA_def_property_ui_text(prop, "Local Space", "Use transforms in Local Space (as opposed to the worldspace default)");
        RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
@@ -1088,10 +1129,11 @@ static void rna_def_channeldriver_variables(BlenderRNA *brna, PropertyRNA *cprop
 
        /* remove variable */
        func= RNA_def_function(srna, "remove", "rna_Driver_remove_variable");
-               RNA_def_function_ui_description(func, "Remove an existing variable from the driver.");
-               /* target to remove */
-       parm= RNA_def_pointer(func, "var", "DriverVariable", "", "Variable to remove from the driver.");
-               RNA_def_property_flag(parm, PROP_REQUIRED);
+       RNA_def_function_ui_description(func, "Remove an existing variable from the driver.");
+       RNA_def_function_flag(func, FUNC_USE_REPORTS);
+       /* target to remove */
+       parm= RNA_def_pointer(func, "variable", "DriverVariable", "", "Variable to remove from the driver.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 }
 
 static void rna_def_channeldriver(BlenderRNA *brna)
@@ -1135,8 +1177,8 @@ static void rna_def_channeldriver(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Show Debug Info", "Show intermediate values for the driver calculations to allow debugging of drivers");
        
        /* State Info (for Debugging) */
-       prop= RNA_def_property(srna, "invalid", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "flag", DRIVER_FLAG_INVALID);
+       prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", DRIVER_FLAG_INVALID);
        RNA_def_property_ui_text(prop, "Invalid", "Driver could not be evaluated in past, so should be skipped");
        
        
@@ -1199,13 +1241,13 @@ static void rna_def_fkeyframe(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_SELECTED, NULL);
        
        /* Enums */
-       prop= RNA_def_property(srna, "handle1_type", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "h1");
        RNA_def_property_enum_items(prop, beztriple_handle_type_items);
        RNA_def_property_ui_text(prop, "Handle 1 Type", "Handle types");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
        
-       prop= RNA_def_property(srna, "handle2_type", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "h2");
        RNA_def_property_enum_items(prop, beztriple_handle_type_items);
        RNA_def_property_ui_text(prop, "Handle 2 Type", "Handle types");
@@ -1224,7 +1266,7 @@ static void rna_def_fkeyframe(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
        
        /* Vector values */
-       prop= RNA_def_property(srna, "handle1", PROP_FLOAT, PROP_TRANSLATION);
+       prop= RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
        RNA_def_property_array(prop, 2);
        RNA_def_property_float_funcs(prop, "rna_FKeyframe_handle1_get", "rna_FKeyframe_handle1_set", NULL);
        RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
@@ -1236,7 +1278,7 @@ static void rna_def_fkeyframe(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "handle2", PROP_FLOAT, PROP_TRANSLATION);
+       prop= RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
        RNA_def_property_array(prop, 2);
        RNA_def_property_float_funcs(prop, "rna_FKeyframe_handle2_get", "rna_FKeyframe_handle2_set", NULL);
        RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
@@ -1276,13 +1318,11 @@ static void rna_def_fcurve_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_property_flag(parm, PROP_REQUIRED);
 
        func= RNA_def_function(srna, "remove", "rna_FCurve_modifiers_remove");
+       RNA_def_function_flag(func, FUNC_USE_REPORTS);
        RNA_def_function_ui_description(func, "Remove a modifier from this fcurve.");
-       /* return type */
-       parm= RNA_def_boolean(func, "success", 0, "Success", "Removed the constraint successfully.");
-       RNA_def_function_return(func, parm);
-       /* object to add */
-       parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
-       RNA_def_property_flag(parm, PROP_REQUIRED);
+       /* modifier to remove */
+       parm= RNA_def_pointer(func, "modifier", "FModifier", "", "Removed modifier.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 }
 
 /* fcurve.keyframe_points */
@@ -1293,25 +1333,32 @@ static void rna_def_fcurve_keyframe_points(BlenderRNA *brna, PropertyRNA *cprop)
        FunctionRNA *func;
        PropertyRNA *parm;
 
+       static EnumPropertyItem keyframe_flag_items[] = {
+               {INSERTKEY_REPLACE, "REPLACE", 0, "Replace", "Don't add any new keyframes, but just replace existing ones"},
+               {INSERTKEY_NEEDED, "NEEDED", 0, "Needed", "Only adds keyframes that are needed"},
+               {INSERTKEY_FAST, "FAST", 0, "Fast", "Fast keyframe insertion to avoid recalculating the curve each time"},
+               {0, NULL, 0, NULL, NULL}};
+
        RNA_def_property_srna(cprop, "FCurveKeyframePoints");
        srna= RNA_def_struct(brna, "FCurveKeyframePoints", NULL);
        RNA_def_struct_sdna(srna, "FCurve");
        RNA_def_struct_ui_text(srna, "Keyframe Points", "Collection of keyframe points");
 
-       func= RNA_def_function(srna, "add", "rna_FKeyframe_points_add");
+       func= RNA_def_function(srna, "insert", "rna_FKeyframe_points_insert");
        RNA_def_function_ui_description(func, "Add a keyframe point to a F-Curve.");
        parm= RNA_def_float(func, "frame", 0.0f, -FLT_MAX, FLT_MAX, "", "X Value of this keyframe point", -FLT_MAX, FLT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
        parm= RNA_def_float(func, "value", 0.0f, -FLT_MAX, FLT_MAX, "", "Y Value of this keyframe point", -FLT_MAX, FLT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
-       /* optional */
-       parm= RNA_def_boolean(func, "replace", 0, "Replace", "Replace existing keyframes");
-       parm= RNA_def_boolean(func, "needed", 0, "Needed", "Only adds keyframes that are needed");
-       parm= RNA_def_boolean(func, "fast", 0, "Fast", "Fast keyframe insertion to avoid recalculating the curve each time");
+
+       RNA_def_enum_flag(func, "options", keyframe_flag_items, 0, "", "Keyframe options.");
 
        parm= RNA_def_pointer(func, "keyframe", "Keyframe", "", "Newly created keyframe");
        RNA_def_function_return(func, parm);
 
+       func= RNA_def_function(srna, "add", "rna_FKeyframe_points_add");
+       RNA_def_function_ui_description(func, "Add a keyframe point to a F-Curve.");
+       RNA_def_int(func, "count", 1, 1, INT_MAX, "Number", "Number of points to add to the spline", 1, INT_MAX);
 
        func= RNA_def_function(srna, "remove", "rna_FKeyframe_points_remove");
        RNA_def_function_ui_description(func, "Remove keyframe from an fcurve.");
@@ -1319,7 +1366,7 @@ static void rna_def_fcurve_keyframe_points(BlenderRNA *brna, PropertyRNA *cprop)
        parm= RNA_def_pointer(func, "keyframe", "Keyframe", "", "Keyframe to remove.");
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
        /* optional */
-       parm= RNA_def_boolean(func, "fast", 0, "Fast", "Fast keyframe removal to avoid recalculating the curve each time");
+       RNA_def_boolean(func, "fast", 0, "Fast", "Fast keyframe removal to avoid recalculating the curve each time");
 }
 
 static void rna_def_fcurve(BlenderRNA *brna)
@@ -1380,6 +1427,7 @@ static void rna_def_fcurve(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_array(prop, 3);
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Color", "Color of the F-Curve in the Graph Editor");
        RNA_def_property_update(prop, NC_ANIMATION, NULL);      
        
@@ -1399,7 +1447,7 @@ static void rna_def_fcurve(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Muted", "F-Curve is not evaluated");
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "auto_clamped_handles", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_auto_handle_clamp", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCURVE_AUTO_HANDLES);
        RNA_def_property_ui_text(prop, "Auto Clamped Handles", "All auto-handles for F-Curve are clamped");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
@@ -1410,9 +1458,9 @@ static void rna_def_fcurve(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_GRAPH, NULL);
 
        /* State Info (for Debugging) */
-       prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", FCURVE_DISABLED);
-       RNA_def_property_ui_text(prop, "Enabled", "False when F-Curve could not be evaluated in past, so should be skipped when evaluating");
+       RNA_def_property_ui_text(prop, "Valid", "False when F-Curve could not be evaluated in past, so should be skipped when evaluating");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
        
        /* Collections */
@@ -1438,7 +1486,7 @@ static void rna_def_fcurve(BlenderRNA *brna)
        parm= RNA_def_float(func, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame", "Evaluate fcurve at given frame", -FLT_MAX, FLT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
        /* return value */
-       parm= RNA_def_float(func, "position", 0, -FLT_MAX, FLT_MAX, "Position", "Fcurve position", -FLT_MAX, FLT_MAX);
+       parm= RNA_def_float(func, "position", 0, -FLT_MAX, FLT_MAX, "Position", "FCurve position", -FLT_MAX, FLT_MAX);
        RNA_def_function_return(func, parm);
 
        func= RNA_def_function(srna, "range", "rna_fcurve_range");