And more UI messages spell check.
[blender.git] / source / blender / blenkernel / intern / fmodifier.c
index dcf81c194798573be58e030038684c5d137517aa..1e6eb77f6665193e9f7f979af29702cc2970b445 100644 (file)
@@ -1,6 +1,4 @@
 /*
 /*
- * $Id$
- *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
 
 #include "DNA_anim_types.h"
 
 
 #include "DNA_anim_types.h"
 
+#include "BLF_translation.h"
+
 #include "BLI_blenlib.h"
 #include "BLI_blenlib.h"
+#include "BLI_noise.h"
 #include "BLI_math.h" /* windows needs for M_PI */
 #include "BLI_utildefines.h"
 
 #include "BKE_fcurve.h"
 #include "BKE_idprop.h"
 
 #include "BLI_math.h" /* windows needs for M_PI */
 #include "BLI_utildefines.h"
 
 #include "BKE_fcurve.h"
 #include "BKE_idprop.h"
 
-
-#define SMALL -1.0e-10
-#define SELECT 1
-
 /* ******************************** F-Modifiers ********************************* */
 
 /* Info ------------------------------- */
 /* ******************************** F-Modifiers ********************************* */
 
 /* Info ------------------------------- */
  */
  
 /* Template for type-info data:
  */
  
 /* Template for type-info data:
- *     - make a copy of this when creating new modifiers, and just change the functions
- *       pointed to as necessary
- *     - although the naming of functions doesn't matter, it would help for code
- *       readability, to follow the same naming convention as is presented here
- *     - any functions that a constraint doesn't need to define, don't define
- *       for such cases, just use NULL 
- *     - these should be defined after all the functions have been defined, so that
- *       forward-definitions/prototypes don't need to be used!
+ *  - make a copy of this when creating new modifiers, and just change the functions
+ *    pointed to as necessary
+ *  - although the naming of functions doesn't matter, it would help for code
+ *    readability, to follow the same naming convention as is presented here
+ *  - any functions that a constraint doesn't need to define, don't define
+ *    for such cases, just use NULL 
+ *  - these should be defined after all the functions have been defined, so that
+ *    forward-definitions/prototypes don't need to be used!
  *     - keep this copy #if-def'd so that future constraints can get based off this
  */
 #if 0
  *     - keep this copy #if-def'd so that future constraints can get based off this
  */
 #if 0
@@ -99,74 +96,74 @@ static FModifierTypeInfo FMI_MODNAME = {
 /* Generator F-Curve Modifier --------------------------- */
 
 /* Generators available:
 /* Generator F-Curve Modifier --------------------------- */
 
 /* Generators available:
- *     1) simple polynomial generator:
+ *  1) simple polynomial generator:
  *             - Exanded form - (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n])  
  *             - Exanded form - (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n])  
- *             - Factorised form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
+ *             - Factorized form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
  */
 
  */
 
-static void fcm_generator_free (FModifier *fcm)
+static void fcm_generator_free(FModifier *fcm)
 {
 {
-       FMod_Generator *data= (FMod_Generator *)fcm->data;
+       FMod_Generator *data = (FMod_Generator *)fcm->data;
        
        /* free polynomial coefficients array */
        if (data->coefficients)
                MEM_freeN(data->coefficients);
 }
 
        
        /* free polynomial coefficients array */
        if (data->coefficients)
                MEM_freeN(data->coefficients);
 }
 
-static void fcm_generator_copy (FModifier *fcm, FModifier *src)
+static void fcm_generator_copy(FModifier *fcm, FModifier *src)
 {
 {
-       FMod_Generator *gen= (FMod_Generator *)fcm->data;
-       FMod_Generator *ogen= (FMod_Generator *)src->data;
+       FMod_Generator *gen = (FMod_Generator *)fcm->data;
+       FMod_Generator *ogen = (FMod_Generator *)src->data;
        
        /* copy coefficients array? */
        if (ogen->coefficients)
        
        /* copy coefficients array? */
        if (ogen->coefficients)
-               gen->coefficients= MEM_dupallocN(ogen->coefficients);
+               gen->coefficients = MEM_dupallocN(ogen->coefficients);
 }
 
 }
 
-static void fcm_generator_new_data (void *mdata)
+static void fcm_generator_new_data(void *mdata)
 {
 {
-       FMod_Generator *data= (FMod_Generator *)mdata;
+       FMod_Generator *data = (FMod_Generator *)mdata;
        float *cp;
        
        /* set default generator to be linear 0-1 (gradient = 1, y-offset = 0) */
        float *cp;
        
        /* set default generator to be linear 0-1 (gradient = 1, y-offset = 0) */
-       data->poly_order= 1;
-       data->arraysize= 2;
-       cp= data->coefficients= MEM_callocN(sizeof(float)*2, "FMod_Generator_Coefs");
+       data->poly_order = 1;
+       data->arraysize = 2;
+       cp = data->coefficients = MEM_callocN(sizeof(float) * 2, "FMod_Generator_Coefs");
        cp[0] = 0; // y-offset 
        cp[1] = 1; // gradient
 }
 
        cp[0] = 0; // y-offset 
        cp[1] = 1; // gradient
 }
 
-static void fcm_generator_verify (FModifier *fcm)
+static void fcm_generator_verify(FModifier *fcm)
 {
 {
-       FMod_Generator *data= (FMod_Generator *)fcm->data;
+       FMod_Generator *data = (FMod_Generator *)fcm->data;
        
        /* requirements depend on mode */
        switch (data->mode) {
                case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
                {
                        /* arraysize needs to be order+1, so resize if not */
        
        /* requirements depend on mode */
        switch (data->mode) {
                case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
                {
                        /* arraysize needs to be order+1, so resize if not */
-                       if (data->arraysize != (data->poly_order+1)) {
+                       if (data->arraysize != (data->poly_order + 1)) {
                                float *nc;
                                
                                /* make new coefficients array, and copy over as much data as can fit */
                                float *nc;
                                
                                /* make new coefficients array, and copy over as much data as can fit */
-                               nc= MEM_callocN(sizeof(float)*(data->poly_order+1), "FMod_Generator_Coefs");
+                               nc = MEM_callocN(sizeof(float) * (data->poly_order + 1), "FMod_Generator_Coefs");
                                
                                if (data->coefficients) {
                                
                                if (data->coefficients) {
-                                       if ((int)data->arraysize > (data->poly_order+1))
-                                               memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order+1));
+                                       if ((int)data->arraysize > (data->poly_order + 1))
+                                               memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order + 1));
                                        else
                                        else
-                                               memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
+                                               memcpy(nc, data->coefficients, sizeof(float) * data->arraysize);
                                                
                                        /* free the old data */
                                        MEM_freeN(data->coefficients);
                                }       
                                
                                /* set the new data */
                                                
                                        /* free the old data */
                                        MEM_freeN(data->coefficients);
                                }       
                                
                                /* set the new data */
-                               data->coefficients= nc;
-                               data->arraysize= data->poly_order+1;
+                               data->coefficients = nc;
+                               data->arraysize = data->poly_order + 1;
                        }
                }
                        }
                }
-                       break;
+               break;
                
                case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
                {
                
                case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
                {
@@ -175,55 +172,55 @@ static void fcm_generator_verify (FModifier *fcm)
                                float *nc;
                                
                                /* make new coefficients array, and copy over as much data as can fit */
                                float *nc;
                                
                                /* make new coefficients array, and copy over as much data as can fit */
-                               nc= MEM_callocN(sizeof(float)*(data->poly_order*2), "FMod_Generator_Coefs");
+                               nc = MEM_callocN(sizeof(float) * (data->poly_order * 2), "FMod_Generator_Coefs");
                                
                                if (data->coefficients) {
                                        if (data->arraysize > (unsigned int)(data->poly_order * 2))
                                
                                if (data->coefficients) {
                                        if (data->arraysize > (unsigned int)(data->poly_order * 2))
-                                               memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order * 2));
+                                               memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order * 2));
                                        else
                                        else
-                                               memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
+                                               memcpy(nc, data->coefficients, sizeof(float) * data->arraysize);
                                                
                                        /* free the old data */
                                        MEM_freeN(data->coefficients);
                                }       
                                
                                /* set the new data */
                                                
                                        /* free the old data */
                                        MEM_freeN(data->coefficients);
                                }       
                                
                                /* set the new data */
-                               data->coefficients= nc;
-                               data->arraysize= data->poly_order * 2;
+                               data->coefficients = nc;
+                               data->arraysize = data->poly_order * 2;
                        }
                }
                        }
                }
-                       break;  
+               break;
        }
 }
 
        }
 }
 
-static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_generator_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
 {
-       FMod_Generator *data= (FMod_Generator *)fcm->data;
+       FMod_Generator *data = (FMod_Generator *)fcm->data;
        
        
-       /* behaviour depends on mode 
+       /* behavior depends on mode 
         * NOTE: the data in its default state is fine too
         */
        switch (data->mode) {
                case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
                {
                        /* we overwrite cvalue with the sum of the polynomial */
         * NOTE: the data in its default state is fine too
         */
        switch (data->mode) {
                case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
                {
                        /* we overwrite cvalue with the sum of the polynomial */
-                       float *powers = MEM_callocN(sizeof(float)*data->arraysize, "Poly Powers");
-                       float value= 0.0f;
+                       float *powers = MEM_callocN(sizeof(float) * data->arraysize, "Poly Powers");
+                       float value = 0.0f;
                        unsigned int i;
                        
                        /* for each x^n, precalculate value based on previous one first... this should be 
                         * faster that calling pow() for each entry
                         */
                        unsigned int i;
                        
                        /* for each x^n, precalculate value based on previous one first... this should be 
                         * faster that calling pow() for each entry
                         */
-                       for (i=0; i < data->arraysize; i++) {
+                       for (i = 0; i < data->arraysize; i++) {
                                /* first entry is x^0 = 1, otherwise, calculate based on previous */
                                if (i)
                                /* first entry is x^0 = 1, otherwise, calculate based on previous */
                                if (i)
-                                       powers[i]= powers[i-1] * evaltime;
+                                       powers[i] = powers[i - 1] * evaltime;
                                else
                                else
-                                       powers[0]= 1;
+                                       powers[0] = 1;
                        }
                        
                        /* for each coefficient, add to value, which we'll write to *cvalue in one go */
                        }
                        
                        /* for each coefficient, add to value, which we'll write to *cvalue in one go */
-                       for (i=0; i < data->arraysize; i++)
+                       for (i = 0; i < data->arraysize; i++)
                                value += data->coefficients[i] * powers[i];
                        
                        /* only if something changed, write *cvalue in one go */
                                value += data->coefficients[i] * powers[i];
                        
                        /* only if something changed, write *cvalue in one go */
@@ -231,33 +228,33 @@ static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *
                                if (data->flag & FCM_GENERATOR_ADDITIVE)
                                        *cvalue += value;
                                else
                                if (data->flag & FCM_GENERATOR_ADDITIVE)
                                        *cvalue += value;
                                else
-                                       *cvalue= value;
+                                       *cvalue = value;
                        }
                                
                        /* cleanup */
                        if (powers) 
                                MEM_freeN(powers);
                }
                        }
                                
                        /* cleanup */
                        if (powers) 
                                MEM_freeN(powers);
                }
-                       break;
+               break;
                        
                        
-               case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* factorised polynomial */
+               case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* Factorized polynomial */
                {
                {
-                       float value= 1.0f, *cp=NULL;
+                       float value = 1.0f, *cp = NULL;
                        unsigned int i;
                        
                        /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */
                        unsigned int i;
                        
                        /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */
-                       for (cp=data->coefficients, i=0; (cp) && (i < (unsigned int)data->poly_order); cp+=2, i++) 
-                               value *= (cp[0]*evaltime + cp[1]);
+                       for (cp = data->coefficients, i = 0; (cp) && (i < (unsigned int)data->poly_order); cp += 2, i++)
+                               value *= (cp[0] * evaltime + cp[1]);
                                
                        /* only if something changed, write *cvalue in one go */
                        if (data->poly_order) {
                                if (data->flag & FCM_GENERATOR_ADDITIVE)
                                        *cvalue += value;
                                else
                                
                        /* only if something changed, write *cvalue in one go */
                        if (data->poly_order) {
                                if (data->flag & FCM_GENERATOR_ADDITIVE)
                                        *cvalue += value;
                                else
-                                       *cvalue= value;
+                                       *cvalue = value;
                        }
                }
                        }
                }
-                       break;
+               break;
        }
 }
 
        }
 }
 
@@ -266,7 +263,7 @@ static FModifierTypeInfo FMI_GENERATOR = {
        sizeof(FMod_Generator), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_NOTHING, /* requirements */
        sizeof(FMod_Generator), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_NOTHING, /* requirements */
-       "Generator", /* name */
+       N_("Generator"), /* name */
        "FMod_Generator", /* struct name */
        fcm_generator_free, /* free data */
        fcm_generator_copy, /* copy data */
        "FMod_Generator", /* struct name */
        fcm_generator_free, /* free data */
        fcm_generator_copy, /* copy data */
@@ -279,29 +276,29 @@ static FModifierTypeInfo FMI_GENERATOR = {
 /* Built-In Function Generator F-Curve Modifier --------------------------- */
 
 /* This uses the general equation for equations:
 /* Built-In Function Generator F-Curve Modifier --------------------------- */
 
 /* This uses the general equation for equations:
- *             y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset
+ *   y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset
  *
  * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients,
  * x is the evaluation 'time', and 'y' is the resultant value
  *
  * Functions available are
  *
  * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients,
  * x is the evaluation 'time', and 'y' is the resultant value
  *
  * Functions available are
- *     sin, cos, tan, sinc (normalised sin), natural log, square root 
+ *     sin, cos, tan, sinc (normalized sin), natural log, square root 
  */
 
  */
 
-static void fcm_fn_generator_new_data (void *mdata)
+static void fcm_fn_generator_new_data(void *mdata)
 {
 {
-       FMod_FunctionGenerator *data= (FMod_FunctionGenerator *)mdata;
+       FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)mdata;
        
        /* set amplitude and phase multiplier to 1.0f so that something is generated */
        
        /* set amplitude and phase multiplier to 1.0f so that something is generated */
-       data->amplitude= 1.0f;
-       data->phase_multiplier= 1.0f;
+       data->amplitude = 1.0f;
+       data->phase_multiplier = 1.0f;
 }
 
 }
 
-/* Unary 'normalised sine' function
- *     y = sin(PI + x) / (PI * x),
+/* Unary 'normalized sine' function
+ *  y = sin(PI + x) / (PI * x),
  * except for x = 0 when y = 1.
  */
  * except for x = 0 when y = 1.
  */
-static double sinc (double x)
+static double sinc(double x)
 {
        if (fabs(x) < 0.0001)
                return 1.0;
 {
        if (fabs(x) < 0.0001)
                return 1.0;
@@ -309,77 +306,76 @@ static double sinc (double x)
                return sin(M_PI * x) / (M_PI * x);
 }
 
                return sin(M_PI * x) / (M_PI * x);
 }
 
-static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_fn_generator_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
 {
-       FMod_FunctionGenerator *data= (FMod_FunctionGenerator *)fcm->data;
-       double arg= data->phase_multiplier*evaltime + data->phase_offset;
+       FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)fcm->data;
+       double arg = data->phase_multiplier * evaltime + data->phase_offset;
        double (*fn)(double v) = NULL;
        
        /* get function pointer to the func to use:
         * WARNING: must perform special argument validation hereto guard against crashes  
         */
        double (*fn)(double v) = NULL;
        
        /* get function pointer to the func to use:
         * WARNING: must perform special argument validation hereto guard against crashes  
         */
-       switch (data->type)
-       {
+       switch (data->type) {
                /* simple ones */                       
                case FCM_GENERATOR_FN_SIN: /* sine wave */
                /* simple ones */                       
                case FCM_GENERATOR_FN_SIN: /* sine wave */
-                       fn= sin;
+                       fn = sin;
                        break;
                case FCM_GENERATOR_FN_COS: /* cosine wave */
                        break;
                case FCM_GENERATOR_FN_COS: /* cosine wave */
-                       fn= cos;
+                       fn = cos;
                        break;
                        break;
-               case FCM_GENERATOR_FN_SINC: /* normalised sine wave */
-                       fn= sinc;
+               case FCM_GENERATOR_FN_SINC: /* normalized sine wave */
+                       fn = sinc;
                        break;
                        
                /* validation required */
                case FCM_GENERATOR_FN_TAN: /* tangent wave */
                {
                        /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */
                        break;
                        
                /* validation required */
                case FCM_GENERATOR_FN_TAN: /* tangent wave */
                {
                        /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */
-                       if IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0) {
+                       if (IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0)) {
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
-                                       *cvalue = 0.0f; /* no value possible here */
+                                       *cvalue = 0.0f;  /* no value possible here */
                        }
                        else
                        }
                        else
-                               fn= tan;
+                               fn = tan;
                }
                }
-                       break;
+               break;
                case FCM_GENERATOR_FN_LN: /* natural log */
                {
                        /* check that value is greater than 1? */
                        if (arg > 1.0) {
                case FCM_GENERATOR_FN_LN: /* natural log */
                {
                        /* check that value is greater than 1? */
                        if (arg > 1.0) {
-                               fn= log;
+                               fn = log;
                        }
                        else {
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
                        }
                        else {
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
-                                       *cvalue = 0.0f; /* no value possible here */
+                                       *cvalue = 0.0f;  /* no value possible here */
                        }
                }
                        }
                }
-                       break;
+               break;
                case FCM_GENERATOR_FN_SQRT: /* square root */
                {
                        /* no negative numbers */
                        if (arg > 0.0) {
                case FCM_GENERATOR_FN_SQRT: /* square root */
                {
                        /* no negative numbers */
                        if (arg > 0.0) {
-                               fn= sqrt;
+                               fn = sqrt;
                        }
                        else {
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
                        }
                        else {
                                if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
-                                       *cvalue = 0.0f; /* no value possible here */
+                                       *cvalue = 0.0f;  /* no value possible here */
                        }
                }
                        }
                }
-                       break;
+               break;
                
                default:
                
                default:
-                       printf("Invalid Function-Generator for F-Modifier - %d \n", data->type);
+                       printf("Invalid Function-Generator for F-Modifier - %d\n", data->type);
        }
        
        /* execute function callback to set value if appropriate */
        if (fn) {
        }
        
        /* execute function callback to set value if appropriate */
        if (fn) {
-               float value= (float)(data->amplitude*(float)fn(arg) + data->value_offset);
+               float value = (float)(data->amplitude * (float)fn(arg) + data->value_offset);
                
                if (data->flag & FCM_GENERATOR_ADDITIVE)
                        *cvalue += value;
                else
                
                if (data->flag & FCM_GENERATOR_ADDITIVE)
                        *cvalue += value;
                else
-                       *cvalue= value;
+                       *cvalue = value;
        }
 }
 
        }
 }
 
@@ -388,7 +384,7 @@ static FModifierTypeInfo FMI_FN_GENERATOR = {
        sizeof(FMod_FunctionGenerator), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_NOTHING, /* requirements */
        sizeof(FMod_FunctionGenerator), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_NOTHING, /* requirements */
-       "Built-In Function", /* name */
+       N_("Built-In Function"), /* name */
        "FMod_FunctionGenerator", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_FunctionGenerator", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -400,82 +396,82 @@ static FModifierTypeInfo FMI_FN_GENERATOR = {
 
 /* Envelope F-Curve Modifier --------------------------- */
 
 
 /* Envelope F-Curve Modifier --------------------------- */
 
-static void fcm_envelope_free (FModifier *fcm)
+static void fcm_envelope_free(FModifier *fcm)
 {
 {
-       FMod_Envelope *env= (FMod_Envelope *)fcm->data;
+       FMod_Envelope *env = (FMod_Envelope *)fcm->data;
        
        /* free envelope data array */
        if (env->data)
                MEM_freeN(env->data);
 }
 
        
        /* free envelope data array */
        if (env->data)
                MEM_freeN(env->data);
 }
 
-static void fcm_envelope_copy (FModifier *fcm, FModifier *src)
+static void fcm_envelope_copy(FModifier *fcm, FModifier *src)
 {
 {
-       FMod_Envelope *env= (FMod_Envelope *)fcm->data;
-       FMod_Envelope *oenv= (FMod_Envelope *)src->data;
+       FMod_Envelope *env = (FMod_Envelope *)fcm->data;
+       FMod_Envelope *oenv = (FMod_Envelope *)src->data;
        
        /* copy envelope data array */
        if (oenv->data)
        
        /* copy envelope data array */
        if (oenv->data)
-               env->data= MEM_dupallocN(oenv->data);
+               env->data = MEM_dupallocN(oenv->data);
 }
 
 }
 
-static void fcm_envelope_new_data (void *mdata)
+static void fcm_envelope_new_data(void *mdata)
 {
 {
-       FMod_Envelope *env= (FMod_Envelope *)mdata;
+       FMod_Envelope *env = (FMod_Envelope *)mdata;
        
        /* set default min/max ranges */
        
        /* set default min/max ranges */
-       env->min= -1.0f;
-       env->max= 1.0f;
+       env->min = -1.0f;
+       env->max = 1.0f;
 }
 
 }
 
-static void fcm_envelope_verify (FModifier *fcm)
+static void fcm_envelope_verify(FModifier *fcm)
 {
 {
-       FMod_Envelope *env= (FMod_Envelope *)fcm->data;
+       FMod_Envelope *env = (FMod_Envelope *)fcm->data;
        
        /* if the are points, perform bubble-sort on them, as user may have changed the order */
        if (env->data) {
        
        /* if the are points, perform bubble-sort on them, as user may have changed the order */
        if (env->data) {
-               // XXX todo...
+               /* XXX todo... */
        }
 }
 
        }
 }
 
-static void fcm_envelope_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_envelope_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
 {
-       FMod_Envelope *env= (FMod_Envelope *)fcm->data;
+       FMod_Envelope *env = (FMod_Envelope *)fcm->data;
        FCM_EnvelopeData *fed, *prevfed, *lastfed;
        FCM_EnvelopeData *fed, *prevfed, *lastfed;
-       float min=0.0f, max=0.0f, fac=0.0f;
+       float min = 0.0f, max = 0.0f, fac = 0.0f;
        int a;
        
        /* get pointers */
        if (env->data == NULL) return;
        int a;
        
        /* get pointers */
        if (env->data == NULL) return;
-       prevfed= env->data;
-       fed= prevfed + 1;
-       lastfed= prevfed + (env->totvert-1);
+       prevfed = env->data;
+       fed = prevfed + 1;
+       lastfed = prevfed + (env->totvert - 1);
        
        /* get min/max values for envelope at evaluation time (relative to mid-value) */
        if (prevfed->time >= evaltime) {
                /* before or on first sample, so just extend value */
        
        /* get min/max values for envelope at evaluation time (relative to mid-value) */
        if (prevfed->time >= evaltime) {
                /* before or on first sample, so just extend value */
-               min= prevfed->min;
-               max= prevfed->max;
+               min = prevfed->min;
+               max = prevfed->max;
        }
        else if (lastfed->time <= evaltime) {
                /* after or on last sample, so just extend value */
        }
        else if (lastfed->time <= evaltime) {
                /* after or on last sample, so just extend value */
-               min= lastfed->min;
-               max= lastfed->max;
+               min = lastfed->min;
+               max = lastfed->max;
        }
        else {
                /* evaltime occurs somewhere between segments */
        }
        else {
                /* evaltime occurs somewhere between segments */
-               // TODO: implement binary search for this to make it faster?
-               for (a=0; prevfed && fed && (a < env->totvert-1); a++, prevfed=fed, fed++) {  
+               /* TODO: implement binary search for this to make it faster? */
+               for (a = 0; prevfed && fed && (a < env->totvert - 1); a++, prevfed = fed, fed++) {
                        /* evaltime occurs within the interval defined by these two envelope points */
                        if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) {
                                float afac, bfac, diff;
                                
                        /* evaltime occurs within the interval defined by these two envelope points */
                        if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) {
                                float afac, bfac, diff;
                                
-                               diff= fed->time - prevfed->time;
-                               afac= (evaltime - prevfed->time) / diff;
-                               bfac= (fed->time - evaltime) / diff;
+                               diff = fed->time - prevfed->time;
+                               afac = (evaltime - prevfed->time) / diff;
+                               bfac = (fed->time - evaltime) / diff;
                                
                                
-                               min= bfac*prevfed->min + afac*fed->min;
-                               max= bfac*prevfed->max + afac*fed->max;
+                               min = bfac * prevfed->min + afac * fed->min;
+                               max = bfac * prevfed->max + afac * fed->max;
                                
                                break;
                        }
                                
                                break;
                        }
@@ -486,8 +482,8 @@ static void fcm_envelope_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *c
         *      - fac is the ratio of how the current y-value corresponds to the reference range
         *      - thus, the new value is found by mapping the old range to the new!
         */
         *      - fac is the ratio of how the current y-value corresponds to the reference range
         *      - thus, the new value is found by mapping the old range to the new!
         */
-       fac= (*cvalue - (env->midval + env->min)) / (env->max - env->min);
-       *cvalue= min + fac*(max - min); 
+       fac = (*cvalue - (env->midval + env->min)) / (env->max - env->min);
+       *cvalue = min + fac * (max - min);
 }
 
 static FModifierTypeInfo FMI_ENVELOPE = {
 }
 
 static FModifierTypeInfo FMI_ENVELOPE = {
@@ -495,7 +491,7 @@ static FModifierTypeInfo FMI_ENVELOPE = {
        sizeof(FMod_Envelope), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
        sizeof(FMod_Envelope), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
-       "Envelope", /* name */
+       N_("Envelope"), /* name */
        "FMod_Envelope", /* struct name */
        fcm_envelope_free, /* free data */
        fcm_envelope_copy, /* copy data */
        "FMod_Envelope", /* struct name */
        fcm_envelope_free, /* free data */
        fcm_envelope_copy, /* copy data */
@@ -508,37 +504,39 @@ static FModifierTypeInfo FMI_ENVELOPE = {
 /* Cycles F-Curve Modifier  --------------------------- */
 
 /* This modifier changes evaltime to something that exists within the curve's frame-range, 
 /* Cycles F-Curve Modifier  --------------------------- */
 
 /* This modifier changes evaltime to something that exists within the curve's frame-range, 
- * then re-evaluates modifier stack up to this point using the new time. This re-entrant behaviour
- * is very likely to be more time-consuming than the original approach... (which was tighly integrated into 
+ * then re-evaluates modifier stack up to this point using the new time. This re-entrant behavior
+ * is very likely to be more time-consuming than the original approach... (which was tightly integrated into
  * the calculation code...).
  *
  * the calculation code...).
  *
- * NOTE: this needs to be at the start of the stack to be of use, as it needs to know the extents of the keyframes/sample-data
- * Possible TODO - store length of cycle information that can be initialised from the extents of the keyframes/sample-data, and adjusted
- *                             as appropriate
+ * NOTE: this needs to be at the start of the stack to be of use, as it needs to know the extents of the
+ * keyframes/sample-data.
+ *
+ * Possible TODO - store length of cycle information that can be initialized from the extents of the
+ * keyframes/sample-data, and adjusted as appropriate.
  */
 
 /* temp data used during evaluation */
 typedef struct tFCMED_Cycles {
  */
 
 /* temp data used during evaluation */
 typedef struct tFCMED_Cycles {
-       float cycyofs;          /* y-offset to apply */
+       float cycyofs;      /* y-offset to apply */
 } tFCMED_Cycles;
  
 } tFCMED_Cycles;
  
-static void fcm_cycles_new_data (void *mdata)
+static void fcm_cycles_new_data(void *mdata)
 {
 {
-       FMod_Cycles *data= (FMod_Cycles *)mdata;
+       FMod_Cycles *data = (FMod_Cycles *)mdata;
        
        /* turn on cycles by default */
        
        /* turn on cycles by default */
-       data->before_mode= data->after_mode= FCM_EXTRAPOLATE_CYCLIC;
+       data->before_mode = data->after_mode = FCM_EXTRAPOLATE_CYCLIC;
 }
 
 }
 
-static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime)
+static float fcm_cycles_time(FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
 {
-       FMod_Cycles *data= (FMod_Cycles *)fcm->data;
-       float prevkey[2], lastkey[2], cycyofs=0.0f;
-       short side=0, mode=0;
-       int cycles=0, ofs=0;
+       FMod_Cycles *data = (FMod_Cycles *)fcm->data;
+       float prevkey[2], lastkey[2], cycyofs = 0.0f;
+       short side = 0, mode = 0;
+       int cycles = 0, ofs = 0;
        
        /* check if modifier is first in stack, otherwise disable ourself... */
        
        /* check if modifier is first in stack, otherwise disable ourself... */
-       // FIXME...
+       /* FIXME... */
        if (fcm->prev) {
                fcm->flag |= FMODIFIER_FLAG_DISABLED;
                return evaltime;
        if (fcm->prev) {
                fcm->flag |= FMODIFIER_FLAG_DISABLED;
                return evaltime;
@@ -546,24 +544,24 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue),
        
        /* calculate new evaltime due to cyclic interpolation */
        if (fcu && fcu->bezt) {
        
        /* calculate new evaltime due to cyclic interpolation */
        if (fcu && fcu->bezt) {
-               BezTriple *prevbezt= fcu->bezt;
-               BezTriple *lastbezt= prevbezt + fcu->totvert-1;
+               BezTriple *prevbezt = fcu->bezt;
+               BezTriple *lastbezt = prevbezt + fcu->totvert - 1;
                
                
-               prevkey[0]= prevbezt->vec[1][0];
-               prevkey[1]= prevbezt->vec[1][1];
+               prevkey[0] = prevbezt->vec[1][0];
+               prevkey[1] = prevbezt->vec[1][1];
                
                
-               lastkey[0]= lastbezt->vec[1][0];
-               lastkey[1]= lastbezt->vec[1][1];
+               lastkey[0] = lastbezt->vec[1][0];
+               lastkey[1] = lastbezt->vec[1][1];
        }
        else if (fcu && fcu->fpt) {
        }
        else if (fcu && fcu->fpt) {
-               FPoint *prevfpt= fcu->fpt;
-               FPoint *lastfpt= prevfpt + fcu->totvert-1;
+               FPoint *prevfpt = fcu->fpt;
+               FPoint *lastfpt = prevfpt + fcu->totvert - 1;
                
                
-               prevkey[0]= prevfpt->vec[0];
-               prevkey[1]= prevfpt->vec[1];
+               prevkey[0] = prevfpt->vec[0];
+               prevkey[1] = prevfpt->vec[1];
                
                
-               lastkey[0]= lastfpt->vec[0];
-               lastkey[1]= lastfpt->vec[1];
+               lastkey[0] = lastfpt->vec[0];
+               lastkey[1] = lastfpt->vec[1];
        }
        else
                return evaltime;
        }
        else
                return evaltime;
@@ -573,46 +571,46 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue),
         *      2) if before first frame or after last frame, make sure some cycling is in use
         */
        if (evaltime < prevkey[0]) {
         *      2) if before first frame or after last frame, make sure some cycling is in use
         */
        if (evaltime < prevkey[0]) {
-               if (data->before_mode)  {
-                       side= -1;
-                       mode= data->before_mode;
-                       cycles= data->before_cycles;
-                       ofs= prevkey[0];
+               if (data->before_mode) {
+                       side = -1;
+                       mode = data->before_mode;
+                       cycles = data->before_cycles;
+                       ofs = prevkey[0];
                }
        }
        else if (evaltime > lastkey[0]) {
                if (data->after_mode) {
                }
        }
        else if (evaltime > lastkey[0]) {
                if (data->after_mode) {
-                       side= 1;
-                       mode= data->after_mode;
-                       cycles= data->after_cycles;
-                       ofs= lastkey[0];
+                       side = 1;
+                       mode = data->after_mode;
+                       cycles = data->after_cycles;
+                       ofs = lastkey[0];
                }
        }
                }
        }
-       if ELEM(0, side, mode)
+       if ((ELEM(0, side, mode)))
                return evaltime;
                
        /* find relative place within a cycle */
        {
                return evaltime;
                
        /* find relative place within a cycle */
        {
-               float cycdx=0, cycdy=0;
-               float cycle= 0, cyct=0;
+               float cycdx = 0, cycdy = 0;
+               float cycle = 0, cyct = 0;
                
                /* calculate period and amplitude (total height) of a cycle */
                
                /* calculate period and amplitude (total height) of a cycle */
-               cycdx= lastkey[0] - prevkey[0];
-               cycdy= lastkey[1] - prevkey[1];
+               cycdx = lastkey[0] - prevkey[0];
+               cycdy = lastkey[1] - prevkey[1];
                
                /* check if cycle is infinitely small, to be point of being impossible to use */
                if (cycdx == 0)
                        return evaltime;
                        
                /* calculate the 'number' of the cycle */
                
                /* check if cycle is infinitely small, to be point of being impossible to use */
                if (cycdx == 0)
                        return evaltime;
                        
                /* calculate the 'number' of the cycle */
-               cycle= ((float)side * (evaltime - ofs) / cycdx);
-
+               cycle = ((float)side * (evaltime - ofs) / cycdx);
+               
                /* calculate the time inside the cycle */
                /* calculate the time inside the cycle */
-               cyct= fmod(evaltime - ofs, cycdx);
+               cyct = fmod(evaltime - ofs, cycdx);
                
                /* check that cyclic is still enabled for the specified time */
                if (cycles == 0) {
                
                /* check that cyclic is still enabled for the specified time */
                if (cycles == 0) {
-                       /* catch this case so that we don't exit when we have cycles=0
+                       /* catch this case so that we don't exit when we have (cycles = 0)
                         * as this indicates infinite cycles...
                         */
                }
                         * as this indicates infinite cycles...
                         */
                }
@@ -625,34 +623,34 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue),
                
                /* check if 'cyclic extrapolation', and thus calculate y-offset for this cycle */
                if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
                
                /* check if 'cyclic extrapolation', and thus calculate y-offset for this cycle */
                if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
-                       if(side < 0)
+                       if (side < 0)
                                cycyofs = (float)floor((evaltime - ofs) / cycdx);
                        else
                                cycyofs = (float)ceil((evaltime - ofs) / cycdx);
                        cycyofs *= cycdy;
                }
                                cycyofs = (float)floor((evaltime - ofs) / cycdx);
                        else
                                cycyofs = (float)ceil((evaltime - ofs) / cycdx);
                        cycyofs *= cycdy;
                }
-
+               
                /* special case for cycle start/end */
                /* special case for cycle start/end */
-               if(cyct == 0.0f) {
+               if (cyct == 0.0f) {
                        evaltime = (side == 1 ? lastkey[0] : prevkey[0]);
                        evaltime = (side == 1 ? lastkey[0] : prevkey[0]);
-
-                       if((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)cycle % 2))
+                       
+                       if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)cycle % 2))
                                evaltime = (side == 1 ? prevkey[0] : lastkey[0]);
                }
                /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
                                evaltime = (side == 1 ? prevkey[0] : lastkey[0]);
                }
                /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
-               else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle+1) % 2)) {
+               else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle + 1) % 2)) {
                        /* when 'mirror' option is used and cycle number is odd, this cycle is played in reverse 
                         *      - for 'before' extrapolation, we need to flip in a different way, otherwise values past
                         *        then end of the curve get referenced (result of fmod will be negative, and with different phase)
                         */
                        if (side < 0)
                        /* when 'mirror' option is used and cycle number is odd, this cycle is played in reverse 
                         *      - for 'before' extrapolation, we need to flip in a different way, otherwise values past
                         *        then end of the curve get referenced (result of fmod will be negative, and with different phase)
                         */
                        if (side < 0)
-                               evaltime= prevkey[0] - cyct;
+                               evaltime = prevkey[0] - cyct;
                        else
                        else
-                               evaltime= lastkey[0] - cyct;
+                               evaltime = lastkey[0] - cyct;
                }
                else {
                        /* the cycle is played normally... */
                }
                else {
                        /* the cycle is played normally... */
-                       evaltime= prevkey[0] + cyct;
+                       evaltime = prevkey[0] + cyct;
                }
                if (evaltime < prevkey[0]) evaltime += cycdx;
        }
                }
                if (evaltime < prevkey[0]) evaltime += cycdx;
        }
@@ -662,17 +660,17 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue),
                tFCMED_Cycles *edata;
                
                /* for now, this is just a float, but we could get more stuff... */
                tFCMED_Cycles *edata;
                
                /* for now, this is just a float, but we could get more stuff... */
-               fcm->edata= edata= MEM_callocN(sizeof(tFCMED_Cycles), "tFCMED_Cycles");
-               edata->cycyofs= cycyofs;
+               fcm->edata = edata = MEM_callocN(sizeof(tFCMED_Cycles), "tFCMED_Cycles");
+               edata->cycyofs = cycyofs;
        }
        
        /* return the new frame to evaluate */
        return evaltime;
 }
  
        }
        
        /* return the new frame to evaluate */
        return evaltime;
 }
  
-static void fcm_cycles_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
+static void fcm_cycles_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
 {
 {
-       tFCMED_Cycles *edata= (tFCMED_Cycles *)fcm->edata;
+       tFCMED_Cycles *edata = (tFCMED_Cycles *)fcm->edata;
        
        /* use temp data */
        if (edata) {
        
        /* use temp data */
        if (edata) {
@@ -681,7 +679,7 @@ static void fcm_cycles_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cva
                
                /* free temp data */
                MEM_freeN(edata);
                
                /* free temp data */
                MEM_freeN(edata);
-               fcm->edata= NULL;
+               fcm->edata = NULL;
        }
 }
 
        }
 }
 
@@ -690,7 +688,7 @@ static FModifierTypeInfo FMI_CYCLES = {
        sizeof(FMod_Cycles), /* size */
        FMI_TYPE_EXTRAPOLATION, /* action type */
        FMI_REQUIRES_ORIGINAL_DATA, /* requirements */
        sizeof(FMod_Cycles), /* size */
        FMI_TYPE_EXTRAPOLATION, /* action type */
        FMI_REQUIRES_ORIGINAL_DATA, /* requirements */
-       "Cycles", /* name */
+       N_("Cycles"), /* name */
        "FMod_Cycles", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_Cycles", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -702,21 +700,21 @@ static FModifierTypeInfo FMI_CYCLES = {
 
 /* Noise F-Curve Modifier  --------------------------- */
 
 
 /* Noise F-Curve Modifier  --------------------------- */
 
-static void fcm_noise_new_data (void *mdata)
+static void fcm_noise_new_data(void *mdata)
 {
 {
-       FMod_Noise *data= (FMod_Noise *)mdata;
+       FMod_Noise *data = (FMod_Noise *)mdata;
        
        /* defaults */
        
        /* defaults */
-       data->size= 1.0f;
-       data->strength= 1.0f;
-       data->phase= 1.0f;
+       data->size = 1.0f;
+       data->strength = 1.0f;
+       data->phase = 1.0f;
        data->depth = 0;
        data->modification = FCM_NOISE_MODIF_REPLACE;
 }
  
        data->depth = 0;
        data->modification = FCM_NOISE_MODIF_REPLACE;
 }
  
-static void fcm_noise_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_noise_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
 {
-       FMod_Noise *data= (FMod_Noise *)fcm->data;
+       FMod_Noise *data = (FMod_Noise *)fcm->data;
        float noise;
        
        /* generate noise using good ol' Blender Noise
        float noise;
        
        /* generate noise using good ol' Blender Noise
@@ -728,17 +726,17 @@ static void fcm_noise_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cval
        /* combine the noise with existing motion data */
        switch (data->modification) {
                case FCM_NOISE_MODIF_ADD:
        /* combine the noise with existing motion data */
        switch (data->modification) {
                case FCM_NOISE_MODIF_ADD:
-                       *cvalue= *cvalue + noise * data->strength;
+                       *cvalue = *cvalue + noise * data->strength;
                        break;
                case FCM_NOISE_MODIF_SUBTRACT:
                        break;
                case FCM_NOISE_MODIF_SUBTRACT:
-                       *cvalue= *cvalue - noise * data->strength;
+                       *cvalue = *cvalue - noise * data->strength;
                        break;
                case FCM_NOISE_MODIF_MULTIPLY:
                        break;
                case FCM_NOISE_MODIF_MULTIPLY:
-                       *cvalue= *cvalue * noise * data->strength;
+                       *cvalue = *cvalue * noise * data->strength;
                        break;
                case FCM_NOISE_MODIF_REPLACE:
                default:
                        break;
                case FCM_NOISE_MODIF_REPLACE:
                default:
-                       *cvalue= *cvalue + (noise - 0.5f) * data->strength;
+                       *cvalue = *cvalue + (noise - 0.5f) * data->strength;
                        break;
        }
 }
                        break;
        }
 }
@@ -748,7 +746,7 @@ static FModifierTypeInfo FMI_NOISE = {
        sizeof(FMod_Noise), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
        sizeof(FMod_Noise), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
-       "Noise", /* name */
+       N_("Noise"), /* name */
        "FMod_Noise", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_Noise", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -766,7 +764,7 @@ static FModifierTypeInfo FMI_FILTER = {
        sizeof(FMod_Filter), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
        sizeof(FMod_Filter), /* size */
        FMI_TYPE_REPLACE_VALUES, /* action type */
        0, /* requirements */
-       "Filter", /* name */
+       N_("Filter"), /* name */
        "FMod_Filter", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_Filter", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -780,25 +778,25 @@ static FModifierTypeInfo FMI_FILTER = {
 
 /* Python F-Curve Modifier --------------------------- */
 
 
 /* Python F-Curve Modifier --------------------------- */
 
-static void fcm_python_free (FModifier *fcm)
+static void fcm_python_free(FModifier *fcm)
 {
 {
-       FMod_Python *data= (FMod_Python *)fcm->data;
+       FMod_Python *data = (FMod_Python *)fcm->data;
        
        /* id-properties */
        IDP_FreeProperty(data->prop);
        MEM_freeN(data->prop);
 }
 
        
        /* id-properties */
        IDP_FreeProperty(data->prop);
        MEM_freeN(data->prop);
 }
 
-static void fcm_python_new_data (void *mdata) 
+static void fcm_python_new_data(void *mdata)
 {
 {
-       FMod_Python *data= (FMod_Python *)mdata;
+       FMod_Python *data = (FMod_Python *)mdata;
        
        /* everything should be set correctly by calloc, except for the prop->type constant.*/
        data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps");
        data->prop->type = IDP_GROUP;
 }
 
        
        /* everything should be set correctly by calloc, except for the prop->type constant.*/
        data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps");
        data->prop->type = IDP_GROUP;
 }
 
-static void fcm_python_copy (FModifier *fcm, FModifier *src)
+static void fcm_python_copy(FModifier *fcm, FModifier *src)
 {
        FMod_Python *pymod = (FMod_Python *)fcm->data;
        FMod_Python *opymod = (FMod_Python *)src->data;
 {
        FMod_Python *pymod = (FMod_Python *)fcm->data;
        FMod_Python *opymod = (FMod_Python *)src->data;
@@ -806,10 +804,10 @@ static void fcm_python_copy (FModifier *fcm, FModifier *src)
        pymod->prop = IDP_CopyProperty(opymod->prop);
 }
 
        pymod->prop = IDP_CopyProperty(opymod->prop);
 }
 
-static void fcm_python_evaluate (FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), float *UNUSED(cvalue), float UNUSED(evaltime))
+static void fcm_python_evaluate(FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), float *UNUSED(cvalue), float UNUSED(evaltime))
 {
 #ifdef WITH_PYTHON
 {
 #ifdef WITH_PYTHON
-       //FMod_Python *data= (FMod_Python *)fcm->data;
+       //FMod_Python *data = (FMod_Python *)fcm->data;
        
        /* FIXME... need to implement this modifier...
         *      It will need it execute a script using the custom properties 
        
        /* FIXME... need to implement this modifier...
         *      It will need it execute a script using the custom properties 
@@ -822,7 +820,7 @@ static FModifierTypeInfo FMI_PYTHON = {
        sizeof(FMod_Python), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
        sizeof(FMod_Python), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
-       "Python", /* name */
+       N_("Python"), /* name */
        "FMod_Python", /* struct name */
        fcm_python_free, /* free data */
        fcm_python_copy, /* copy data */
        "FMod_Python", /* struct name */
        fcm_python_free, /* free data */
        fcm_python_copy, /* copy data */
@@ -835,9 +833,9 @@ static FModifierTypeInfo FMI_PYTHON = {
 
 /* Limits F-Curve Modifier --------------------------- */
 
 
 /* Limits F-Curve Modifier --------------------------- */
 
-static float fcm_limits_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
+static float fcm_limits_time(FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
 {
-       FMod_Limits *data= (FMod_Limits *)fcm->data;
+       FMod_Limits *data = (FMod_Limits *)fcm->data;
        
        /* check for the time limits */
        if ((data->flag & FCM_LIMIT_XMIN) && (evaltime < data->rect.xmin))
        
        /* check for the time limits */
        if ((data->flag & FCM_LIMIT_XMIN) && (evaltime < data->rect.xmin))
@@ -849,15 +847,15 @@ static float fcm_limits_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(
        return evaltime;
 }
 
        return evaltime;
 }
 
-static void fcm_limits_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
+static void fcm_limits_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
 {
 {
-       FMod_Limits *data= (FMod_Limits *)fcm->data;
+       FMod_Limits *data = (FMod_Limits *)fcm->data;
        
        /* value limits now */
        if ((data->flag & FCM_LIMIT_YMIN) && (*cvalue < data->rect.ymin))
        
        /* value limits now */
        if ((data->flag & FCM_LIMIT_YMIN) && (*cvalue < data->rect.ymin))
-               *cvalue= data->rect.ymin;
+               *cvalue = data->rect.ymin;
        if ((data->flag & FCM_LIMIT_YMAX) && (*cvalue > data->rect.ymax))
        if ((data->flag & FCM_LIMIT_YMAX) && (*cvalue > data->rect.ymax))
-               *cvalue= data->rect.ymax;
+               *cvalue = data->rect.ymax;
 }
 
 static FModifierTypeInfo FMI_LIMITS = {
 }
 
 static FModifierTypeInfo FMI_LIMITS = {
@@ -865,7 +863,7 @@ static FModifierTypeInfo FMI_LIMITS = {
        sizeof(FMod_Limits), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */  /* XXX... err... */   
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
        sizeof(FMod_Limits), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */  /* XXX... err... */   
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
-       "Limits", /* name */
+       N_("Limits"), /* name */
        "FMod_Limits", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_Limits", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -877,18 +875,18 @@ static FModifierTypeInfo FMI_LIMITS = {
 
 /* Stepped F-Curve Modifier --------------------------- */
 
 
 /* Stepped F-Curve Modifier --------------------------- */
 
-static void fcm_stepped_new_data (void *mdata) 
+static void fcm_stepped_new_data(void *mdata)
 {
 {
-       FMod_Stepped *data= (FMod_Stepped *)mdata;
+       FMod_Stepped *data = (FMod_Stepped *)mdata;
        
        /* just need to set the step-size to 2-frames by default */
        
        /* just need to set the step-size to 2-frames by default */
-       // XXX: or would 5 be more normal?
+       /* XXX: or would 5 be more normal? */
        data->step_size = 2.0f;
 }
 
        data->step_size = 2.0f;
 }
 
-static float fcm_stepped_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
+static float fcm_stepped_time(FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
 {
-       FMod_Stepped *data= (FMod_Stepped *)fcm->data;
+       FMod_Stepped *data = (FMod_Stepped *)fcm->data;
        int snapblock;
        
        /* check range clamping to see if we should alter the timing to achieve the desired results */
        int snapblock;
        
        /* check range clamping to see if we should alter the timing to achieve the desired results */
@@ -918,7 +916,7 @@ static FModifierTypeInfo FMI_STEPPED = {
        sizeof(FMod_Limits), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */  /* XXX... err... */   
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
        sizeof(FMod_Limits), /* size */
        FMI_TYPE_GENERATE_CURVE, /* action type */  /* XXX... err... */   
        FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
-       "Stepped", /* name */
+       N_("Stepped"), /* name */
        "FMod_Stepped", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
        "FMod_Stepped", /* struct name */
        NULL, /* free data */
        NULL, /* copy data */
@@ -935,43 +933,43 @@ static FModifierTypeInfo FMI_STEPPED = {
 
 /* These globals only ever get directly accessed in this file */
 static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
 
 /* These globals only ever get directly accessed in this file */
 static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
-static short FMI_INIT= 1; /* when non-zero, the list needs to be updated */
+static short FMI_INIT = 1; /* when non-zero, the list needs to be updated */
 
 /* This function only gets called when FMI_INIT is non-zero */
 
 /* This function only gets called when FMI_INIT is non-zero */
-static void fmods_init_typeinfo (void) 
+static void fmods_init_typeinfo(void)
 {
 {
-       fmodifiersTypeInfo[0]=  NULL;                                   /* 'Null' F-Curve Modifier */
-       fmodifiersTypeInfo[1]=  &FMI_GENERATOR;                 /* Generator F-Curve Modifier */
-       fmodifiersTypeInfo[2]=  &FMI_FN_GENERATOR;              /* Built-In Function Generator F-Curve Modifier */
-       fmodifiersTypeInfo[3]=  &FMI_ENVELOPE;                  /* Envelope F-Curve Modifier */
-       fmodifiersTypeInfo[4]=  &FMI_CYCLES;                    /* Cycles F-Curve Modifier */
-       fmodifiersTypeInfo[5]=  &FMI_NOISE;                             /* Apply-Noise F-Curve Modifier */
-       fmodifiersTypeInfo[6]=  NULL/*&FMI_FILTER*/;                    /* Filter F-Curve Modifier */  // XXX unimplemented
-       fmodifiersTypeInfo[7]=  &FMI_PYTHON;                    /* Custom Python F-Curve Modifier */
-       fmodifiersTypeInfo[8]=  &FMI_LIMITS;                    /* Limits F-Curve Modifier */
-       fmodifiersTypeInfo[9]=  &FMI_STEPPED;                   /* Stepped F-Curve Modifier */
+       fmodifiersTypeInfo[0] =  NULL;                   /* 'Null' F-Curve Modifier */
+       fmodifiersTypeInfo[1] =  &FMI_GENERATOR;         /* Generator F-Curve Modifier */
+       fmodifiersTypeInfo[2] =  &FMI_FN_GENERATOR;      /* Built-In Function Generator F-Curve Modifier */
+       fmodifiersTypeInfo[3] =  &FMI_ENVELOPE;          /* Envelope F-Curve Modifier */
+       fmodifiersTypeInfo[4] =  &FMI_CYCLES;            /* Cycles F-Curve Modifier */
+       fmodifiersTypeInfo[5] =  &FMI_NOISE;             /* Apply-Noise F-Curve Modifier */
+       fmodifiersTypeInfo[6] =  NULL /*&FMI_FILTER*/;   /* Filter F-Curve Modifier */           // XXX unimplemented
+       fmodifiersTypeInfo[7] =  &FMI_PYTHON;            /* Custom Python F-Curve Modifier */
+       fmodifiersTypeInfo[8] =  &FMI_LIMITS;            /* Limits F-Curve Modifier */
+       fmodifiersTypeInfo[9] =  &FMI_STEPPED;           /* Stepped F-Curve Modifier */
 }
 
 /* This function should be used for getting the appropriate type-info when only
  * a F-Curve modifier type is known
  */
 }
 
 /* This function should be used for getting the appropriate type-info when only
  * a F-Curve modifier type is known
  */
-FModifierTypeInfo *get_fmodifier_typeinfo (int type)
+FModifierTypeInfo *get_fmodifier_typeinfo(int type)
 {
 {
-       /* initialise the type-info list? */
+       /* initialize the type-info list? */
        if (FMI_INIT) {
                fmods_init_typeinfo();
                FMI_INIT = 0;
        }
        
        /* only return for valid types */
        if (FMI_INIT) {
                fmods_init_typeinfo();
                FMI_INIT = 0;
        }
        
        /* only return for valid types */
-       if ( (type >= FMODIFIER_TYPE_NULL) && 
-                (type <= FMODIFIER_NUM_TYPES ) ) 
+       if ((type >= FMODIFIER_TYPE_NULL) &&
+           (type <  FMODIFIER_NUM_TYPES))
        {
                /* there shouldn't be any segfaults here... */
                return fmodifiersTypeInfo[type];
        }
        else {
        {
                /* there shouldn't be any segfaults here... */
                return fmodifiersTypeInfo[type];
        }
        else {
-               printf("No valid F-Curve Modifier type-info data available. Type = %i \n", type);
+               printf("No valid F-Curve Modifier type-info data available. Type = %i\n", type);
        }
        
        return NULL;
        }
        
        return NULL;
@@ -980,7 +978,7 @@ FModifierTypeInfo *get_fmodifier_typeinfo (int type)
 /* This function should always be used to get the appropriate type-info, as it
  * has checks which prevent segfaults in some weird cases.
  */
 /* This function should always be used to get the appropriate type-info, as it
  * has checks which prevent segfaults in some weird cases.
  */
-FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm)
+FModifierTypeInfo *fmodifier_get_typeinfo(FModifier *fcm)
 {
        /* only return typeinfo for valid modifiers */
        if (fcm)
 {
        /* only return typeinfo for valid modifiers */
        if (fcm)
@@ -992,25 +990,25 @@ FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm)
 /* API --------------------------- */
 
 /* Add a new F-Curve Modifier to the given F-Curve of a certain type */
 /* API --------------------------- */
 
 /* Add a new F-Curve Modifier to the given F-Curve of a certain type */
-FModifier *add_fmodifier (ListBase *modifiers, int type)
+FModifier *add_fmodifier(ListBase *modifiers, int type)
 {
 {
-       FModifierTypeInfo *fmi= get_fmodifier_typeinfo(type);
+       FModifierTypeInfo *fmi = get_fmodifier_typeinfo(type);
        FModifier *fcm;
        
        /* sanity checks */
        FModifier *fcm;
        
        /* sanity checks */
-       if ELEM(NULL, modifiers, fmi)
+       if (ELEM(NULL, modifiers, fmi))
                return NULL;
        
        /* special checks for whether modifier can be added */
        if ((modifiers->first) && (type == FMODIFIER_TYPE_CYCLES)) {
                /* cycles modifier must be first in stack, so for now, don't add if it can't be */
                return NULL;
        
        /* special checks for whether modifier can be added */
        if ((modifiers->first) && (type == FMODIFIER_TYPE_CYCLES)) {
                /* cycles modifier must be first in stack, so for now, don't add if it can't be */
-               // TODO: perhaps there is some better way, but for now, 
-               printf("Error: Cannot add 'Cycles' modifier to F-Curve, as 'Cycles' modifier can only be first in stack. \n");
+               /* TODO: perhaps there is some better way, but for now, */
+               printf("Error: Cannot add 'Cycles' modifier to F-Curve, as 'Cycles' modifier can only be first in stack.\n");
                return NULL;
        }
        
        /* add modifier itself */
                return NULL;
        }
        
        /* add modifier itself */
-       fcm= MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
+       fcm = MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
        fcm->type = type;
        fcm->flag = FMODIFIER_FLAG_EXPANDED;
        fcm->influence = 1.0f;
        fcm->type = type;
        fcm->flag = FMODIFIER_FLAG_EXPANDED;
        fcm->influence = 1.0f;
@@ -1021,7 +1019,7 @@ FModifier *add_fmodifier (ListBase *modifiers, int type)
                fcm->flag |= FMODIFIER_FLAG_ACTIVE;
        
        /* add modifier's data */
                fcm->flag |= FMODIFIER_FLAG_ACTIVE;
        
        /* add modifier's data */
-       fcm->data= MEM_callocN(fmi->size, fmi->structName);
+       fcm->data = MEM_callocN(fmi->size, fmi->structName);
        
        /* init custom settings if necessary */
        if (fmi->new_data)      
        
        /* init custom settings if necessary */
        if (fmi->new_data)      
@@ -1032,9 +1030,9 @@ FModifier *add_fmodifier (ListBase *modifiers, int type)
 }
 
 /* Make a copy of the specified F-Modifier */
 }
 
 /* Make a copy of the specified F-Modifier */
-FModifier *copy_fmodifier (FModifier *src)
+FModifier *copy_fmodifier(FModifier *src)
 {
 {
-       FModifierTypeInfo *fmi= fmodifier_get_typeinfo(src);
+       FModifierTypeInfo *fmi = fmodifier_get_typeinfo(src);
        FModifier *dst;
        
        /* sanity check */
        FModifier *dst;
        
        /* sanity check */
@@ -1057,18 +1055,18 @@ FModifier *copy_fmodifier (FModifier *src)
 }
 
 /* Duplicate all of the F-Modifiers in the Modifier stacks */
 }
 
 /* Duplicate all of the F-Modifiers in the Modifier stacks */
-void copy_fmodifiers (ListBase *dst, ListBase *src)
+void copy_fmodifiers(ListBase *dst, ListBase *src)
 {
        FModifier *fcm, *srcfcm;
        
 {
        FModifier *fcm, *srcfcm;
        
-       if ELEM(NULL, dst, src)
+       if (ELEM(NULL, dst, src))
                return;
        
                return;
        
-       dst->first= dst->last= NULL;
+       dst->first = dst->last = NULL;
        BLI_duplicatelist(dst, src);
        
        BLI_duplicatelist(dst, src);
        
-       for (fcm=dst->first, srcfcm=src->first; fcm && srcfcm; srcfcm=srcfcm->next, fcm=fcm->next) {
-               FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
+       for (fcm = dst->first, srcfcm = src->first; fcm && srcfcm; srcfcm = srcfcm->next, fcm = fcm->next) {
+               FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
                
                /* make a new copy of the F-Modifier's data */
                fcm->data = MEM_dupallocN(fcm->data);
                
                /* make a new copy of the F-Modifier's data */
                fcm->data = MEM_dupallocN(fcm->data);
@@ -1080,9 +1078,9 @@ void copy_fmodifiers (ListBase *dst, ListBase *src)
 }
 
 /* Remove and free the given F-Modifier from the given stack  */
 }
 
 /* Remove and free the given F-Modifier from the given stack  */
-int remove_fmodifier (ListBase *modifiers, FModifier *fcm)
+int remove_fmodifier(ListBase *modifiers, FModifier *fcm)
 {
 {
-       FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
+       FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
        
        /* sanity check */
        if (fcm == NULL)
        
        /* sanity check */
        if (fcm == NULL)
@@ -1103,15 +1101,15 @@ int remove_fmodifier (ListBase *modifiers, FModifier *fcm)
                return 1;
        } 
        else {
                return 1;
        } 
        else {
-               // XXX this case can probably be removed some day, as it shouldn't happen...
-               printf("remove_fmodifier() - no modifier stack given \n");
+               /* XXX this case can probably be removed some day, as it shouldn't happen... */
+               printf("remove_fmodifier() - no modifier stack given\n");
                MEM_freeN(fcm);
                return 0;
        }
 }
 
 /* Remove all of a given F-Curve's modifiers */
                MEM_freeN(fcm);
                return 0;
        }
 }
 
 /* Remove all of a given F-Curve's modifiers */
-void free_fmodifiers (ListBase *modifiers)
+void free_fmodifiers(ListBase *modifiers)
 {
        FModifier *fcm, *fmn;
        
 {
        FModifier *fcm, *fmn;
        
@@ -1120,23 +1118,23 @@ void free_fmodifiers (ListBase *modifiers)
                return;
        
        /* free each modifier in order - modifier is unlinked from list and freed */
                return;
        
        /* free each modifier in order - modifier is unlinked from list and freed */
-       for (fcm= modifiers->first; fcm; fcm= fmn) {
-               fmn= fcm->next;
+       for (fcm = modifiers->first; fcm; fcm = fmn) {
+               fmn = fcm->next;
                remove_fmodifier(modifiers, fcm);
        }
 }
 
 /* Find the active F-Modifier */
                remove_fmodifier(modifiers, fcm);
        }
 }
 
 /* Find the active F-Modifier */
-FModifier *find_active_fmodifier (ListBase *modifiers)
+FModifier *find_active_fmodifier(ListBase *modifiers)
 {
        FModifier *fcm;
        
        /* sanity checks */
 {
        FModifier *fcm;
        
        /* sanity checks */
-       if ELEM(NULL, modifiers, modifiers->first)
+       if (ELEM(NULL, modifiers, modifiers->first))
                return NULL;
        
        /* loop over modifiers until 'active' one is found */
                return NULL;
        
        /* loop over modifiers until 'active' one is found */
-       for (fcm= modifiers->first; fcm; fcm= fcm->next) {
+       for (fcm = modifiers->first; fcm; fcm = fcm->next) {
                if (fcm->flag & FMODIFIER_FLAG_ACTIVE)
                        return fcm;
        }
                if (fcm->flag & FMODIFIER_FLAG_ACTIVE)
                        return fcm;
        }
@@ -1146,16 +1144,16 @@ FModifier *find_active_fmodifier (ListBase *modifiers)
 }
 
 /* Set the active F-Modifier */
 }
 
 /* Set the active F-Modifier */
-void set_active_fmodifier (ListBase *modifiers, FModifier *fcm)
+void set_active_fmodifier(ListBase *modifiers, FModifier *fcm)
 {
        FModifier *fm;
        
        /* sanity checks */
 {
        FModifier *fm;
        
        /* sanity checks */
-       if ELEM(NULL, modifiers, modifiers->first)
+       if (ELEM(NULL, modifiers, modifiers->first))
                return;
        
        /* deactivate all, and set current one active */
                return;
        
        /* deactivate all, and set current one active */
-       for (fm= modifiers->first; fm; fm= fm->next)
+       for (fm = modifiers->first; fm; fm = fm->next)
                fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
        
        /* make given modifier active */
                fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
        
        /* make given modifier active */
@@ -1167,7 +1165,7 @@ void set_active_fmodifier (ListBase *modifiers, FModifier *fcm)
  *     - mtype - type of modifier (if 0, doesn't matter)
  *     - acttype - type of action to perform (if -1, doesn't matter)
  */
  *     - mtype - type of modifier (if 0, doesn't matter)
  *     - acttype - type of action to perform (if -1, doesn't matter)
  */
-short list_has_suitable_fmodifier (ListBase *modifiers, int mtype, short acttype)
+short list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype)
 {
        FModifier *fcm;
        
 {
        FModifier *fcm;
        
@@ -1176,19 +1174,19 @@ short list_has_suitable_fmodifier (ListBase *modifiers, int mtype, short acttype
                return (modifiers && modifiers->first);
                
        /* sanity checks */
                return (modifiers && modifiers->first);
                
        /* sanity checks */
-       if ELEM(NULL, modifiers, modifiers->first)
+       if (ELEM(NULL, modifiers, modifiers->first))
                return 0;
                
        /* find the first mdifier fitting these criteria */
                return 0;
                
        /* find the first mdifier fitting these criteria */
-       for (fcm= modifiers->first; fcm; fcm= fcm->next) {
-               FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
-               short mOk=1, aOk=1; /* by default 1, so that when only one test, won't fail */
+       for (fcm = modifiers->first; fcm; fcm = fcm->next) {
+               FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
+               short mOk = 1, aOk = 1; /* by default 1, so that when only one test, won't fail */
                
                /* check if applicable ones are fullfilled */
                if (mtype)
                
                /* check if applicable ones are fullfilled */
                if (mtype)
-                       mOk= (fcm->type == mtype);
+                       mOk = (fcm->type == mtype);
                if (acttype > -1)
                if (acttype > -1)
-                       aOk= (fmi->acttype == acttype);
+                       aOk = (fmi->acttype == acttype);
                        
                /* if both are ok, we've found a hit */
                if (mOk && aOk)
                        
                /* if both are ok, we've found a hit */
                if (mOk && aOk)
@@ -1202,7 +1200,7 @@ short list_has_suitable_fmodifier (ListBase *modifiers, int mtype, short acttype
 /* Evaluation API --------------------------- */
 
 /* helper function - calculate influence of FModifier */
 /* Evaluation API --------------------------- */
 
 /* helper function - calculate influence of FModifier */
-static float eval_fmodifier_influence (FModifier *fcm, float evaltime)
+static float eval_fmodifier_influence(FModifier *fcm, float evaltime)
 {
        float influence;
        
 {
        float influence;
        
@@ -1243,7 +1241,7 @@ static float eval_fmodifier_influence (FModifier *fcm, float evaltime)
 }
 
 /* evaluate time modifications imposed by some F-Curve Modifiers
 }
 
 /* evaluate time modifications imposed by some F-Curve Modifiers
- *     - this step acts as an optimisation to prevent the F-Curve stack being evaluated 
+ *     - this step acts as an optimization to prevent the F-Curve stack being evaluated 
  *       several times by modifiers requesting the time be modified, as the final result
  *       would have required using the modified time
  *     - modifiers only ever receive the unmodified time, as subsequent modifiers should be
  *       several times by modifiers requesting the time be modified, as the final result
  *       would have required using the modified time
  *     - modifiers only ever receive the unmodified time, as subsequent modifiers should be
@@ -1251,12 +1249,12 @@ static float eval_fmodifier_influence (FModifier *fcm, float evaltime)
  *       so nevaltime gets set to whatever the last time-modifying modifier likes...
  *     - we start from the end of the stack, as only the last one matters for now
  */
  *       so nevaltime gets set to whatever the last time-modifying modifier likes...
  *     - we start from the end of the stack, as only the last one matters for now
  */
-float evaluate_time_fmodifiers (ListBase *modifiers, FCurve *fcu, float cvalue, float evaltime)
+float evaluate_time_fmodifiers(ListBase *modifiers, FCurve *fcu, float cvalue, float evaltime)
 {
        FModifier *fcm;
        
        /* sanity checks */
 {
        FModifier *fcm;
        
        /* sanity checks */
-       if ELEM(NULL, modifiers, modifiers->last)
+       if (ELEM(NULL, modifiers, modifiers->last))
                return evaltime;
                
        /* Starting from the end of the stack, calculate the time effects of various stacked modifiers 
                return evaltime;
                
        /* Starting from the end of the stack, calculate the time effects of various stacked modifiers 
@@ -1269,8 +1267,8 @@ float evaluate_time_fmodifiers (ListBase *modifiers, FCurve *fcu, float cvalue,
         * effect, which should get us the desired effects when using layered time manipulations
         * (such as multiple 'stepped' modifiers in sequence, causing different stepping rates)
         */
         * effect, which should get us the desired effects when using layered time manipulations
         * (such as multiple 'stepped' modifiers in sequence, causing different stepping rates)
         */
-       for (fcm= modifiers->last; fcm; fcm= fcm->prev) {
-               FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
+       for (fcm = modifiers->last; fcm; fcm = fcm->prev) {
+               FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
                
                if (fmi == NULL) 
                        continue;
                
                if (fmi == NULL) 
                        continue;
@@ -1278,12 +1276,12 @@ float evaluate_time_fmodifiers (ListBase *modifiers, FCurve *fcu, float cvalue,
                /* if modifier cannot be applied on this frame (whatever scale it is on, it won't affect the results)
                 * hence we shouldn't bother seeing what it would do given the chance
                 */
                /* if modifier cannot be applied on this frame (whatever scale it is on, it won't affect the results)
                 * hence we shouldn't bother seeing what it would do given the chance
                 */
-               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || 
-                       ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
+               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 ||
+                   ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
                {
                        /* only evaluate if there's a callback for this */
                        if (fmi->evaluate_modifier_time) {
                {
                        /* only evaluate if there's a callback for this */
                        if (fmi->evaluate_modifier_time) {
-                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) {
+                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) {
                                        float influence = eval_fmodifier_influence(fcm, evaltime);
                                        float nval = fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime);
                                        
                                        float influence = eval_fmodifier_influence(fcm, evaltime);
                                        float nval = fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime);
                                        
@@ -1297,30 +1295,30 @@ float evaluate_time_fmodifiers (ListBase *modifiers, FCurve *fcu, float cvalue,
        return evaltime;
 }
 
        return evaltime;
 }
 
-/* Evalautes the given set of F-Curve Modifiers using the given data
+/* Evaluates the given set of F-Curve Modifiers using the given data
  * Should only be called after evaluate_time_fmodifiers() has been called...
  */
  * Should only be called after evaluate_time_fmodifiers() has been called...
  */
-void evaluate_value_fmodifiers (ListBase *modifiers, FCurve *fcu, float *cvalue, float evaltime)
+void evaluate_value_fmodifiers(ListBase *modifiers, FCurve *fcu, float *cvalue, float evaltime)
 {
        FModifier *fcm;
        
        /* sanity checks */
 {
        FModifier *fcm;
        
        /* sanity checks */
-       if ELEM(NULL, modifiers, modifiers->first)
+       if (ELEM(NULL, modifiers, modifiers->first))
                return;
        
        /* evaluate modifiers */
                return;
        
        /* evaluate modifiers */
-       for (fcm= modifiers->first; fcm; fcm= fcm->next) {
-               FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
+       for (fcm = modifiers->first; fcm; fcm = fcm->next) {
+               FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
                
                if (fmi == NULL) 
                        continue;
                
                /* only evaluate if there's a callback for this, and if F-Modifier can be evaluated on this frame */
                
                if (fmi == NULL) 
                        continue;
                
                /* only evaluate if there's a callback for this, and if F-Modifier can be evaluated on this frame */
-               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || 
-                       ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
+               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 ||
+                   ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
                {
                        if (fmi->evaluate_modifier) {
                {
                        if (fmi->evaluate_modifier) {
-                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) {
+                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) {
                                        float influence = eval_fmodifier_influence(fcm, evaltime);
                                        float nval = *cvalue;
                                        
                                        float influence = eval_fmodifier_influence(fcm, evaltime);
                                        float nval = *cvalue;
                                        
@@ -1337,20 +1335,20 @@ void evaluate_value_fmodifiers (ListBase *modifiers, FCurve *fcu, float *cvalue,
 /* Bake modifiers for given F-Curve to curve sample data, in the frame range defined
  * by start and end (inclusive).
  */
 /* Bake modifiers for given F-Curve to curve sample data, in the frame range defined
  * by start and end (inclusive).
  */
-void fcurve_bake_modifiers (FCurve *fcu, int start, int end)
+void fcurve_bake_modifiers(FCurve *fcu, int start, int end)
 {
        ChannelDriver *driver;
        
        /* sanity checks */
 {
        ChannelDriver *driver;
        
        /* sanity checks */
-       // TODO: make these tests report errors using reports not printf's
-       if ELEM(NULL, fcu, fcu->modifiers.first) {
+       /* TODO: make these tests report errors using reports not printf's */
+       if (ELEM(NULL, fcu, fcu->modifiers.first)) {
                printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
                return;
        }
        
        /* temporarily, disable driver while we sample, so that they don't influence the outcome */
                printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
                return;
        }
        
        /* temporarily, disable driver while we sample, so that they don't influence the outcome */
-       driver= fcu->driver;
-       fcu->driver= NULL;
+       driver = fcu->driver;
+       fcu->driver = NULL;
        
        /* bake the modifiers, by sampling the curve at each frame */
        fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
        
        /* bake the modifiers, by sampling the curve at each frame */
        fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
@@ -1359,5 +1357,5 @@ void fcurve_bake_modifiers (FCurve *fcu, int start, int end)
        free_fmodifiers(&fcu->modifiers);
        
        /* restore driver */
        free_fmodifiers(&fcu->modifiers);
        
        /* restore driver */
-       fcu->driver= driver;
+       fcu->driver = driver;
 }
 }