Code style edits (mostly spliting long lines, and removing trailing spaces).
authorBastien Montagne <montagne29@wanadoo.fr>
Sun, 18 Mar 2012 09:27:36 +0000 (09:27 +0000)
committerBastien Montagne <montagne29@wanadoo.fr>
Sun, 18 Mar 2012 09:27:36 +0000 (09:27 +0000)
Note about long lines: I did not touch to two pieces of code (because I don’t see any way to keep a nicely formated, compact code, with shorter lines):
* The node types definitions into rna_nodetree_types.h
* The vgroup name functions into rna_particle.c

77 files changed:
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_ID.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_action.c
source/blender/makesrna/intern/rna_action_api.c
source/blender/makesrna/intern/rna_actuator.c
source/blender/makesrna/intern/rna_actuator_api.c
source/blender/makesrna/intern/rna_animation.c
source/blender/makesrna/intern/rna_animation_api.c
source/blender/makesrna/intern/rna_animviz.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_armature_api.c
source/blender/makesrna/intern/rna_boid.c
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_camera.c
source/blender/makesrna/intern/rna_camera_api.c
source/blender/makesrna/intern/rna_cloth.c
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_constraint.c
source/blender/makesrna/intern/rna_controller.c
source/blender/makesrna/intern/rna_controller_api.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_dynamicpaint.c
source/blender/makesrna/intern/rna_fcurve.c
source/blender/makesrna/intern/rna_fcurve_api.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_gpencil.c
source/blender/makesrna/intern/rna_group.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_image_api.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_internal_types.h
source/blender/makesrna/intern/rna_key.c
source/blender/makesrna/intern/rna_lamp.c
source/blender/makesrna/intern/rna_lattice.c
source/blender/makesrna/intern/rna_main.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_material_api.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_mesh_api.c
source/blender/makesrna/intern/rna_mesh_utils.h
source/blender/makesrna/intern/rna_meta.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_movieclip.c
source/blender/makesrna/intern/rna_nla.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_api.c
source/blender/makesrna/intern/rna_object_force.c
source/blender/makesrna/intern/rna_particle.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_pose_api.c
source/blender/makesrna/intern/rna_render.c
source/blender/makesrna/intern/rna_rna.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_scene_api.c
source/blender/makesrna/intern/rna_sculpt_paint.c
source/blender/makesrna/intern/rna_sensor.c
source/blender/makesrna/intern/rna_sensor_api.c
source/blender/makesrna/intern/rna_sequencer.c
source/blender/makesrna/intern/rna_sequencer_api.c
source/blender/makesrna/intern/rna_smoke.c
source/blender/makesrna/intern/rna_sound.c
source/blender/makesrna/intern/rna_space.c
source/blender/makesrna/intern/rna_test.c
source/blender/makesrna/intern/rna_text.c
source/blender/makesrna/intern/rna_texture.c
source/blender/makesrna/intern/rna_texture_api.c
source/blender/makesrna/intern/rna_tracking.c
source/blender/makesrna/intern/rna_ui.c
source/blender/makesrna/intern/rna_ui_api.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/makesrna/intern/rna_wm.c
source/blender/makesrna/intern/rna_wm_api.c
source/blender/makesrna/intern/rna_world.c

index 23a1b0a83d76ee13c427b61e4bd2388900450a28..4c5fc709d7edfd575557c10f0ed7ed83d117d684 100644 (file)
@@ -75,19 +75,19 @@ static int replace_if_different(char *tmpfile, const char *dep_files[])
 
 #define REN_IF_DIFF                                                           \
        {                                                                         \
-               FILE *file_test = fopen(orgfile, "rb");                                \
-               if (file_test) {                                                       \
+               FILE *file_test = fopen(orgfile, "rb");                               \
+               if (file_test) {                                                      \
                        fclose(file_test);                                                \
-                       if (fp_org) fclose(fp_org);                                        \
-                       if (fp_new) fclose(fp_new);                                        \
-                       if (remove(orgfile) != 0) {                                        \
+                       if (fp_org) fclose(fp_org);                                       \
+                       if (fp_new) fclose(fp_new);                                       \
+                       if (remove(orgfile) != 0) {                                       \
                                fprintf(stderr, "%s:%d, Remove Error (%s): \"%s\"\n",         \
                                        __FILE__, __LINE__, strerror(errno), orgfile);        \
                                return -1;                                                    \
                        }                                                                 \
                }                                                                     \
        }                                                                         \
-       if (rename(tmpfile, orgfile) != 0) {                                       \
+       if (rename(tmpfile, orgfile) != 0) {                                      \
                fprintf(stderr, "%s:%d, Rename Error (%s): \"%s\" -> \"%s\"\n",       \
                        __FILE__, __LINE__, strerror(errno), tmpfile, orgfile);       \
                return -1;                                                            \
@@ -304,7 +304,8 @@ static void rna_print_c_string(FILE *f, const char *str)
 static void rna_print_data_get(FILE *f, PropertyDefRNA *dp)
 {
        if (dp->dnastructfromname && dp->dnastructfromprop)
-               fprintf(f, "    %s *data= (%s*)(((%s*)ptr->data)->%s);\n", dp->dnastructname, dp->dnastructname, dp->dnastructfromname, dp->dnastructfromprop);
+               fprintf(f, "    %s *data= (%s*)(((%s*)ptr->data)->%s);\n", dp->dnastructname, dp->dnastructname,
+                       dp->dnastructfromname, dp->dnastructfromprop);
        else
                fprintf(f, "    %s *data= (%s*)(ptr->data);\n", dp->dnastructname, dp->dnastructname);
 }
@@ -476,7 +477,8 @@ static void rna_int_print(FILE *f, int num)
        else fprintf(f, "%d", num);
 }
 
-static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                       const char *manualfunc)
 {
        char *func;
 
@@ -498,7 +500,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                if (IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
                                        if (prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
                                                fprintf(stderr, "%s (1): %s.%s is a '%s' but wrapped as type '%s'.\n",
-                                                       __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                                                       __func__, srna->identifier, prop->identifier, dp->dnatype,
+                                                       RNA_property_typename(prop->type));
                                                DefRNA.error = 1;
                                                return NULL;
                                        }
@@ -507,7 +510,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                        else if (prop->type == PROP_INT || prop->type == PROP_BOOLEAN || prop->type == PROP_ENUM) {
                                if (IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
                                        fprintf(stderr, "%s (2): %s.%s is a '%s' but wrapped as type '%s'.\n",
-                                               __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                                               __func__, srna->identifier, prop->identifier, dp->dnatype,
+                                               RNA_property_typename(prop->type));
                                        DefRNA.error = 1;
                                        return NULL;
                                }
@@ -538,7 +542,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                if (sprop->maxlength)
                                        fprintf(f, "    %s(value, data->%s, %d);\n", string_copy_func, dp->dnaname, sprop->maxlength);
                                else
-                                       fprintf(f, "    %s(value, data->%s, sizeof(data->%s));\n", string_copy_func, dp->dnaname, dp->dnaname);
+                                       fprintf(f, "    %s(value, data->%s, sizeof(data->%s));\n", string_copy_func,
+                                               dp->dnaname, dp->dnaname);
                        }
                        fprintf(f, "}\n\n");
                        break;
@@ -553,9 +558,11 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                PointerPropertyRNA *pprop = (PointerPropertyRNA*)prop;
                                rna_print_data_get(f, dp);
                                if (dp->dnapointerlevel == 0)
-                                       fprintf(f, "    return rna_pointer_inherit_refine(ptr, &RNA_%s, &data->%s);\n", (const char*)pprop->type, dp->dnaname);
+                                       fprintf(f, "    return rna_pointer_inherit_refine(ptr, &RNA_%s, &data->%s);\n",
+                                               (const char*)pprop->type, dp->dnaname);
                                else
-                                       fprintf(f, "    return rna_pointer_inherit_refine(ptr, &RNA_%s, data->%s);\n", (const char*)pprop->type, dp->dnaname);
+                                       fprintf(f, "    return rna_pointer_inherit_refine(ptr, &RNA_%s, data->%s);\n",
+                                               (const char*)pprop->type, dp->dnaname);
                        }
                        fprintf(f, "}\n\n");
                        break;
@@ -585,7 +592,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                if (prop->flag & PROP_DYNAMIC)
                                        fprintf(f, "void %s(PointerRNA *ptr, %s values[])\n", func, rna_type_type(prop));
                                else
-                                       fprintf(f, "void %s(PointerRNA *ptr, %s values[%u])\n", func, rna_type_type(prop), prop->totarraylength);
+                                       fprintf(f, "void %s(PointerRNA *ptr, %s values[%u])\n", func, rna_type_type(prop),
+                                               prop->totarraylength);
                                fprintf(f, "{\n");
 
                                if (manualfunc) {
@@ -595,7 +603,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                        rna_print_data_get(f, dp);
 
                                        if (prop->flag & PROP_DYNAMIC) {
-                                               char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get_length");
+                                               char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier),
+                                                                                       "get_length");
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
                                                fprintf(f, "    for(i=0; i<len; i++) {\n");
@@ -618,7 +627,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                        }
                                        else {
                                                if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
-                                                       fprintf(f, "            values[i]= %s((data->%s[i] & ", (dp->booleannegative)? "!": "", dp->dnaname);
+                                                       fprintf(f, "            values[i]= %s((data->%s[i] & ", (dp->booleannegative)? "!": "",
+                                                               dp->dnaname);
                                                        rna_int_print(f, dp->booleanbit);
                                                        fprintf(f, ") != 0);\n");
                                                }
@@ -659,7 +669,8 @@ static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                                fprintf(f, ");\n");
                                        }
                                        else
-                                               fprintf(f, "    return (%s)%s(data->%s);\n", rna_type_type(prop), (dp->booleannegative)? "!": "", dp->dnaname);
+                                               fprintf(f, "    return (%s)%s(data->%s);\n", rna_type_type(prop),
+                                                       (dp->booleannegative)? "!": "", dp->dnaname);
                                }
 
                                fprintf(f, "}\n\n");
@@ -730,7 +741,8 @@ static void rna_clamp_value(FILE *f, PropertyRNA *prop, int array)
                fprintf(f, "value;\n");
 }
 
-static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                       const char *manualfunc)
 {
        char *func;
 
@@ -772,7 +784,8 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                if (sprop->maxlength)
                                        fprintf(f, "    %s(data->%s, value, %d);\n", string_copy_func, dp->dnaname, sprop->maxlength);
                                else
-                                       fprintf(f, "    %s(data->%s, value, sizeof(data->%s));\n", string_copy_func, dp->dnaname, dp->dnaname);
+                                       fprintf(f, "    %s(data->%s, value, sizeof(data->%s));\n", string_copy_func,
+                                               dp->dnaname, dp->dnaname);
                        }
                        fprintf(f, "}\n\n");
                        break;
@@ -817,7 +830,8 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                if (prop->flag & PROP_DYNAMIC)
                                        fprintf(f, "void %s(PointerRNA *ptr, const %s values[])\n", func, rna_type_type(prop));
                                else
-                                       fprintf(f, "void %s(PointerRNA *ptr, const %s values[%u])\n", func, rna_type_type(prop), prop->totarraylength);
+                                       fprintf(f, "void %s(PointerRNA *ptr, const %s values[%u])\n", func,
+                                               rna_type_type(prop), prop->totarraylength);
                                fprintf(f, "{\n");
 
                                if (manualfunc) {
@@ -827,7 +841,8 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                        rna_print_data_get(f, dp);
 
                                        if (prop->flag & PROP_DYNAMIC) {
-                                               char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "set_length");
+                                               char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier),
+                                                                                       "set_length");
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
                                                rna_clamp_value_range(f, prop);
@@ -842,17 +857,19 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
 
                                        if (dp->dnaarraylength == 1) {
                                                if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
-                                                       fprintf(f, "            if(%svalues[i]) data->%s |= (%d<<i);\n", (dp->booleannegative)? "!": "", dp->dnaname, dp->booleanbit);
+                                                       fprintf(f, "            if(%svalues[i]) data->%s |= (%d<<i);\n",
+                                                               (dp->booleannegative)? "!": "", dp->dnaname, dp->booleanbit);
                                                        fprintf(f, "            else data->%s &= ~(%d<<i);\n", dp->dnaname, dp->booleanbit);
                                                }
                                                else {
-                                                       fprintf(f, "            (&data->%s)[i]= %s", dp->dnaname, (dp->booleannegative)? "!": "");
+                                                       fprintf(f, "            (&data->%s)[i]= %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
                                                        rna_clamp_value(f, prop, 1);
                                                }
                                        }
                                        else {
                                                if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
-                                                       fprintf(f, "            if(%svalues[i]) data->%s[i] |= ", (dp->booleannegative)? "!": "", dp->dnaname);
+                                                       fprintf(f, "            if(%svalues[i]) data->%s[i] |= ", (dp->booleannegative) ? "!" : "",
+                                                               dp->dnaname);
                                                        rna_int_print(f, dp->booleanbit);
                                                        fprintf(f, ";\n");
                                                        fprintf(f, "            else data->%s[i] &= ~", dp->dnaname);
@@ -864,9 +881,10 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                                }
                                                else {
                                                        if (dp->dnatype)
-                                                               fprintf(f, "            ((%s*)data->%s)[i]= %s", dp->dnatype, dp->dnaname, (dp->booleannegative)? "!": "");
+                                                               fprintf(f, "            ((%s*)data->%s)[i]= %s", dp->dnatype, dp->dnaname,
+                                                                       (dp->booleannegative) ? "!" : "");
                                                        else
-                                                               fprintf(f, "            (data->%s)[i]= %s", dp->dnaname, (dp->booleannegative)? "!": "");
+                                                               fprintf(f, "            (data->%s)[i]= %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
                                                        rna_clamp_value(f, prop, 1);
                                                }
                                        }
@@ -884,7 +902,7 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                else {
                                        rna_print_data_get(f, dp);
                                        if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
-                                               fprintf(f, "    if(%svalue) data->%s |= ", (dp->booleannegative)? "!": "", dp->dnaname);
+                                               fprintf(f, "    if(%svalue) data->%s |= ", (dp->booleannegative) ? "!" : "", dp->dnaname);
                                                rna_int_print(f, dp->booleanbit);
                                                fprintf(f, ";\n");
                                                fprintf(f, "    else data->%s &= ~", dp->dnaname);
@@ -899,7 +917,7 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
                                        }
                                        else {
                                                rna_clamp_value_range(f, prop);
-                                               fprintf(f, "    data->%s= %s", dp->dnaname, (dp->booleannegative)? "!": "");
+                                               fprintf(f, "    data->%s= %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
                                                rna_clamp_value(f, prop, 0);
                                        }
                                }
@@ -911,7 +929,8 @@ static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *pr
        return func;
 }
 
-static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                          const char *manualfunc)
 {
        char *func = NULL;
 
@@ -971,7 +990,8 @@ static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA
        return func;
 }
 
-static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                         const char *manualfunc)
 {
        char *func, *getfunc;
 
@@ -1005,9 +1025,11 @@ static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *
                }
                else {
                        if (dp->dnalengthname)
-                               fprintf(f, "\n  rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), data->%s, 0, NULL);\n", dp->dnaname, dp->dnaname, dp->dnalengthname);
+                               fprintf(f, "\n  rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), data->%s, 0, NULL);\n",
+                                       dp->dnaname, dp->dnaname, dp->dnalengthname);
                        else
-                               fprintf(f, "\n  rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), %d, 0, NULL);\n", dp->dnaname, dp->dnaname, dp->dnalengthfixed);
+                               fprintf(f, "\n  rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), %d, 0, NULL);\n",
+                                       dp->dnaname, dp->dnaname, dp->dnalengthfixed);
                }
        }
        else {
@@ -1030,7 +1052,8 @@ static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *
        return func;
 }
 
-static char *rna_def_property_lookup_int_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc, const char *nextfunc)
+static char *rna_def_property_lookup_int_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                              const char *manualfunc, const char *nextfunc)
 {
        /* note on indices, this is for external functions and ignores skipped values.
         * so the the index can only be checked against the length when there is no 'skip' funcion. */
@@ -1113,13 +1136,16 @@ static char *rna_def_property_lookup_int_func(FILE *f, StructRNA *srna, Property
 
        if (dp->dnalengthname || dp->dnalengthfixed) {
                if (dp->dnalengthname)
-                       fprintf(f, "\n  rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), data->%s, index);\n", item_type, dp->dnaname, dp->dnaname, dp->dnalengthname);
+                       fprintf(f, "\n  rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), data->%s, index);\n",
+                               item_type, dp->dnaname, dp->dnaname, dp->dnalengthname);
                else
-                       fprintf(f, "\n  rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), %d, index);\n", item_type, dp->dnaname, dp->dnaname, dp->dnalengthfixed);
+                       fprintf(f, "\n  rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), %d, index);\n",
+                               item_type, dp->dnaname, dp->dnaname, dp->dnalengthfixed);
        }
        else {
                if (dp->dnapointerlevel == 0)
-                       fprintf(f, "\n  return rna_listbase_lookup_int(ptr, &RNA_%s, &data->%s, index);\n", item_type, dp->dnaname);
+                       fprintf(f, "\n  return rna_listbase_lookup_int(ptr, &RNA_%s, &data->%s, index);\n",
+                               item_type, dp->dnaname);
                else
                        fprintf(f, "\n  return rna_listbase_lookup_int(ptr, &RNA_%s, data->%s, index);\n", item_type, dp->dnaname);
        }
@@ -1130,7 +1156,8 @@ static char *rna_def_property_lookup_int_func(FILE *f, StructRNA *srna, Property
        return func;
 }
 
-static char *rna_def_property_next_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_next_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                        const char *manualfunc)
 {
        char *func, *getfunc;
 
@@ -1156,7 +1183,8 @@ static char *rna_def_property_next_func(FILE *f, StructRNA *srna, PropertyRNA *p
        return func;
 }
 
-static char *rna_def_property_end_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
+static char *rna_def_property_end_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp,
+                                       const char *manualfunc)
 {
        char *func;
 
@@ -1317,7 +1345,8 @@ static void rna_def_property_funcs(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
                        cprop->begin = (void*)rna_def_property_begin_func(f, srna, prop, dp, (const char*)cprop->begin);
                        cprop->next = (void*)rna_def_property_next_func(f, srna, prop, dp, (const char*)cprop->next);
                        cprop->end = (void*)rna_def_property_end_func(f, srna, prop, dp, (const char*)cprop->end);
-                       cprop->lookupint = (void*)rna_def_property_lookup_int_func(f, srna, prop, dp, (const char*)cprop->lookupint, nextfunc);
+                       cprop->lookupint = (void*)rna_def_property_lookup_int_func(f, srna, prop, dp,
+                                                                                  (const char*)cprop->lookupint, nextfunc);
 
                        if (!(prop->flag & PROP_IDPROPERTY)) {
                                if (!cprop->begin) {
@@ -1399,7 +1428,8 @@ static void rna_def_property_funcs_header(FILE *f, StructRNA *srna, PropertyDefR
 
                                for (i = 0; i<eprop->totitem; i++)
                                        if (eprop->item[i].identifier[0])
-                                               fprintf(f, "\t%s_%s_%s = %d,\n", srna->identifier, prop->identifier, eprop->item[i].identifier, eprop->item[i].value);
+                                               fprintf(f, "\t%s_%s_%s = %d,\n", srna->identifier, prop->identifier,
+                                                       eprop->item[i].identifier, eprop->item[i].value);
 
                                fprintf(f, "};\n\n");
                        }
@@ -1488,7 +1518,8 @@ static void rna_def_property_funcs_header_cpp(FILE *f, StructRNA *srna, Property
 
                                for (i = 0; i<eprop->totitem; i++)
                                        if (eprop->item[i].identifier[0])
-                                               fprintf(f, "\t\t%s_%s = %d,\n", rna_safe_id(prop->identifier), eprop->item[i].identifier, eprop->item[i].value);
+                                               fprintf(f, "\t\t%s_%s = %d,\n", rna_safe_id(prop->identifier), eprop->item[i].identifier,
+                                                       eprop->item[i].value);
 
                                fprintf(f, "\t};\n");
                        }
@@ -1513,9 +1544,11 @@ static void rna_def_property_funcs_header_cpp(FILE *f, StructRNA *srna, Property
                        CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)dp->prop;
 
                        if (cprop->item_type)
-                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (const char*)cprop->item_type, srna->identifier, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (const char*)cprop->item_type, srna->identifier,
+                                       rna_safe_id(prop->identifier));
                        else
-                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier,
+                                       rna_safe_id(prop->identifier));
                        break;
                }
        }
@@ -1537,25 +1570,29 @@ static void rna_def_property_funcs_impl_cpp(FILE *f, StructRNA *srna, PropertyDe
                        if (!prop->arraydimension)
                                fprintf(f, "\tBOOLEAN_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
                        else if (prop->totarraylength)
-                               fprintf(f, "\tBOOLEAN_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tBOOLEAN_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength,
+                                       rna_safe_id(prop->identifier));
                        break;
                }
                case PROP_INT: {
                        if (!prop->arraydimension)
                                fprintf(f, "\tINT_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
                        else if (prop->totarraylength)
-                               fprintf(f, "\tINT_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tINT_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength,
+                                       rna_safe_id(prop->identifier));
                        break;
                }
                case PROP_FLOAT: {
                        if (!prop->arraydimension)
                                fprintf(f, "\tFLOAT_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
                        else if (prop->totarraylength)
-                               fprintf(f, "\tFLOAT_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tFLOAT_ARRAY_PROPERTY(%s, %u, %s)", srna->identifier, prop->totarraylength,
+                                       rna_safe_id(prop->identifier));
                        break;
                }
                case PROP_ENUM: {
-                       fprintf(f, "\tENUM_PROPERTY(%s_enum, %s, %s)", rna_safe_id(prop->identifier), srna->identifier, rna_safe_id(prop->identifier));
+                       fprintf(f, "\tENUM_PROPERTY(%s_enum, %s, %s)", rna_safe_id(prop->identifier), srna->identifier,
+                               rna_safe_id(prop->identifier));
 
                        break;
                }
@@ -1567,17 +1604,20 @@ static void rna_def_property_funcs_impl_cpp(FILE *f, StructRNA *srna, PropertyDe
                        PointerPropertyRNA *pprop = (PointerPropertyRNA*)dp->prop;
 
                        if (pprop->type)
-                               fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", (const char*)pprop->type, srna->identifier, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", (const char*)pprop->type, srna->identifier,
+                                       rna_safe_id(prop->identifier));
                        else
-                               fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, rna_safe_id(prop->identifier));
+                               fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier,
+                                       rna_safe_id(prop->identifier));
                        break;
                }
                case PROP_COLLECTION: {
 #if 0
-                       CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
+                       CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)dp->prop;
 
-                       if(cprop->type)
-                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (const char*)cprop->type, srna->identifier, prop->identifier);
+                       if (cprop->type)
+                               fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (const char*)cprop->type, srna->identifier,
+                                       prop->identifier);
                        else
                                fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);
 #endif
@@ -1637,7 +1677,8 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
                /* fixed size arrays and RNA pointers are pre-allocated on the ParameterList stack, pass a pointer to it */
                else if (type == PROP_POINTER || dparm->prop->arraydimension)
                        ptrstr = "*";
-               /* PROP_THICK_WRAP strings are pre-allocated on the ParameterList stack, but type name for string props is already char*, so leave empty */
+               /* PROP_THICK_WRAP strings are pre-allocated on the ParameterList stack,
+                * but type name for string props is already char*, so leave empty */
                else if (type == PROP_STRING && (flag & PROP_THICK_WRAP))
                        ptrstr = "";
                else
@@ -1647,7 +1688,8 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
                if (flag & PROP_DYNAMIC)
                        fprintf(f, "\tint %s%s_len;\n", pout ? "*" : "", dparm->prop->identifier);
                
-               fprintf(f, "\t%s%s %s%s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, dparm->prop->identifier);
+               fprintf(f, "\t%s%s %s%s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
+                       ptrstr, dparm->prop->identifier);
        }
 
        if (has_data) {
@@ -1699,7 +1741,8 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
                                valstr = "*";
                        }
 
-                       /* this must be kept in sync with RNA_parameter_length_get_data, we could just call the function directly, but this is faster */
+                       /* this must be kept in sync with RNA_parameter_length_get_data,
+                        * we could just call the function directly, but this is faster */
                        if (flag & PROP_DYNAMIC) {
                                fprintf(f, "\t%s_len= %s((int *)_data);\n", dparm->prop->identifier, pout ? "" : "*");
                                data_str = "(&(((char *)_data)[sizeof(void *)]))";
@@ -1712,7 +1755,8 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
                        if (!pout)
                                fprintf(f, "%s", valstr);
 
-                       fprintf(f, "((%s%s%s)%s);\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, data_str);
+                       fprintf(f, "((%s%s%s)%s);\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
+                               ptrstr, data_str);
                }
 
                if (dparm->next)
@@ -1774,8 +1818,10 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
 
                if (func->c_ret) {
                        dparm = rna_find_parameter_def(func->c_ret);
-                       ptrstr = (((dparm->prop->type == PROP_POINTER) && !(dparm->prop->flag & PROP_RNAPTR)) || (dparm->prop->arraydimension))? "*": "";
-                       fprintf(f, "\t*((%s%s%s*)_retdata)= %s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, func->c_ret->identifier);
+                       ptrstr = (((dparm->prop->type == PROP_POINTER) && !(dparm->prop->flag & PROP_RNAPTR)) ||
+                                 (dparm->prop->arraydimension)) ? "*" : "";
+                       fprintf(f, "\t*((%s%s%s*)_retdata)= %s;\n", rna_type_struct(dparm->prop),
+                               rna_parameter_type_name(dparm->prop), ptrstr, func->c_ret->identifier);
                }
        }
 
@@ -1944,7 +1990,8 @@ static void rna_generate_property_prototypes(BlenderRNA *brna, StructRNA *srna,
        while (base) {
                fprintf(f, "\n");
                for (prop = base->cont.properties.first; prop; prop = prop->next)
-                       fprintf(f, "%s%s rna_%s_%s;\n", "extern ", rna_property_structname(prop->type), base->identifier, prop->identifier);
+                       fprintf(f, "%s%s rna_%s_%s;\n", "extern ", rna_property_structname(prop->type),
+                               base->identifier, prop->identifier);
                base = base->base;
        }
 
@@ -1952,7 +1999,8 @@ static void rna_generate_property_prototypes(BlenderRNA *brna, StructRNA *srna,
                fprintf(f, "\n");
 
        for (prop = srna->cont.properties.first; prop; prop = prop->next)
-               fprintf(f, "%s%s rna_%s_%s;\n", (prop->flag & PROP_EXPORT)? "": "", rna_property_structname(prop->type), srna->identifier, prop->identifier);
+               fprintf(f, "%s%s rna_%s_%s;\n", (prop->flag & PROP_EXPORT)? "": "", rna_property_structname(prop->type),
+                       srna->identifier, prop->identifier);
        fprintf(f, "\n");
 }
 
@@ -1961,7 +2009,8 @@ static void rna_generate_parameter_prototypes(BlenderRNA *brna, StructRNA *srna,
        PropertyRNA *parm;
 
        for (parm = func->cont.properties.first; parm; parm = parm->next)
-               fprintf(f, "%s%s rna_%s_%s_%s;\n", "extern ", rna_property_structname(parm->type), srna->identifier, func->identifier, parm->identifier);
+               fprintf(f, "%s%s rna_%s_%s_%s;\n", "extern ", rna_property_structname(parm->type), srna->identifier,
+                       func->identifier, parm->identifier);
 
        if (func->cont.properties.first)
                fprintf(f, "\n");
@@ -2032,7 +2081,7 @@ static void rna_generate_static_parameter_prototypes(BlenderRNA *brna, StructRNA
        /* self, context and reports parameters */
        if (func->flag & FUNC_USE_SELF_ID) {
                fprintf(f, "struct ID *_selfid");
-               first = 0;              
+               first = 0;
        }
        
        if ((func->flag & FUNC_NO_SELF) == 0) {
@@ -2086,9 +2135,11 @@ static void rna_generate_static_parameter_prototypes(BlenderRNA *brna, StructRNA
                        fprintf(f, "int %s%s_len, ", pout ? "*" : "", dparm->prop->identifier);
 
                if (!(flag & PROP_DYNAMIC) && dparm->prop->arraydimension)
-                       fprintf(f, "%s%s %s[%u]", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), dparm->prop->identifier, dparm->prop->totarraylength);
+                       fprintf(f, "%s%s %s[%u]", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
+                               dparm->prop->identifier, dparm->prop->totarraylength);
                else
-                       fprintf(f, "%s%s %s%s", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, dparm->prop->identifier);
+                       fprintf(f, "%s%s %s%s", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
+                               ptrstr, dparm->prop->identifier);
 
        }
 
@@ -2117,7 +2168,7 @@ static void rna_generate_static_function_prototypes(BlenderRNA *brna, StructRNA
        fprintf(f, "\n");
 }
 
-static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, PropertyRNA *prop) 
+static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, PropertyRNA *prop)
 {
        char *strnest = "", *errnest = "";
        int len, freenest = 0;
@@ -2140,7 +2191,8 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                int i, defaultfound = 0, totflag = 0;
 
                                if (eprop->item) {
-                                       fprintf(f, "static EnumPropertyItem rna_%s%s_%s_items[%d] = {\n\t", srna->identifier, strnest, prop->identifier, eprop->totitem+1);
+                                       fprintf(f, "static EnumPropertyItem rna_%s%s_%s_items[%d] = {\n\t", srna->identifier,
+                                               strnest, prop->identifier, eprop->totitem+1);
 
                                        for (i = 0; i<eprop->totitem; i++) {
                                                fprintf(f, "{%d, ", eprop->item[i].value);
@@ -2166,7 +2218,8 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                        if (prop->flag & PROP_ENUM_FLAG) {
                                                if (eprop->defaultvalue & ~totflag) {
                                                        fprintf(stderr, "%s: %s%s.%s, enum default includes unused bits (%d).\n",
-                                                               __func__, srna->identifier, errnest, prop->identifier, eprop->defaultvalue & ~totflag);
+                                                               __func__, srna->identifier, errnest, prop->identifier,
+                                                               eprop->defaultvalue & ~totflag);
                                                        DefRNA.error = 1;
                                                }
                                        }
@@ -2190,7 +2243,8 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                unsigned int i;
 
                                if (prop->arraydimension && prop->totarraylength) {
-                                       fprintf(f, "static int rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest, prop->identifier, prop->totarraylength);
+                                       fprintf(f, "static int rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest,
+                                               prop->identifier, prop->totarraylength);
 
                                        for (i = 0; i<prop->totarraylength; i++) {
                                                if (bprop->defaultarray)
@@ -2210,7 +2264,8 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                unsigned int i;
 
                                if (prop->arraydimension && prop->totarraylength) {
-                                       fprintf(f, "static int rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest, prop->identifier, prop->totarraylength);
+                                       fprintf(f, "static int rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest,
+                                               prop->identifier, prop->totarraylength);
 
                                        for (i = 0; i<prop->totarraylength; i++) {
                                                if (iprop->defaultarray)
@@ -2230,7 +2285,8 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
                                unsigned int i;
 
                                if (prop->arraydimension && prop->totarraylength) {
-                                       fprintf(f, "static float rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest, prop->identifier, prop->totarraylength);
+                                       fprintf(f, "static float rna_%s%s_%s_default[%u] = {\n\t", srna->identifier, strnest,
+                                               prop->identifier, prop->totarraylength);
 
                                        for (i = 0; i<prop->totarraylength; i++) {
                                                if (fprop->defaultarray)
@@ -2420,10 +2476,16 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
 
                fprintf(f, "%s%s rna_%s_%s_func = {\n", "", "FunctionRNA", srna->identifier, func->identifier);
 
-               if (func->cont.next) fprintf(f, "\t{(FunctionRNA*)&rna_%s_%s_func, ", srna->identifier, ((FunctionRNA*)func->cont.next)->identifier);
-               else fprintf(f, "\t{NULL, ");
-               if (func->cont.prev) fprintf(f, "(FunctionRNA*)&rna_%s_%s_func,\n", srna->identifier, ((FunctionRNA*)func->cont.prev)->identifier);
-               else fprintf(f, "NULL,\n");
+               if (func->cont.next)
+                       fprintf(f, "\t{(FunctionRNA*)&rna_%s_%s_func, ", srna->identifier,
+                               ((FunctionRNA*)func->cont.next)->identifier);
+               else
+                       fprintf(f, "\t{NULL, ");
+               if (func->cont.prev)
+                       fprintf(f, "(FunctionRNA*)&rna_%s_%s_func,\n", srna->identifier,
+                               ((FunctionRNA*)func->cont.prev)->identifier);
+               else
+                       fprintf(f, "NULL,\n");
 
                fprintf(f, "\tNULL,\n");
 
@@ -2444,8 +2506,10 @@ static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
                if (dfunc->gencall) fprintf(f, "\t%s,\n", dfunc->gencall);
                else fprintf(f, "\tNULL,\n");
 
-               if (func->c_ret) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s_%s\n", srna->identifier, func->identifier, func->c_ret->identifier);
-               else fprintf(f, "\tNULL\n");
+               if (func->c_ret)
+                       fprintf(f, "\t(PropertyRNA*)&rna_%s_%s_%s\n", srna->identifier, func->identifier, func->c_ret->identifier);
+               else
+                       fprintf(f, "\tNULL\n");
 
                fprintf(f, "};\n");
                fprintf(f, "\n");
@@ -2589,7 +2653,7 @@ static RNAProcessItem PROCESS_ITEMS[] = {
        {"rna_userdef.c", NULL, RNA_def_userdef},
        {"rna_vfont.c", NULL, RNA_def_vfont},
        {"rna_wm.c", "rna_wm_api.c", RNA_def_wm},
-       {"rna_world.c", NULL, RNA_def_world},   
+       {"rna_world.c", NULL, RNA_def_world},
        {"rna_movieclip.c", NULL, RNA_def_movieclip},
        {"rna_tracking.c", NULL, RNA_def_tracking},
        {NULL, NULL}};
@@ -2690,7 +2754,8 @@ static void rna_generate_header(BlenderRNA *brna, FILE *f)
        fprintf(f, "#define FOREACH_BEGIN(property, sptr, itemptr) \\\n");
        fprintf(f, "    { \\\n");
        fprintf(f, "            CollectionPropertyIterator rna_macro_iter; \\\n");
-       fprintf(f, "            for(property##_begin(&rna_macro_iter, sptr); rna_macro_iter.valid; property##_next(&rna_macro_iter)) { \\\n");
+       fprintf(f, "            for(property##_begin(&rna_macro_iter, sptr); rna_macro_iter.valid; "
+                  "property##_next(&rna_macro_iter)) { \\\n");
        fprintf(f, "                    itemptr= rna_macro_iter.ptr;\n\n");
 
        fprintf(f, "#define FOREACH_END(property) \\\n");
@@ -2783,7 +2848,8 @@ static const char *cpp_classes = ""
 "\n"
 "   Array() {}\n"
 "      Array(const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T)*Tsize); }\n"
-"      const Array<T, Tsize>& operator=(const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T)*Tsize); return *this; }\n"
+"      const Array<T, Tsize>& operator=(const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T)*Tsize); "
+"return *this; }\n"
 "\n"
 "      operator T*() { return data; }\n"
 "};\n"
@@ -2804,14 +2870,17 @@ static const char *cpp_classes = ""
 "\n"
 "      T& operator*(void) { return t; }\n"
 "      T* operator->(void) { return &t; }\n"
-"      bool operator==(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) { return iter.valid == other.iter.valid; }\n"
-"      bool operator!=(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) { return iter.valid != other.iter.valid; }\n"
+"      bool operator==(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) "
+"{ return iter.valid == other.iter.valid; }\n"
+"      bool operator!=(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) "
+"{ return iter.valid != other.iter.valid; }\n"
 "\n"
 "      void begin(const Pointer& ptr)\n"
 "      { if(init) Tend(&iter); Tbegin(&iter, (PointerRNA*)&ptr.ptr); t = T(iter.ptr); init = true; }\n"
 "\n"
 "private:\n"
-"      const CollectionIterator<T, Tbegin, Tnext, Tend>& operator=(const CollectionIterator<T, Tbegin, Tnext, Tend>& copy) {}\n"
+"      const CollectionIterator<T, Tbegin, Tnext, Tend>& operator="
+"(const CollectionIterator<T, Tbegin, Tnext, Tend>& copy) {}\n"
 ""
 "      CollectionPropertyIterator iter;\n"
 "      T t;\n"
@@ -2865,7 +2934,8 @@ static void rna_generate_header_cpp(BlenderRNA *brna, FILE *f)
 
                fprintf(f, "class %s : public %s {\n", srna->identifier, (srna->base)? srna->base->identifier: "Pointer");
                fprintf(f, "public:\n");
-               fprintf(f, "\t%s(const PointerRNA& ptr) :\n\t\t%s(ptr)", srna->identifier, (srna->base)? srna->base->identifier: "Pointer");
+               fprintf(f, "\t%s(const PointerRNA& ptr) :\n\t\t%s(ptr)", srna->identifier,
+                       (srna->base)? srna->base->identifier: "Pointer");
                for (dp = ds->cont.properties.first; dp; dp = dp->next)
                        if (!(dp->prop->flag & (PROP_IDPROPERTY|PROP_BUILTIN)))
                                if (dp->prop->type == PROP_COLLECTION)
index 03519bf18966dc4b37374912c4d17fc5278bca10..6992d992ccafb236478ae98b3b4030971841145f 100644 (file)
@@ -40,7 +40,7 @@
 
 #include "rna_internal.h"
 
-/* enum of ID-block types 
+/* enum of ID-block types
  * NOTE: need to keep this in line with the other defines for these
  */
 EnumPropertyItem id_type_items[] = {
@@ -219,7 +219,9 @@ void rna_PropertyGroup_unregister(Main *UNUSED(bmain), StructRNA *type)
        RNA_struct_free(&BLENDER_RNA, type);
 }
 
-StructRNA *rna_PropertyGroup_register(Main *UNUSED(bmain), ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc UNUSED(call), StructFreeFunc UNUSED(free))
+StructRNA *rna_PropertyGroup_register(Main *UNUSED(bmain), ReportList *reports, void *data, const char *identifier,
+                                      StructValidateFunc validate, StructCallbackFunc UNUSED(call),
+                                      StructFreeFunc UNUSED(free))
 {
        PointerRNA dummyptr;
 
@@ -235,7 +237,8 @@ StructRNA *rna_PropertyGroup_register(Main *UNUSED(bmain), ReportList *reports,
         * owns the string pointer which it could potentially free while blender
         * is running. */
        if (BLI_strnlen(identifier, MAX_IDPROP_NAME) == MAX_IDPROP_NAME) {
-               BKE_reportf(reports, RPT_ERROR, "registering id property class: '%s' is too long, maximum length is " STRINGIFY(MAX_IDPROP_NAME), identifier);
+               BKE_reportf(reports, RPT_ERROR, "registering id property class: '%s' is too long, maximum length is "
+                                               STRINGIFY(MAX_IDPROP_NAME), identifier);
                return NULL;
        }
 
@@ -285,7 +288,7 @@ static void rna_ID_update_tag(ID *id, ReportList *reports, int flag)
                /* Could add particle updates later */
 #if 0
                case ID_PA:
-                       if(flag & ~(OB_RECALC_ALL|PSYS_RECALC)) {
+                       if (flag & ~(OB_RECALC_ALL|PSYS_RECALC)) {
                                BKE_report(reports, RPT_ERROR, "'refresh' incompatible with ParticleSettings ID type");
                                return;
                        }
@@ -391,7 +394,8 @@ static void rna_def_ID_properties(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "idp_array", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_struct_type(prop, "PropertyGroup");
-       RNA_def_property_collection_funcs(prop, "rna_IDPArray_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_IDPArray_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_IDPArray_begin", "rna_iterator_array_next", "rna_iterator_array_end",
+                                         "rna_iterator_array_get", "rna_IDPArray_length", NULL, NULL, NULL);
        RNA_def_property_flag(prop, PROP_EXPORT|PROP_IDPROPERTY);
 
        /* never tested, maybe its useful to have this? */
@@ -464,7 +468,9 @@ static void rna_def_ID(BlenderRNA *brna)
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "ID", NULL);
-       RNA_def_struct_ui_text(srna, "ID", "Base type for datablocks, defining a unique name, linking from other libraries and garbage collection");
+       RNA_def_struct_ui_text(srna, "ID",
+                              "Base type for datablocks, defining a unique name, linking from other libraries "
+                              "and garbage collection");
        RNA_def_struct_flag(srna, STRUCT_ID|STRUCT_ID_REFCOUNT);
        RNA_def_struct_refine_func(srna, "rna_ID_refine");
        RNA_def_struct_idprops_func(srna, "rna_ID_idprops");
@@ -547,7 +553,7 @@ static void rna_def_library(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "Library");
-       RNA_def_property_ui_text(prop, "Parent", "");   
+       RNA_def_property_ui_text(prop, "Parent", "");
 }
 void RNA_def_ID(BlenderRNA *brna)
 {
@@ -568,4 +574,3 @@ void RNA_def_ID(BlenderRNA *brna)
 }
 
 #endif
-
index 8e2319215a8288434a69258aa919e34d7542eb1b..582f4b32962036e747bd31ce1eeeae118378f7b5 100644 (file)
@@ -590,7 +590,8 @@ int RNA_struct_is_a(StructRNA *type, StructRNA *srna)
 
 PropertyRNA *RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
 {
-       if (identifier[0] =='[' && identifier[1] =='"') { /* "  (dummy comment to avoid confusing some function lists in text editors) */
+       if (identifier[0] =='[' && identifier[1] =='"') { /* "  (dummy comment to avoid confusing some
+                                                          * function lists in text editors) */
                /* id prop lookup, not so common */
                PropertyRNA *r_prop = NULL;
                PointerRNA r_ptr; /* only support single level props */
@@ -995,7 +996,8 @@ void RNA_property_float_range(PointerRNA *ptr, PropertyRNA *prop, float *hardmin
        }
 }
 
-void RNA_property_float_ui_range(PointerRNA *ptr, PropertyRNA *prop, float *softmin, float *softmax, float *step, float *precision)
+void RNA_property_float_ui_range(PointerRNA *ptr, PropertyRNA *prop, float *softmin, float *softmax,
+                                 float *step, float *precision)
 {
        FloatPropertyRNA *fprop = (FloatPropertyRNA*)rna_ensure_property(prop);
        float hardmin, hardmax;
@@ -1133,7 +1135,8 @@ EnumPropertyItem DummyRNA_DEFAULT_items[] = {
        {0, NULL, 0, NULL, NULL}
 };
 
-void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free)
+void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item,
+                             int *totitem, int *free)
 {
        EnumPropertyRNA *eprop = (EnumPropertyRNA*)rna_ensure_property(prop);
 
@@ -1163,7 +1166,8 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En
        }
 }
 
-void RNA_property_enum_items_gettexted(bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free)
+void RNA_property_enum_items_gettexted(bContext *C, PointerRNA *ptr, PropertyRNA *prop,
+                                       EnumPropertyItem **item, int *totitem, int *free)
 {
        RNA_property_enum_items(C, ptr, prop, item, totitem, free);
 
@@ -1279,7 +1283,8 @@ int RNA_enum_description(EnumPropertyItem *item, const int value, const char **d
        return 0;
 }
 
-int RNA_property_enum_identifier(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **identifier)
+int RNA_property_enum_identifier(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value,
+                                 const char **identifier)
 {
        EnumPropertyItem *item = NULL;
        int result, free;
@@ -1311,7 +1316,8 @@ int RNA_property_enum_name(bContext *C, PointerRNA *ptr, PropertyRNA *prop, cons
        return 0;
 }
 
-int RNA_property_enum_bitflag_identifiers(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **identifier)
+int RNA_property_enum_bitflag_identifiers(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value,
+                                          const char **identifier)
 {
        EnumPropertyItem *item = NULL;
        int result, free;
@@ -2989,7 +2995,7 @@ int RNA_property_collection_raw_array(PointerRNA *ptr, PropertyRNA *prop, Proper
 
 #define RAW_GET(dtype, var, raw, a)                                           \
 {                                                                             \
-       switch (raw.type) {                                                        \
+       switch (raw.type) {                                                       \
                case PROP_RAW_CHAR: var = (dtype)((char*)raw.array)[a]; break;        \
                case PROP_RAW_SHORT: var = (dtype)((short*)raw.array)[a]; break;      \
                case PROP_RAW_INT: var = (dtype)((int*)raw.array)[a]; break;          \
@@ -3001,7 +3007,7 @@ int RNA_property_collection_raw_array(PointerRNA *ptr, PropertyRNA *prop, Proper
 
 #define RAW_SET(dtype, raw, a, var)                                           \
 {                                                                             \
-       switch (raw.type) {                                                        \
+       switch (raw.type) {                                                       \
                case PROP_RAW_CHAR: ((char*)raw.array)[a] = (char)var; break;         \
                case PROP_RAW_SHORT: ((short*)raw.array)[a] = (short)var; break;      \
                case PROP_RAW_INT: ((int*)raw.array)[a] = (int)var; break;            \
@@ -3023,7 +3029,8 @@ int RNA_raw_type_sizeof(RawPropertyType type)
        }
 }
 
-static int rna_raw_access(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *inarray, RawPropertyType intype, int inlen, int set)
+static int rna_raw_access(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname,
+                          void *inarray, RawPropertyType intype, int inlen, int set)
 {
        StructRNA *ptype;
        PointerRNA itemptr;
@@ -3063,7 +3070,8 @@ static int rna_raw_access(ReportList *reports, PointerRNA *ptr, PropertyRNA *pro
                if (RNA_property_collection_raw_array(ptr, prop, itemprop, &out)) {
                        int arraylen = (itemlen == 0) ? 1 : itemlen;
                        if (in.len != arraylen*out.len) {
-                               BKE_reportf(reports, RPT_ERROR, "Array length mismatch (expected %d, got %d)", out.len*arraylen, in.len);
+                               BKE_reportf(reports, RPT_ERROR, "Array length mismatch (expected %d, got %d)",
+                                           out.len * arraylen, in.len);
                                return 0;
                        }
                        
@@ -3325,12 +3333,14 @@ RawPropertyType RNA_property_raw_type(PropertyRNA *prop)
        return prop->rawtype;
 }
 
-int RNA_property_collection_raw_get(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *array, RawPropertyType type, int len)
+int RNA_property_collection_raw_get(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname,
+                                    void *array, RawPropertyType type, int len)
 {
        return rna_raw_access(reports, ptr, prop, propname, array, type, len, 0);
 }
 
-int RNA_property_collection_raw_set(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname, void *array, RawPropertyType type, int len)
+int RNA_property_collection_raw_set(ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, const char *propname,
+                                    void *array, RawPropertyType type, int len)
 {
        return rna_raw_access(reports, ptr, prop, propname, array, type, len, 1);
 }
@@ -3387,7 +3397,8 @@ PointerRNA rna_listbase_lookup_int(PointerRNA *ptr, StructRNA *type, struct List
        return rna_pointer_inherit_refine(ptr, type, data);
 }
 
-void rna_iterator_array_begin(CollectionPropertyIterator *iter, void *ptr, int itemsize, int length, int free_ptr, IteratorSkipFunc skip)
+void rna_iterator_array_begin(CollectionPropertyIterator *iter, void *ptr, int itemsize, int length,
+                              int free_ptr, IteratorSkipFunc skip)
 {
        ArrayIterator *internal;
 
@@ -3691,7 +3702,7 @@ int RNA_path_resolve_full(PointerRNA *ptr, const char *path, PointerRNA *r_ptr,
                                int i, temp_index;
 
                                for (i = 0; i<dim; i++) {
-                                       temp_index = -1; 
+                                       temp_index = -1;
 
                                        /* multi index resolve */
                                        if (*path =='[') {
@@ -3990,7 +4001,8 @@ static char *rna_path_from_ID_to_idpgroup(PointerRNA *ptr)
        BLI_assert(ptr->id.data != NULL);
 
        /* TODO, Support Bones/PoseBones. no pointers stored to the bones from here, only the ID. See example in [#25746]
-        * unless this is added only way to find this is to also search all bones and pose bones of an armature or object */
+        *       Unless this is added only way to find this is to also search all bones and pose bones
+        *       of an armature or object */
        RNA_id_pointer_create(ptr->id.data, &id_ptr);
 
        haystack = RNA_struct_idprops(&id_ptr, FALSE);
@@ -4019,11 +4031,11 @@ char *RNA_path_from_ID_to_struct(PointerRNA *ptr)
                        PointerRNA parentptr;
                        PropertyRNA *userprop;
                        
-                       /* find the property in the struct we're nested in that references this struct, and 
+                       /* find the property in the struct we're nested in that references this struct, and
                         * use its identifier as the first part of the path used...
                         */
                        RNA_id_pointer_create(ptr->id.data, &parentptr);
-                       userprop = RNA_struct_find_nested(&parentptr, ptr->type); 
+                       userprop = RNA_struct_find_nested(&parentptr, ptr->type);
                        
                        if (userprop)
                                ptrpath = BLI_strdup(RNA_property_identifier(userprop));
@@ -4487,7 +4499,7 @@ char *RNA_pointer_as_string(bContext *C, PointerRNA *ptr)
        }
        RNA_STRUCT_END;
 
-       BLI_dynstr_append(dynstr, "}"); 
+       BLI_dynstr_append(dynstr, "}");
        
        
        cstring = BLI_dynstr_get_cstring(dynstr);
@@ -4514,7 +4526,8 @@ char *RNA_property_as_string(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
                else {
                        BLI_dynstr_append(dynstr, "(");
                        for (i = 0; i<len; i++) {
-                               BLI_dynstr_appendf(dynstr, i?", %s":"%s", RNA_property_boolean_get_index(ptr, prop, i) ? "True" : "False");
+                               BLI_dynstr_appendf(dynstr, i ? ", %s" : "%s",
+                                                  RNA_property_boolean_get_index(ptr, prop, i) ? "True" : "False");
                        }
                        if (len == 1)
                                BLI_dynstr_append(dynstr, ","); /* otherwise python wont see it as a tuple */
@@ -4617,7 +4630,8 @@ char *RNA_property_as_string(bContext *C, PointerRNA *ptr, PropertyRNA *prop)
                CollectionPropertyIterator collect_iter;
                BLI_dynstr_append(dynstr, "[");
                
-               for (RNA_property_collection_begin(ptr, prop, &collect_iter); collect_iter.valid; RNA_property_collection_next(&collect_iter)) {
+               for (RNA_property_collection_begin(ptr, prop, &collect_iter); collect_iter.valid;
+                    RNA_property_collection_next(&collect_iter)) {
                        PointerRNA itemptr = collect_iter.ptr;
                        
                        if (first_time == 0)
@@ -4841,7 +4855,7 @@ void RNA_parameter_get(ParameterList *parms, PropertyRNA *parm, void **value)
        RNA_parameter_list_begin(parms, &iter);
 
        for (; iter.valid; RNA_parameter_list_next(&iter))
-               if (iter.parm == parm) 
+               if (iter.parm == parm)
                        break;
 
        if (iter.valid)
@@ -4872,7 +4886,7 @@ void RNA_parameter_set(ParameterList *parms, PropertyRNA *parm, const void *valu
        RNA_parameter_list_begin(parms, &iter);
 
        for (; iter.valid; RNA_parameter_list_next(&iter))
-               if (iter.parm == parm) 
+               if (iter.parm == parm)
                        break;
 
        if (iter.valid)
@@ -4950,7 +4964,8 @@ int RNA_function_call(bContext *C, ReportList *reports, PointerRNA *ptr, Functio
        return -1;
 }
 
-int RNA_function_call_lookup(bContext *C, ReportList *reports, PointerRNA *ptr, const char *identifier, ParameterList *parms)
+int RNA_function_call_lookup(bContext *C, ReportList *reports, PointerRNA *ptr, const char *identifier,
+                             ParameterList *parms)
 {
        FunctionRNA *func;
 
@@ -4962,7 +4977,8 @@ int RNA_function_call_lookup(bContext *C, ReportList *reports, PointerRNA *ptr,
        return -1;
 }
 
-int RNA_function_call_direct(bContext *C, ReportList *reports, PointerRNA *ptr, FunctionRNA *func, const char *format, ...)
+int RNA_function_call_direct(bContext *C, ReportList *reports, PointerRNA *ptr, FunctionRNA *func,
+                             const char *format, ...)
 {
        va_list args;
        int ret;
@@ -4976,7 +4992,8 @@ int RNA_function_call_direct(bContext *C, ReportList *reports, PointerRNA *ptr,
        return ret;
 }
 
-int RNA_function_call_direct_lookup(bContext *C, ReportList *reports, PointerRNA *ptr, const char *identifier, const char *format, ...)
+int RNA_function_call_direct_lookup(bContext *C, ReportList *reports, PointerRNA *ptr, const char *identifier,
+                                    const char *format, ...)
 {
        FunctionRNA *func;
 
@@ -5160,7 +5177,8 @@ static int rna_function_parameter_parse(PointerRNA *ptr, PropertyRNA *prop, Prop
        return 0;
 }
 
-int RNA_function_call_direct_va(bContext *C, ReportList *reports, PointerRNA *ptr, FunctionRNA *func, const char *format, va_list args)
+int RNA_function_call_direct_va(bContext *C, ReportList *reports, PointerRNA *ptr, FunctionRNA *func,
+                                const char *format, va_list args)
 {
        PointerRNA funcptr;
        ParameterList parms;
@@ -5226,39 +5244,45 @@ int RNA_function_call_direct_va(bContext *C, ReportList *reports, PointerRNA *pt
                case PROP_ENUM:
                        {
                                int arg = va_arg(args, int);
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg, NULL, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg,
+                                                                  NULL, tid, fid, pid);
                                break;
                        }
                case PROP_FLOAT:
                        {
                                double arg = va_arg(args, double);
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg, NULL, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg,
+                                                                  NULL, tid, fid, pid);
                                break;
                        }
                case PROP_STRING:
                        {
                                char *arg = va_arg(args, char*);
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg, NULL, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg,
+                                                                  NULL, tid, fid, pid);
                                break;
                        }
                case PROP_POINTER:
                        {
                                StructRNA *srna = va_arg(args, StructRNA*);
                                void *arg = va_arg(args, void*);
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg, srna, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg,
+                                                                  srna, tid, fid, pid);
                                break;
                        }
                case PROP_COLLECTION:
                        {
                                StructRNA *srna = va_arg(args, StructRNA*);
                                ListBase *arg = va_arg(args, ListBase*);
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg, srna, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, &arg,
+                                                                  srna, tid, fid, pid);
                                break;
                        }
                default:
                        {
                                /* handle errors */
-                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, NULL, NULL, tid, fid, pid);
+                               err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, iter.data, NULL,
+                                                                  NULL, tid, fid, pid);
                                break;
                        }
                }
@@ -5292,39 +5316,45 @@ int RNA_function_call_direct_va(bContext *C, ReportList *reports, PointerRNA *pt
                        case PROP_ENUM:
                                {
                                        int *arg = va_arg(args, int*);
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata, NULL, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata,
+                                                                          NULL, tid, fid, pid);
                                        break;
                                }
                        case PROP_FLOAT:
                                {
                                        float *arg = va_arg(args, float*);
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata, NULL, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata,
+                                                                          NULL, tid, fid, pid);
                                        break;
                                }
                        case PROP_STRING:
                                {
                                        char **arg = va_arg(args, char**);
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata, NULL, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata,
+                                                                          NULL, tid, fid, pid);
                                        break;
                                }
                        case PROP_POINTER:
                                {
                                        StructRNA *srna = va_arg(args, StructRNA*);
                                        void **arg = va_arg(args, void**);
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata, srna, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata,
+                                                                          srna, tid, fid, pid);
                                        break;
                                }
                        case PROP_COLLECTION:
                                {
                                        StructRNA *srna = va_arg(args, StructRNA*);
                                        ListBase **arg = va_arg(args, ListBase**);
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata, srna, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, arg, retdata,
+                                                                          srna, tid, fid, pid);
                                        break;
                                }
                        default:
                                {
                                        /* handle errors */
-                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, NULL, NULL, NULL, tid, fid, pid);
+                                       err = rna_function_parameter_parse(&funcptr, parm, type, ftype, len, NULL, NULL,
+                                                                          NULL, tid, fid, pid);
                                        break;
                                }
                        }
index 829b1ae1f13164f00c7b9bc15f9b2b479823b55a..fe729f1c44b964a106576da6c2d29e73cc0cf22b 100644 (file)
@@ -93,7 +93,8 @@ static void rna_Action_groups_remove(bAction *act, ReportList *reports, bActionG
        MEM_freeN(agrp);
 }
 
-static FCurve *rna_Action_fcurve_new(bAction *act, ReportList *reports, const char *data_path, int index, const char *group)
+static FCurve *rna_Action_fcurve_new(bAction *act, ReportList *reports, const char *data_path,
+                                     int index, const char *group)
 {
        if (group && group[0] =='\0') group = NULL;
 
@@ -104,7 +105,8 @@ static FCurve *rna_Action_fcurve_new(bAction *act, ReportList *reports, const ch
 
        /* annoying, check if this exists */
        if (verify_fcurve(act, group, data_path, index, 0)) {
-               BKE_reportf(reports, RPT_ERROR, "F-Curve '%s[%d]' already exists in action '%s'", data_path, index, act->id.name+2);
+               BKE_reportf(reports, RPT_ERROR, "F-Curve '%s[%d]' already exists in action '%s'", data_path,
+                           index, act->id.name+2);
                return NULL;
        }
        return verify_fcurve(act, group, data_path, index, 1);
@@ -114,7 +116,8 @@ static void rna_Action_fcurve_remove(bAction *act, ReportList *reports, FCurve *
 {
        if (fcu->grp) {
                if (BLI_findindex(&act->groups, fcu->grp) == -1) {
-                       BKE_reportf(reports, RPT_ERROR, "F-Curve's ActionGroup '%s' not found in action '%s'", fcu->grp->name, act->id.name+2);
+                       BKE_reportf(reports, RPT_ERROR, "F-Curve's ActionGroup '%s' not found in action '%s'",
+                                   fcu->grp->name, act->id.name+2);
                        return;
                }
                
@@ -202,7 +205,7 @@ int rna_Action_id_poll(PointerRNA *ptr, PointerRNA value)
        bAction *act = (bAction *)value.id.data;
        
        if (act) {
-               /* there can still be actions that will have undefined id-root 
+               /* there can still be actions that will have undefined id-root
                 * (i.e. floating "action-library" members) which we will not
                 * be able to resolve an idroot for automatically, so let these through
                 */
@@ -222,7 +225,7 @@ int rna_Action_actedit_assign_poll(PointerRNA *ptr, PointerRNA value)
        bAction *act = (bAction *)value.id.data;
        
        if (act) {
-               /* there can still be actions that will have undefined id-root 
+               /* there can still be actions that will have undefined id-root
                 * (i.e. floating "action-library" members) which we will not
                 * be able to resolve an idroot for automatically, so let these through
                 */
@@ -259,12 +262,15 @@ static void rna_def_dopesheet(BlenderRNA *brna)
        /* XXX: make this obsolete? */
        prop = RNA_def_property(srna, "source", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "ID");
-       RNA_def_property_ui_text(prop, "Source", "ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil)");
+       RNA_def_property_ui_text(prop, "Source",
+                                "ID-Block representing source data, currently ID_SCE (for Dopesheet), "
+                                "and ID_SC (for Grease Pencil)");
        
        /* Show datablock filters */
        prop = RNA_def_property(srna, "show_datablock_filters", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ADS_FLAG_SHOW_DBFILTERS);
-       RNA_def_property_ui_text(prop, "Show Datablock Filters", "Show options for whether channels related to certain types of data are included");
+       RNA_def_property_ui_text(prop, "Show Datablock Filters",
+                                "Show options for whether channels related to certain types of data are included");
        RNA_def_property_ui_icon(prop, ICON_DISCLOSURE_TRI_RIGHT, -1);
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN, NULL);
        
@@ -284,7 +290,8 @@ static void rna_def_dopesheet(BlenderRNA *brna)
        /* Object Group Filtering Settings */
        prop = RNA_def_property(srna, "show_only_group_objects", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "filterflag", ADS_FILTER_ONLYOBGROUP);
-       RNA_def_property_ui_text(prop, "Only Objects in Group", "Only include channels from Objects in the specified Group");
+       RNA_def_property_ui_text(prop, "Only Objects in Group",
+                                "Only include channels from Objects in the specified Group");
        RNA_def_property_ui_icon(prop, ICON_GROUP, 0);
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
@@ -297,7 +304,8 @@ static void rna_def_dopesheet(BlenderRNA *brna)
        /* FCurve Display Name Search Settings */
        prop = RNA_def_property(srna, "show_only_matching_fcurves", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "filterflag", ADS_FILTER_BY_FCU_NAME);
-       RNA_def_property_ui_text(prop, "Only Matching F-Curves", "Only include F-Curves with names containing search text");
+       RNA_def_property_ui_text(prop, "Only Matching F-Curves",
+                                "Only include F-Curves with names containing search text");
        RNA_def_property_ui_icon(prop, ICON_VIEWZOOM, 0);
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
@@ -309,7 +317,8 @@ static void rna_def_dopesheet(BlenderRNA *brna)
        /* NLA Specific Settings */
        prop = RNA_def_property(srna, "show_missing_nla", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "filterflag", ADS_FILTER_NLA_NOACT);
-       RNA_def_property_ui_text(prop, "Include Missing NLA", "Include Animation Data blocks with no NLA data (NLA Editor only)");
+       RNA_def_property_ui_text(prop, "Include Missing NLA",
+                                "Include Animation Data blocks with no NLA data (NLA Editor only)");
        RNA_def_property_ui_icon(prop, ICON_ACTION, 0);
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
@@ -322,14 +331,16 @@ static void rna_def_dopesheet(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "show_expanded_summary", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ADS_FLAG_SUMMARY_COLLAPSED);
-       RNA_def_property_ui_text(prop, "Collapse Summary", "Collapse summary when shown, so all other channels get hidden (DopeSheet Editors Only)");
+       RNA_def_property_ui_text(prop, "Collapse Summary",
+                                "Collapse summary when shown, so all other channels get hidden (DopeSheet Editors Only)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
        
        /* General DataType Filtering Settings */
        prop = RNA_def_property(srna, "show_transforms", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "filterflag", ADS_FILTER_NOOBJ);
-       RNA_def_property_ui_text(prop, "Display Transforms", "Include visualization of Object-level Animation data (mostly Transforms)");
+       RNA_def_property_ui_text(prop, "Display Transforms",
+                                "Include visualization of Object-level Animation data (mostly Transforms)");
        RNA_def_property_ui_icon(prop, ICON_MANIPUL, 0); /* XXX? */
        RNA_def_property_update(prop, NC_ANIMATION|ND_ANIMCHAN|NA_EDITED, NULL);
        
@@ -442,8 +453,8 @@ static void rna_def_action_group(BlenderRNA *brna)
         * defined like a standard ListBase. Adding/removing channels from this list needs
         * extreme care, otherwise the F-Curve list running through adjacent groups does
         * not match up with the one stored in the Action, resulting in curves which do not
-        * show up in animation editors. In extreme cases, animation may also selectively 
-        * fail to play back correctly. 
+        * show up in animation editors. In extreme cases, animation may also selectively
+        * fail to play back correctly.
         *
         * If such changes are required, these MUST go through the API functions for manipulating
         * these F-Curve groupings. Also, note that groups only apply in actions ONLY.
@@ -565,12 +576,14 @@ static void rna_def_action_pose_markers(BlenderRNA *brna, PropertyRNA *cprop)
        prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "TimelineMarker");
        RNA_def_property_flag(prop, PROP_EDITABLE);
-       RNA_def_property_pointer_funcs(prop, "rna_Action_active_pose_marker_get", "rna_Action_active_pose_marker_set", NULL, NULL);
+       RNA_def_property_pointer_funcs(prop, "rna_Action_active_pose_marker_get",
+                                      "rna_Action_active_pose_marker_set", NULL, NULL);
        RNA_def_property_ui_text(prop, "Active Pose Marker", "Active pose marker for this Action");
        
        prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "active_marker");
-       RNA_def_property_int_funcs(prop, "rna_Action_active_pose_marker_index_get", "rna_Action_active_pose_marker_index_set", "rna_Action_active_pose_marker_index_range");
+       RNA_def_property_int_funcs(prop, "rna_Action_active_pose_marker_index_get",
+                                  "rna_Action_active_pose_marker_index_set", "rna_Action_active_pose_marker_index_range");
        RNA_def_property_ui_text(prop, "Active Pose Marker Index", "Index of active pose marker");
 }
 
@@ -604,15 +617,19 @@ static void rna_def_action(BlenderRNA *brna)
        rna_def_action_pose_markers(brna, prop);
        
        /* properties */
-       prop = RNA_def_float_vector(srna, "frame_range" , 2 , NULL , 0, 0, "Frame Range" , "The final frame range of all F-Curves within this action" , 0 , 0);
+       prop = RNA_def_float_vector(srna, "frame_range" , 2 , NULL , 0, 0, "Frame Range" ,
+                                   "The final frame range of all F-Curves within this action" , 0 , 0);
        RNA_def_property_float_funcs(prop, "rna_Action_frame_range_get" , NULL, NULL);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        
-       /* special "type" limiter - should not really be edited in general, but is still available/editable in 'emergencies' */
+       /* special "type" limiter - should not really be edited in general,
+        * but is still available/editable in 'emergencies' */
        prop = RNA_def_property(srna, "id_root", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "idroot");
        RNA_def_property_enum_items(prop, id_type_items);
-       RNA_def_property_ui_text(prop, "ID Root Type", "Type of ID-block that action can be used on - DO NOT CHANGE UNLESS YOU KNOW WHAT YOU'RE DOING");
+       RNA_def_property_ui_text(prop, "ID Root Type",
+                                "Type of ID-block that action can be used on - "
+                                "DO NOT CHANGE UNLESS YOU KNOW WHAT YOU'RE DOING");
        
        /* API calls */
        RNA_api_action(srna);
index 07c42cf0d20d13d1cc167765889ede81102e3a74..7e95aaab31b2d29e52e2fbf25b9e0c378a64e7e8 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,7 @@
  * The Original Code is Copyright (C) 2009 Blender Foundation.
  * All rights reserved.
  *
- * 
+ *
  * Contributor(s): Arystanbek Dyussenov
  *
  * ***** END GPL LICENSE BLOCK *****
index 78555d2a8775a8f204138d909722057de8377392..708d3ad06990ded5f50f2bd346fb5e87b3f9e926 100644 (file)
@@ -597,7 +597,8 @@ static void rna_def_action_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_continue_last_frame", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "end_reset", 1);
-       RNA_def_property_ui_text(prop, "Continue", "Restore last frame when switching on/off, otherwise play from the start each time");
+       RNA_def_property_ui_text(prop, "Continue",
+                                "Restore last frame when switching on/off, otherwise play from the start each time");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
        
        prop = RNA_def_property(srna, "property", PROP_STRING, PROP_NONE);
@@ -625,7 +626,9 @@ static void rna_def_action_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "priority", PROP_INT, PROP_NONE);
        RNA_def_property_range(prop, 0, 100);
-       RNA_def_property_ui_text(prop, "Priority", "Execution priority - lower numbers will override actions with higher numbers (with 2 or more actions at once, the overriding channels must be lower in the stack)");
+       RNA_def_property_ui_text(prop, "Priority",
+                                "Execution priority - lower numbers will override actions with higher numbers "
+                                "(with 2 or more actions at once, the overriding channels must be lower in the stack)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "layer", PROP_INT, PROP_NONE);
@@ -635,7 +638,8 @@ static void rna_def_action_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "layer_weight", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0.0, 1.0);
-       RNA_def_property_ui_text(prop, "Layer Weight", "How much of the previous layer to blend into this one (0 = add mode)");
+       RNA_def_property_ui_text(prop, "Layer Weight",
+                                "How much of the previous layer to blend into this one (0 = add mode)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "frame_property", PROP_STRING, PROP_NONE);
@@ -647,13 +651,17 @@ static void rna_def_action_actuator(BlenderRNA *brna)
        prop = RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_IPOADD);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_ActionActuator_add_set");
-       RNA_def_property_ui_text(prop, "Add", "Action is added to the current loc/rot/scale in global or local coordinate according to Local flag");
+       RNA_def_property_ui_text(prop, "Add",
+                                "Action is added to the current loc/rot/scale in global or local coordinate according to "
+                                "Local flag");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_force", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_IPOFORCE);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_ActionActuator_force_set");
-       RNA_def_property_ui_text(prop, "Force", "Apply Action as a global or local force depending on the local option (dynamic objects only)");
+       RNA_def_property_ui_text(prop, "Force",
+                                "Apply Action as a global or local force depending on the local option "
+                                "(dynamic objects only)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
        
        prop = RNA_def_property(srna, "use_local", PROP_BOOLEAN, PROP_NONE);
@@ -701,7 +709,8 @@ static void rna_def_object_actuator(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "Object");
        RNA_def_property_pointer_sdna(prop, NULL, "reference");
        RNA_def_property_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Reference Object", "Reference object for velocity calculation, leave empty for world reference");
+       RNA_def_property_ui_text(prop, "Reference Object",
+                                "Reference object for velocity calculation, leave empty for world reference");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
        
        prop = RNA_def_property(srna, "damping", PROP_INT, PROP_NONE);
@@ -719,7 +728,8 @@ static void rna_def_object_actuator(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "forcerot[1]");
        RNA_def_property_ui_range(prop, 0.0, 3.0, 10, 2);
        RNA_def_property_float_funcs(prop, NULL, "rna_ObjectActuator_integralcoefficient_set", NULL);
-       RNA_def_property_ui_text(prop, "Integral Coefficient", "Low value (0.01) for slow response, high value (0.5) for fast response");
+       RNA_def_property_ui_text(prop, "Integral Coefficient",
+                                "Low value (0.01) for slow response, high value (0.5) for fast response");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "derivate_coefficient", PROP_FLOAT, PROP_NONE);
@@ -798,7 +808,9 @@ static void rna_def_object_actuator(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "linearvelocity");
        RNA_def_property_array(prop, 3);
        RNA_def_property_ui_range(prop, -10000.0, 10000.0, 10, 2);
-       RNA_def_property_ui_text(prop, "Linear Velocity", "Linear velocity (in Servo mode it sets the target relative linear velocity, it will be achieved by automatic application of force - Null velocity is a valid target)");
+       RNA_def_property_ui_text(prop, "Linear Velocity",
+                                "Linear velocity (in Servo mode it sets the target relative linear velocity, it will be "
+                                "achieved by automatic application of force - Null velocity is a valid target)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "angular_velocity", PROP_FLOAT, PROP_XYZ);
@@ -990,7 +1002,9 @@ static void rna_def_sound_actuator(BlenderRNA *brna)
        prop = RNA_def_property(srna, "cone_outer_gain_3d", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sound3D.cone_outer_gain");
        RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 2);
-       RNA_def_property_ui_text(prop, "Cone Outer Gain", "The gain outside the outer cone (the gain in the outer cone will be interpolated between this value and the normal gain in the inner cone)");
+       RNA_def_property_ui_text(prop, "Cone Outer Gain",
+                                "The gain outside the outer cone (the gain in the outer cone will be interpolated "
+                                "between this value and the normal gain in the inner cone)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "cone_outer_angle_3d", PROP_FLOAT, PROP_NONE);
@@ -1130,13 +1144,15 @@ static void rna_def_constraint_actuator(BlenderRNA *brna)
 
        /* ACT_CONST_TYPE_LOC */
        prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_limitmin_get", "rna_ConstraintActuator_limitmin_set", NULL);
+       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_limitmin_get",
+                                    "rna_ConstraintActuator_limitmin_set", NULL);
        RNA_def_property_ui_range(prop, -2000.f, 2000.f, 1, 2);
        RNA_def_property_ui_text(prop, "Min", "");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_limitmax_get", "rna_ConstraintActuator_limitmax_set", NULL);
+       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_limitmax_get",
+                                    "rna_ConstraintActuator_limitmax_set", NULL);
        RNA_def_property_ui_range(prop, -2000.f, 2000.f, 1, 2);
        RNA_def_property_ui_text(prop, "Max", "");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
@@ -1155,7 +1171,8 @@ static void rna_def_constraint_actuator(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_distance_get", "rna_ConstraintActuator_distance_set", NULL);
+       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_distance_get",
+                                    "rna_ConstraintActuator_distance_set", NULL);
        RNA_def_property_ui_range(prop, -2000.f, 2000.f, 1, 2);
        RNA_def_property_ui_text(prop, "Distance", "Keep this distance to target");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
@@ -1202,19 +1219,24 @@ static void rna_def_constraint_actuator(BlenderRNA *brna)
        prop = RNA_def_property(srna, "angle_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "minloc[0]");
        RNA_def_property_range(prop, 0.0, 180.0);
-       RNA_def_property_ui_text(prop, "Min Angle", "Minimum angle (in degree) to maintain with target direction (no correction is done if angle with target direction is between min and max)");
+       RNA_def_property_ui_text(prop, "Min Angle",
+                                "Minimum angle (in degree) to maintain with target direction "
+                                "(no correction is done if angle with target direction is between min and max)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        /*XXX TODO - use radians internally then change to PROP_ANGLE */
        prop = RNA_def_property(srna, "angle_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "maxloc[0]");
        RNA_def_property_range(prop, 0.0, 180.0);
-       RNA_def_property_ui_text(prop, "Max Angle", "Maximum angle (in degree) allowed with target direction (no correction is done if angle with target direction is between min and max)");
+       RNA_def_property_ui_text(prop, "Max Angle",
+                                "Maximum angle (in degree) allowed with target direction "
+                                "(no correction is done if angle with target direction is between min and max)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        /* ACT_CONST_TYPE_FH */
        prop = RNA_def_property(srna, "fh_height", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_fhheight_get", "rna_ConstraintActuator_fhheight_set", NULL);
+       RNA_def_property_float_funcs(prop, "rna_ConstraintActuator_fhheight_get",
+                                    "rna_ConstraintActuator_fhheight_set", NULL);
        RNA_def_property_ui_range(prop, 0.01, 2000.0, 10, 2);
        RNA_def_property_ui_text(prop, "Distance", "Height of the force field area");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
@@ -1244,7 +1266,9 @@ static void rna_def_constraint_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_CONST_NORMAL);
-       RNA_def_property_ui_text(prop, "N", "Set object axis along (local axis) or parallel (global axis) to the normal at hit position");
+       RNA_def_property_ui_text(prop, "N",
+                                "Set object axis along (local axis) or parallel (global axis) to the normal at "
+                                "hit position");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_persistent", PROP_BOOLEAN, PROP_NONE);
@@ -1325,7 +1349,8 @@ static void rna_def_edit_object_actuator(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "Mesh");
        RNA_def_property_pointer_sdna(prop, NULL, "me");
        RNA_def_property_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Mesh", "Replace the existing, when left blank 'Phys' will remake the existing physics mesh");
+       RNA_def_property_ui_text(prop, "Mesh",
+                                "Replace the existing, when left blank 'Phys' will remake the existing physics mesh");
        /* note: custom set function is ONLY to avoid rna setting a user for this. */
        RNA_def_property_pointer_funcs(prop, NULL, "rna_Actuator_editobject_mesh_set", NULL, NULL);
        RNA_def_property_update(prop, NC_LOGIC, NULL);
@@ -1373,7 +1398,8 @@ static void rna_def_edit_object_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_replace_physics_mesh", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_EDOB_REPLACE_MESH_PHYS);
-       RNA_def_property_ui_text(prop, "Phys", "Replace the physics mesh (triangle bounds only - compound shapes not supported)");
+       RNA_def_property_ui_text(prop, "Phys",
+                                "Replace the physics mesh (triangle bounds only - compound shapes not supported)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_3d_tracking", PROP_BOOLEAN, PROP_NONE);
@@ -1396,7 +1422,7 @@ static void rna_def_scene_actuator(BlenderRNA *brna)
                {ACT_SCENE_REMOVE, "REMOVE", 0, "Remove Scene", ""},
                {ACT_SCENE_SUSPEND, "SUSPEND", 0, "Suspend Scene", ""},
                {ACT_SCENE_RESUME, "RESUME", 0, "Resume Scene", ""},
-               {0, NULL, 0, NULL, NULL}};      
+               {0, NULL, 0, NULL, NULL}};
                
        srna = RNA_def_struct(brna, "SceneActuator", "Actuator");
        RNA_def_struct_ui_text(srna, "Scene Actuator", "");
@@ -1454,7 +1480,7 @@ static void rna_def_random_actuator(BlenderRNA *brna)
                {ACT_RANDOM_FLOAT_UNIFORM, "FLOAT_UNIFORM", 0, "Float Uniform", ""},
                {ACT_RANDOM_FLOAT_NORMAL, "FLOAT_NORMAL", 0, "Float Normal", ""},
                {ACT_RANDOM_FLOAT_NEGATIVE_EXPONENTIAL, "FLOAT_NEGATIVE_EXPONENTIAL", 0, "Float Neg. Exp.", ""},
-               {0, NULL, 0, NULL, NULL}};      
+               {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "RandomActuator", "Actuator");
        RNA_def_struct_ui_text(srna, "Random Actuator", "");
@@ -1463,7 +1489,9 @@ static void rna_def_random_actuator(BlenderRNA *brna)
        prop = RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
        RNA_def_property_ui_range(prop, 0, 1000, 1, 1);
        RNA_def_property_range(prop, 0, MAXFRAME);
-       RNA_def_property_ui_text(prop, "Seed", "Initial seed of the random generator, use Python for more freedom (choose 0 for not random)");
+       RNA_def_property_ui_text(prop, "Seed",
+                                "Initial seed of the random generator, use Python for more freedom "
+                                "(choose 0 for not random)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "property", PROP_STRING, PROP_NONE);
@@ -1579,7 +1607,8 @@ static void rna_def_message_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "to_property", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "toPropName");
-       RNA_def_property_ui_text(prop, "To", "Optional, send message to objects with this name only, or empty to broadcast");
+       RNA_def_property_ui_text(prop, "To",
+                                "Optional, send message to objects with this name only, or empty to broadcast");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "subject", PROP_STRING, PROP_NONE);
@@ -1634,7 +1663,9 @@ static void rna_def_game_actuator(BlenderRNA *brna)
 
        /* ACT_GAME_LOAD */
        prop = RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
-       RNA_def_property_ui_text(prop, "File", "Load this blend file, use the \"//\" prefix for a path relative to the current blend file");
+       RNA_def_property_ui_text(prop, "File",
+                                "Load this blend file, use the \"//\" prefix for a path relative to the current "
+                                "blend file");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
        /*XXX to do: an operator that calls file_browse with relative_path on and blender filtering active */
 }
@@ -1650,17 +1681,22 @@ static void rna_def_visibility_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_visible", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ACT_VISIBILITY_INVISIBLE);
-       RNA_def_property_ui_text(prop, "Visible", "Set the objects visible (initialized from the object render restriction toggle in physics button)");
+       RNA_def_property_ui_text(prop, "Visible",
+                                "Set the objects visible (initialized from the object render restriction toggle in "
+                                "physics button)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_occlusion", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_VISIBILITY_OCCLUSION);
-       RNA_def_property_ui_text(prop, "Occlusion", "Set the object to occlude objects behind it (initialized from the object type in physics button)");
+       RNA_def_property_ui_text(prop, "Occlusion",
+                                "Set the object to occlude objects behind it (initialized from the object type in "
+                                "physics button)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "apply_to_children", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ACT_VISIBILITY_RECURSIVE);
-       RNA_def_property_ui_text(prop, "Children", "Set all the children of this object to the same visibility/occlusion recursively");
+       RNA_def_property_ui_text(prop, "Children",
+                                "Set all the children of this object to the same visibility/occlusion recursively");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 }
 
@@ -1754,7 +1790,9 @@ static void rna_def_parent_actuator(BlenderRNA *brna)
        /* booleans */
        prop = RNA_def_property(srna, "use_compound", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ACT_PARENT_COMPOUND);
-       RNA_def_property_ui_text(prop, "Compound", "Add this object shape to the parent shape (only if the parent shape is already compound)");
+       RNA_def_property_ui_text(prop, "Compound",
+                                "Add this object shape to the parent shape "
+                                "(only if the parent shape is already compound)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_ghost", PROP_BOOLEAN, PROP_NONE);
@@ -1801,7 +1839,8 @@ static void rna_def_shape_action_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_continue_last_frame", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "end_reset", 1);
-       RNA_def_property_ui_text(prop, "Continue", "Restore last frame when switching on/off, otherwise play from the start each time");
+       RNA_def_property_ui_text(prop, "Continue",
+                                "Restore last frame when switching on/off, otherwise play from the start each time");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
        
        prop = RNA_def_property(srna, "property", PROP_STRING, PROP_NONE);
@@ -1829,7 +1868,9 @@ static void rna_def_shape_action_actuator(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "priority", PROP_INT, PROP_NONE);
        RNA_def_property_range(prop, 0, 100);
-       RNA_def_property_ui_text(prop, "Priority", "Execution priority - lower numbers will override actions with higher numbers (with 2 or more actions at once, the overriding channels must be lower in the stack)");
+       RNA_def_property_ui_text(prop, "Priority",
+                                "Execution priority - lower numbers will override actions with higher numbers "
+                                "(with 2 or more actions at once, the overriding channels must be lower in the stack)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "frame_property", PROP_STRING, PROP_NONE);
@@ -1919,7 +1960,9 @@ static void rna_def_armature_actuator(BlenderRNA *brna)
        RNA_def_property_pointer_sdna(prop, NULL, "subtarget");
        RNA_def_property_struct_type(prop, "Object");
        RNA_def_property_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Secondary Target", "Set this object as the secondary target of the constraint (only IK polar target at the moment)");
+       RNA_def_property_ui_text(prop, "Secondary Target",
+                                "Set this object as the secondary target of the constraint "
+                                "(only IK polar target at the moment)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
@@ -2062,4 +2105,3 @@ void RNA_def_actuator(BlenderRNA *brna)
 }
 
 #endif
-
index eba2cfafd47855ce379f01e3be6e074d5eae5567..68b2c4f8b52dd797ada3acc77cc7c67a2c856fec 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,7 @@
  * The Original Code is Copyright (C) 2010 Blender Foundation.
  * All rights reserved.
  *
- * 
+ *
  * Contributor(s):
  *
  * ***** END GPL LICENSE BLOCK *****
@@ -60,13 +60,13 @@ void RNA_api_actuator(StructRNA *srna)
 
        func = RNA_def_function(srna, "link", "rna_Actuator_link");
        RNA_def_function_ui_description(func, "Link the actuator to a controller");
-       parm = RNA_def_pointer(func, "controller", "Controller", "", "Controller to link to"); 
+       parm = RNA_def_pointer(func, "controller", "Controller", "", "Controller to link to");
        RNA_def_property_flag(parm, PROP_REQUIRED);
        RNA_def_property_update(parm, NC_LOGIC, NULL);
 
        func = RNA_def_function(srna, "unlink", "rna_Actuator_unlink");
        RNA_def_function_ui_description(func, "Unlink the actuator from a controller");
-       parm = RNA_def_pointer(func, "controller", "Controller", "", "Controller to unlink from"); 
+       parm = RNA_def_pointer(func, "controller", "Controller", "", "Controller to unlink from");
        RNA_def_property_flag(parm, PROP_REQUIRED);
        RNA_def_property_update(parm, NC_LOGIC, NULL);
 }
index 56c176256bc5a4c8f87c80add0e936807706c1e2..fce618228b353eb36f01711a68d29232304f0442 100644 (file)
@@ -178,7 +178,8 @@ static void rna_KeyingSetInfo_unregister(Main *bmain, StructRNA *type)
        ANIM_keyingset_info_unregister(bmain, ksi);
 }
 
-static StructRNA *rna_KeyingSetInfo_register(Main *bmain, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
+static StructRNA *rna_KeyingSetInfo_register(Main *bmain, ReportList *reports, void *data, const char *identifier,
+                                             StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
 {
        KeyingSetInfo dummyksi = {NULL};
        KeyingSetInfo *ksi;
@@ -209,7 +210,7 @@ static StructRNA *rna_KeyingSetInfo_register(Main *bmain, ReportList *reports, v
        memcpy(ksi, &dummyksi, sizeof(KeyingSetInfo));
        
        /* set RNA-extensions info */
-       ksi->ext.srna = RNA_def_struct(&BLENDER_RNA, ksi->idname, "KeyingSetInfo"); 
+       ksi->ext.srna = RNA_def_struct(&BLENDER_RNA, ksi->idname, "KeyingSetInfo");
        ksi->ext.data = data;
        ksi->ext.call = call;
        ksi->ext.free = free;
@@ -342,7 +343,7 @@ static PointerRNA rna_KeyingSet_typeinfo_get(PointerRNA *ptr)
 
 
 
-static KS_Path *rna_KeyingSet_paths_add(KeyingSet *keyingset, ReportList *reports, 
+static KS_Path *rna_KeyingSet_paths_add(KeyingSet *keyingset, ReportList *reports,
                ID *id, const char rna_path[], int index, int group_method, const char group_name[])
 {
        KS_Path *ksp = NULL;
@@ -357,7 +358,7 @@ static KS_Path *rna_KeyingSet_paths_add(KeyingSet *keyingset, ReportList *report
        /* if data is valid, call the API function for this */
        if (keyingset) {
                ksp = BKE_keyingset_add_path(keyingset, id, group_name, rna_path, index, flag, group_method);
-               keyingset->active_path = BLI_countlist(&keyingset->paths); 
+               keyingset->active_path = BLI_countlist(&keyingset->paths);
        }
        else {
                BKE_report(reports, RPT_ERROR, "Keying Set Path could not be added");
@@ -460,9 +461,13 @@ static void rna_def_common_keying_flags(StructRNA *srna, short reg)
        PropertyRNA *prop;
 
        static EnumPropertyItem keying_flag_items[] = {
-                       {INSERTKEY_NEEDED, "INSERTKEY_NEEDED", 0, "Insert Keyframes - Only Needed", "Only insert keyframes where they're needed in the relevant F-Curves"},
-                       {INSERTKEY_MATRIX, "INSERTKEY_VISUAL", 0, "Insert Keyframes - Visual", "Insert keyframes based on 'visual transforms'"},
-                       {INSERTKEY_XYZ2RGB, "INSERTKEY_XYZ_TO_RGB", 0, "F-Curve Colors - XYZ to RGB", "Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis"},
+                       {INSERTKEY_NEEDED, "INSERTKEY_NEEDED", 0, "Insert Keyframes - Only Needed",
+                                          "Only insert keyframes where they're needed in the relevant F-Curves"},
+                       {INSERTKEY_MATRIX, "INSERTKEY_VISUAL", 0, "Insert Keyframes - Visual",
+                                          "Insert keyframes based on 'visual transforms'"},
+                       {INSERTKEY_XYZ2RGB, "INSERTKEY_XYZ_TO_RGB", 0, "F-Curve Colors - XYZ to RGB",
+                                           "Color for newly added transformation F-Curves (Location, Rotation, Scale) "
+                                           "and also Color is based on the transform axis"},
                        {0, NULL, 0, NULL, NULL}};
 
        prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
@@ -545,7 +550,7 @@ static void rna_def_keyingset_info(BlenderRNA *brna)
        RNA_def_property_flag(parm, PROP_REQUIRED);
        parm = RNA_def_pointer(func, "ks", "KeyingSet", "", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
-       parm = RNA_def_pointer(func, "data", "AnyType", "", ""); 
+       parm = RNA_def_pointer(func, "data", "AnyType", "", "");
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR|PROP_NEVER_NULL);
 }
 
@@ -564,7 +569,9 @@ static void rna_def_keyingset_path(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_editable_func(prop, "rna_ksPath_id_editable");
        RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_ksPath_id_typef", NULL);
-       RNA_def_property_ui_text(prop, "ID-Block", "ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)");
+       RNA_def_property_ui_text(prop, "ID-Block",
+                                "ID-Block that keyframes for Keying Set should be added to "
+                                "(for Absolute Keying Sets only)");
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET|NA_EDITED, NULL); /* XXX: maybe a bit too noisy */
        
        prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
@@ -589,7 +596,8 @@ static void rna_def_keyingset_path(BlenderRNA *brna)
        
        /* Path + Array Index */
        prop = RNA_def_property(srna, "data_path", PROP_STRING, PROP_NONE);
-       RNA_def_property_string_funcs(prop, "rna_ksPath_RnaPath_get", "rna_ksPath_RnaPath_length", "rna_ksPath_RnaPath_set");
+       RNA_def_property_string_funcs(prop, "rna_ksPath_RnaPath_get", "rna_ksPath_RnaPath_length",
+                                     "rna_ksPath_RnaPath_set");
        RNA_def_property_ui_text(prop, "Data Path", "Path to property setting");
        RNA_def_struct_name_property(srna, prop); /* XXX this is the best indicator for now... */
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET|NA_EDITED, NULL);
@@ -602,7 +610,9 @@ static void rna_def_keyingset_path(BlenderRNA *brna)
        /* Flags */
        prop = RNA_def_property(srna, "use_entire_array", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", KSP_FLAG_WHOLE_ARRAY);
-       RNA_def_property_ui_text(prop, "Entire Array", "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used");
+       RNA_def_property_ui_text(prop, "Entire Array",
+                                "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), "
+                                "entire array is to be used");
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET|NA_EDITED, NULL); /* XXX: maybe a bit too noisy */
        
        /* Keyframing Settings */
@@ -634,10 +644,11 @@ static void rna_def_keyingset_paths(BlenderRNA *brna, PropertyRNA *cprop)
        parm = RNA_def_pointer(func, "ksp", "KeyingSetPath", "New Path", "Path created and added to the Keying Set");
                RNA_def_function_return(func, parm);
                /* ID-block for target */
-       parm = RNA_def_pointer(func, "target_id", "ID", "Target ID", "ID-Datablock for the destination"); 
+       parm = RNA_def_pointer(func, "target_id", "ID", "Target ID", "ID-Datablock for the destination");
                RNA_def_property_flag(parm, PROP_REQUIRED);
                /* rna-path */
-       parm = RNA_def_string(func, "data_path", "", 256, "Data-Path", "RNA-Path to destination property"); /* xxx hopefully this is long enough */
+               /* XXX hopefully this is long enough */
+       parm = RNA_def_string(func, "data_path", "", 256, "Data-Path", "RNA-Path to destination property");
                RNA_def_property_flag(parm, PROP_REQUIRED);
                /* index (defaults to -1 for entire array) */
        RNA_def_int(func, "index", -1, -1, INT_MAX, "Index",
@@ -655,7 +666,7 @@ static void rna_def_keyingset_paths(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_function_ui_description(func, "Remove the given path from the Keying Set");
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
                /* path to remove */
-       parm = RNA_def_pointer(func, "path", "KeyingSetPath", "Path", ""); 
+       parm = RNA_def_pointer(func, "path", "KeyingSetPath", "Path", "");
                RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
 
 
@@ -668,12 +679,14 @@ static void rna_def_keyingset_paths(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_property_struct_type(prop, "KeyingSetPath");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_editable_func(prop, "rna_KeyingSet_active_ksPath_editable");
-       RNA_def_property_pointer_funcs(prop, "rna_KeyingSet_active_ksPath_get", "rna_KeyingSet_active_ksPath_set", NULL, NULL);
+       RNA_def_property_pointer_funcs(prop, "rna_KeyingSet_active_ksPath_get",
+                                      "rna_KeyingSet_active_ksPath_set", NULL, NULL);
        RNA_def_property_ui_text(prop, "Active Keying Set", "Active Keying Set used to insert/delete keyframes");
 
        prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "active_path");
-       RNA_def_property_int_funcs(prop, "rna_KeyingSet_active_ksPath_index_get", "rna_KeyingSet_active_ksPath_index_set", "rna_KeyingSet_active_ksPath_index_range");
+       RNA_def_property_int_funcs(prop, "rna_KeyingSet_active_ksPath_index_get", "rna_KeyingSet_active_ksPath_index_set",
+                                  "rna_KeyingSet_active_ksPath_index_range");
        RNA_def_property_ui_text(prop, "Active Path Index", "Current Keying Set index");
 }
 
@@ -722,7 +735,9 @@ static void rna_def_keyingset(BlenderRNA *brna)
        prop = RNA_def_property(srna, "is_path_absolute", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", KEYINGSET_ABSOLUTE);
-       RNA_def_property_ui_text(prop, "Absolute", "Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)"); 
+       RNA_def_property_ui_text(prop, "Absolute",
+                                "Keying Set defines specific paths/settings to be keyframed "
+                                "(i.e. is not reliant on context info)");
        
        /* Keyframing Flags */
        rna_def_common_keying_flags(srna, 0);
@@ -800,7 +815,7 @@ void rna_def_animdata_common(StructRNA *srna)
        prop = RNA_def_property(srna, "animation_data", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "adt");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Animation Data", "Animation data for this datablock");  
+       RNA_def_property_ui_text(prop, "Animation Data", "Animation data for this datablock");
 }
 
 void rna_def_animdata(BlenderRNA *brna)
@@ -821,7 +836,8 @@ void rna_def_animdata(BlenderRNA *brna)
        
        /* Active Action */
        prop = RNA_def_property(srna, "action", PROP_POINTER, PROP_NONE);
-       RNA_def_property_flag(prop, PROP_EDITABLE); /* this flag as well as the dynamic test must be defined for this to be editable... */
+               /* this flag as well as the dynamic test must be defined for this to be editable... */
+       RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_pointer_funcs(prop, NULL, "rna_AnimData_action_set", NULL, "rna_Action_id_poll");
        RNA_def_property_editable_func(prop, "rna_AnimData_action_editable");
        RNA_def_property_ui_text(prop, "Action", "Active Action for this datablock");
@@ -831,20 +847,23 @@ void rna_def_animdata(BlenderRNA *brna)
        prop = RNA_def_property(srna, "action_extrapolation", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "act_extendmode");
        RNA_def_property_enum_items(prop, nla_mode_extend_items);
-       RNA_def_property_ui_text(prop, "Action Extrapolation", "Action to take for gaps past the Active Action's range (when evaluating with NLA)");
+       RNA_def_property_ui_text(prop, "Action Extrapolation",
+                                "Action to take for gaps past the Active Action's range (when evaluating with NLA)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_NLA, NULL); /* this will do? */
        
        prop = RNA_def_property(srna, "action_blend_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "act_blendmode");
        RNA_def_property_enum_items(prop, nla_mode_blend_items);
-       RNA_def_property_ui_text(prop, "Action Blending", "Method used for combining Active Action's result with result of NLA stack");
+       RNA_def_property_ui_text(prop, "Action Blending",
+                                "Method used for combining Active Action's result with result of NLA stack");
        RNA_def_property_update(prop, NC_ANIMATION|ND_NLA, NULL); /* this will do? */
        
        prop = RNA_def_property(srna, "action_influence", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "act_influence");
        RNA_def_property_float_default(prop, 1.0f);
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Action Influence", "Amount the Active Action contributes to the result of the NLA stack");
+       RNA_def_property_ui_text(prop, "Action Influence",
+                                "Amount the Active Action contributes to the result of the NLA stack");
        RNA_def_property_update(prop, NC_ANIMATION|ND_NLA, NULL); /* this will do? */
        
        /* Drivers */
index f47f8eb88cf5209464d1c205b7283e5406a9559f..c3c4a1355fd00c79cca774cf841e8431f8172104 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,7 @@
  * The Original Code is Copyright (C) 2009 Blender Foundation.
  * All rights reserved.
  *
- * 
+ *
  * Contributor(s): Joshua Leung
  *
  * ***** END GPL LICENSE BLOCK *****
@@ -74,9 +74,10 @@ void RNA_api_keyingset(StructRNA *srna)
        
        /* validate relative Keying Set (used to ensure paths are ok for context) */
        func = RNA_def_function(srna, "refresh", "rna_KeyingSet_context_refresh");
-       RNA_def_function_ui_description(func, "Refresh Keying Set to ensure that it is valid for the current context. Call before each use of one");
+       RNA_def_function_ui_description(func,
+                                       "Refresh Keying Set to ensure that it is valid for the current context "
+                                       "(call before each use of one)");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
 }
 
 #endif
-
index adc3640dae46e27e6aff009a4394024a2d15beda..f7065307d87055641a4056fa070311f14617dd83 100644 (file)
@@ -92,7 +92,7 @@ void rna_def_motionpath_common(StructRNA *srna)
        
        prop = RNA_def_property(srna, "motion_path", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "mpath");
-       RNA_def_property_ui_text(prop, "Motion Path", "Motion Path for this element");  
+       RNA_def_property_ui_text(prop, "Motion Path", "Motion Path for this element");
 }
 
 static void rna_def_animviz_motionpath_vert(BlenderRNA *brna)
@@ -147,7 +147,8 @@ static void rna_def_animviz_motion_path(BlenderRNA *brna)
        prop = RNA_def_property(srna, "use_bone_head", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_BHEAD);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* xxx */
-       RNA_def_property_ui_text(prop, "Use Bone Heads", "For PoseBone paths, use the bone head location when calculating this path");
+       RNA_def_property_ui_text(prop, "Use Bone Heads",
+                                "For PoseBone paths, use the bone head location when calculating this path");
        
        prop = RNA_def_property(srna, "is_modified", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", MOTIONPATH_FLAG_EDIT);
@@ -184,39 +185,49 @@ static void rna_def_animviz_ghosts(BlenderRNA *brna)
        /* Settings */
        prop = RNA_def_property(srna, "show_only_selected", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "ghost_flag", GHOST_FLAG_ONLYSEL);
-       RNA_def_property_ui_text(prop, "On Selected Bones Only", "For Pose-Mode drawing, only draw ghosts for selected bones");
+       RNA_def_property_ui_text(prop, "On Selected Bones Only",
+                                "For Pose-Mode drawing, only draw ghosts for selected bones");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_step", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ghost_step");
        RNA_def_property_range(prop, 1, 20);
-       RNA_def_property_ui_text(prop, "Frame Step", "Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Frame Step",
+                                "Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        /* Playback Ranges */
        prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_sf");
        RNA_def_property_int_funcs(prop, NULL, "rna_AnimViz_ghost_start_frame_set", NULL);
-       RNA_def_property_ui_text(prop, "Start Frame", "Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Start Frame",
+                                "Starting frame of range of Ghosts to display "
+                                "(not for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_ef");
        RNA_def_property_int_funcs(prop, NULL, "rna_AnimViz_ghost_end_frame_set", NULL);
-       RNA_def_property_ui_text(prop, "End Frame", "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "End Frame",
+                                "End frame of range of Ghosts to display "
+                                "(not for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        /* Around Current Ranges */
        prop = RNA_def_property(srna, "frame_before", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_bc");
        RNA_def_property_range(prop, 0, 30);
-       RNA_def_property_ui_text(prop, "Before Current", "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Before Current",
+                                "Number of frames to show before the current frame "
+                                "(only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_after", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "ghost_ac");
        RNA_def_property_range(prop, 0, 30);
-       RNA_def_property_ui_text(prop, "After Current", "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "After Current",
+                                "Number of frames to show after the current frame "
+                                "(only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
 }
 
@@ -226,7 +237,8 @@ static void rna_def_animviz_paths(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static const EnumPropertyItem prop_type_items[] = {
-               {MOTIONPATH_TYPE_ACFRA, "CURRENT_FRAME", 0, "Around Frame", "Display Paths of poses within a fixed number of frames around the current frame"},
+               {MOTIONPATH_TYPE_ACFRA, "CURRENT_FRAME", 0, "Around Frame",
+                                       "Display Paths of poses within a fixed number of frames around the current frame"},
                {MOTIONPATH_TYPE_RANGE, "RANGE", 0, "In Range", "Display Paths of poses within specified range"},
                {0, NULL, 0, NULL, NULL}};
        static const EnumPropertyItem prop_location_items[] = {
@@ -270,13 +282,16 @@ static void rna_def_animviz_paths(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "show_keyframe_action_all", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "path_viewflag", MOTIONPATH_VIEW_KFACT);
-       RNA_def_property_ui_text(prop, "All Action Keyframes", "For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)");
+       RNA_def_property_ui_text(prop, "All Action Keyframes",
+                                "For bone motion paths, search whole Action for keyframes instead of in group"
+                                " with matching name only (is slower)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_step", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "path_step");
        RNA_def_property_range(prop, 1, 100);
-       RNA_def_property_ui_text(prop, "Frame Step", "Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Frame Step",
+                                "Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        
@@ -284,26 +299,34 @@ static void rna_def_animviz_paths(BlenderRNA *brna)
        prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_sf");
        RNA_def_property_int_funcs(prop, NULL, "rna_AnimViz_path_start_frame_set", NULL);
-       RNA_def_property_ui_text(prop, "Start Frame", "Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Start Frame",
+                                "Starting frame of range of paths to display/calculate "
+                                "(not for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_ef");
        RNA_def_property_int_funcs(prop, NULL, "rna_AnimViz_path_end_frame_set", NULL);
-       RNA_def_property_ui_text(prop, "End Frame", "End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "End Frame",
+                                "End frame of range of paths to display/calculate "
+                                "(not for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        /* Around Current Ranges */
        prop = RNA_def_property(srna, "frame_before", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_bc");
        RNA_def_property_range(prop, 1, MAXFRAMEF/2);
-       RNA_def_property_ui_text(prop, "Before Current", "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "Before Current",
+                                "Number of frames to show before the current frame "
+                                "(only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
        
        prop = RNA_def_property(srna, "frame_after", PROP_INT, PROP_TIME);
        RNA_def_property_int_sdna(prop, NULL, "path_ac");
        RNA_def_property_range(prop, 1, MAXFRAMEF/2);
-       RNA_def_property_ui_text(prop, "After Current", "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)");
+       RNA_def_property_ui_text(prop, "After Current",
+                                "Number of frames to show after the current frame "
+                                "(only for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL); /* XXX since this is only for 3d-view drawing */
 }
 
@@ -316,7 +339,7 @@ void rna_def_animviz_common(StructRNA *srna)
        prop = RNA_def_property(srna, "animation_visualisation", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_pointer_sdna(prop, NULL, "avs");
-       RNA_def_property_ui_text(prop, "Animation Visualisation", "Animation data for this datablock"); 
+       RNA_def_property_ui_text(prop, "Animation Visualisation", "Animation data for this datablock");
 }
 
 static void rna_def_animviz(BlenderRNA *brna)
index b6d07d079f14cfd485f3791c58b07104b4a68cf1..f6763b4dcde748165b50d9f55ce68b9de803319d 100644 (file)
@@ -494,7 +494,8 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        
        prop = RNA_def_property(srna, "use_cyclic_offset", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
-       RNA_def_property_ui_text(prop, "Cyclic Offset", "When bone doesn't have a parent, it receives cyclic offset effects");
+       RNA_def_property_ui_text(prop, "Cyclic Offset",
+                                "When bone doesn't have a parent, it receives cyclic offset effects");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
        prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
@@ -520,7 +521,8 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        if (editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
        else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        RNA_def_property_float_sdna(prop, NULL, "rad_head");
-       /*RNA_def_property_range(prop, 0, 1000);   *//* XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid); */
+               /* XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid); */
+       /*RNA_def_property_range(prop, 0, 1000); */
        RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
        RNA_def_property_ui_text(prop, "Envelope Head Radius", "Radius of head of bone (for Envelope deform only)");
        
@@ -528,7 +530,8 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
        if (editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
        else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        RNA_def_property_float_sdna(prop, NULL, "rad_tail");
-       /*RNA_def_property_range(prop, 0, 1000);   *//* XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid); */
+               /* XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid); */
+       /*RNA_def_property_range(prop, 0, 1000); */
        RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
        RNA_def_property_ui_text(prop, "Envelope Tail Radius", "Radius of tail of bone (for Envelope deform only)");
        
@@ -592,10 +595,12 @@ static void rna_def_bone(BlenderRNA *brna)
 
        rna_def_bone_common(srna, 0);
 
-               /* XXX should we define this in PoseChannel wrapping code instead? but PoseChannels directly get some of their flags from here... */
+               /* XXX should we define this in PoseChannel wrapping code instead?
+                *     But PoseChannels directly get some of their flags from here... */
        prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_P);
-       RNA_def_property_ui_text(prop, "Hide", "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)");
+       RNA_def_property_ui_text(prop, "Hide",
+                                "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
 
        prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
@@ -736,7 +741,8 @@ static void rna_def_edit_bone(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_flag(prop, PROP_THICK_WRAP); /* no reference to original data */
        RNA_def_property_ui_text(prop, "Editbone Matrix", "Read-only matrix calculated from the roll (armature space)");
-       RNA_def_property_float_funcs(prop, "rna_EditBone_matrix_get", NULL, NULL); /* TODO - this could be made writable also */
+               /* TODO - this could be made writable also */
+       RNA_def_property_float_funcs(prop, "rna_EditBone_matrix_get", NULL, NULL);
 
        RNA_api_armature_edit_bone(srna);
 
@@ -824,7 +830,8 @@ static void rna_def_armature(BlenderRNA *brna)
                {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Display bones as octahedral shape (default)"},
                {ARM_LINE, "STICK", 0, "Stick", "Display bones as simple 2D lines with dots"},
                {ARM_B_BONE, "BBONE", 0, "B-Bone", "Display bones as boxes, showing subdivision and B-Splines"},
-               {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope", "Display bones as extruded spheres, showing deformation influence volume"},
+               {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope",
+                              "Display bones as extruded spheres, showing deformation influence volume"},
                {ARM_WIRE, "WIRE", 0, "Wire", "Display bones as thin wires, showing subdivision and B-Splines"},
                {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem prop_vdeformer[] = {
@@ -911,7 +918,8 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
        RNA_def_property_array(prop, 32);
        RNA_def_property_ui_text(prop, "Layer Proxy Protection",
-                                "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo");
+                                "Protected layers in Proxy Instances are restored to Proxy settings "
+                                "on file reload and undo");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
                
                /* flag */
@@ -978,11 +986,14 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Use Dual Quaternion Deformation", "Enable deform rotation with Quaternions");
        RNA_def_property_update(prop, 0, "rna_Armature_update_data");
        
-       /*prop= RNA_def_property(srna, "deform_invert_vertexgroups", PROP_BOOLEAN, PROP_NONE); */
-       /*RNA_def_property_boolean_negative_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP); */
-       /*RNA_def_property_ui_text(prop, "Invert Vertex Group Influence", "Invert Vertex Group influence (only for Modifiers)"); */
-       /*RNA_def_property_update(prop, 0, "rna_Armature_update_data"); */
-       
+#if 0
+       prop = RNA_def_property(srna, "deform_invert_vertexgroups", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
+       RNA_def_property_ui_text(prop, "Invert Vertex Group Influence",
+                                "Invert Vertex Group influence (only for Modifiers)");
+       RNA_def_property_update(prop, 0, "rna_Armature_update_data");
+#endif
+
        /* Number fields */
 /* XXX depreceated ....... old animviz for armatures only */
                /* ghost/onionskining settings */
@@ -1016,10 +1027,11 @@ static void rna_def_armature(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "ghostef");
        RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_end_frame_set", NULL);
        RNA_def_property_ui_text(prop, "Ghosting End Frame",
-                                "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)");
+                                "End frame of range of Ghosts to display "
+                                "(not for 'Around Current Frame' Onion-skinning method)");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
        RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
-/* XXX depreceated ....... old animviz for armatures only       */
+/* XXX depreceated ....... old animviz for armatures only */
 }
 
 void RNA_def_armature(BlenderRNA *brna)
index 08c0a5b54aa3cd9615e1e0635a2aef0279f7770d..4a872dca952425881157b187b508a1517ce32aa2 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,7 @@
  * The Original Code is Copyright (C) 2009 Blender Foundation.
  * All rights reserved.
  *
- * 
+ *
  * Contributor(s): Campbell Barton
  *
  * ***** END GPL LICENSE BLOCK *****
@@ -50,7 +50,8 @@ void rna_EditBone_align_roll(EditBone *ebo, float no[3])
 float rna_Bone_do_envelope(Bone *bone, float *vec)
 {
        float scale = (bone->flag & BONE_MULT_VG_ENV) == BONE_MULT_VG_ENV ? bone->weight : 1.0f;
-       return distfactor_to_bone(vec, bone->arm_head, bone->arm_tail, bone->rad_head * scale, bone->rad_tail * scale, bone->dist * scale);
+       return distfactor_to_bone(vec, bone->arm_head, bone->arm_tail, bone->rad_head * scale,
+                                 bone->rad_tail * scale, bone->dist * scale);
 }
 
 #else
index 0db401334cdcf1e88d272949458919a38d93012d..3767a019a629de6474612530ab7355fc69a4e207 100644 (file)
 EnumPropertyItem boidrule_type_items[] = {
        {eBoidRuleType_Goal, "GOAL", 0, "Goal", "Go to assigned object or loudest assigned signal source"},
        {eBoidRuleType_Avoid, "AVOID", 0, "Avoid", "Get away from assigned object or loudest assigned signal source"},
-       {eBoidRuleType_AvoidCollision, "AVOID_COLLISION", 0, "Avoid Collision", "Manoeuvre to avoid collisions with other boids and deflector objects in near future"},
+       {eBoidRuleType_AvoidCollision, "AVOID_COLLISION", 0, "Avoid Collision",
+                                      "Manoeuvre to avoid collisions with other boids and deflector objects in "
+                                      "near future"},
        {eBoidRuleType_Separate, "SEPARATE", 0, "Separate", "Keep from going through other boids"},
        {eBoidRuleType_Flock, "FLOCK", 0, "Flock", "Move to center of neighbors and match their velocity"},
        {eBoidRuleType_FollowLeader, "FOLLOW_LEADER", 0, "Follow Leader", "Follow a boid or assigned object"},
        {eBoidRuleType_AverageSpeed, "AVERAGE_SPEED", 0, "Average Speed", "Maintain speed, flight level or wander"},
        {eBoidRuleType_Fight, "FIGHT", 0, "Fight", "Go to closest enemy and attack when in range"},
-       /*{eBoidRuleType_Protect, "PROTECT", 0, "Protect", "Go to enemy closest to target and attack when in range"}, */
-       /*{eBoidRuleType_Hide, "HIDE", 0, "Hide", "Find a deflector move to it's other side from closest enemy"}, */
-       /*{eBoidRuleType_FollowPath, "FOLLOW_PATH", 0, "Follow Path", "Move along a assigned curve or closest curve in a group"}, */
-       /*{eBoidRuleType_FollowWall, "FOLLOW_WALL", 0, "Follow Wall", "Move next to a deflector object's in direction of it's tangent"}, */
+#if 0
+       {eBoidRuleType_Protect, "PROTECT", 0, "Protect", "Go to enemy closest to target and attack when in range"},
+       {eBoidRuleType_Hide, "HIDE", 0, "Hide", "Find a deflector move to it's other side from closest enemy"},
+       {eBoidRuleType_FollowPath, "FOLLOW_PATH", 0, "Follow Path",
+                                  "Move along a assigned curve or closest curve in a group"},
+       {eBoidRuleType_FollowWall, "FOLLOW_WALL", 0, "Follow Wall",
+                                  "Move next to a deflector object's in direction of it's tangent"},
+#endif
        {0, NULL, 0, NULL, NULL}};
 
 EnumPropertyItem boidruleset_type_items[] = {
-       {eBoidRulesetType_Fuzzy, "FUZZY", 0, "Fuzzy", "Rules are gone through top to bottom. Only the first rule that effect above fuzziness threshold is evaluated"},
+       {eBoidRulesetType_Fuzzy, "FUZZY", 0, "Fuzzy",
+                                "Rules are gone through top to bottom (only the first rule which effect is above "
+                                "fuzziness threshold is evaluated)"},
        {eBoidRulesetType_Random, "RANDOM", 0, "Random", "A random rule is selected for each boid"},
        {eBoidRulesetType_Average, "AVERAGE", 0, "Average", "All rules are averaged"},
        {0, NULL, 0, NULL, NULL}};
@@ -464,7 +472,9 @@ static void rna_def_boidstate(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Active Boid Rule", "");
 
        prop = RNA_def_property(srna, "active_boid_rule_index", PROP_INT, PROP_UNSIGNED);
-       RNA_def_property_int_funcs(prop, "rna_BoidState_active_boid_rule_index_get", "rna_BoidState_active_boid_rule_index_set", "rna_BoidState_active_boid_rule_index_range");
+       RNA_def_property_int_funcs(prop, "rna_BoidState_active_boid_rule_index_get",
+                                  "rna_BoidState_active_boid_rule_index_set",
+                                  "rna_BoidState_active_boid_rule_index_range");
        RNA_def_property_ui_text(prop, "Active Boid Rule Index", "");
 
        prop = RNA_def_property(srna, "rule_fuzzy", PROP_FLOAT, PROP_NONE);
@@ -526,7 +536,9 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Active Boid Rule", "");
 
        prop = RNA_def_property(srna, "active_boid_state_index", PROP_INT, PROP_UNSIGNED);
-       RNA_def_property_int_funcs(prop, "rna_BoidSettings_active_boid_state_index_get", "rna_BoidSettings_active_boid_state_index_set", "rna_BoidSettings_active_boid_state_index_range");
+       RNA_def_property_int_funcs(prop, "rna_BoidSettings_active_boid_state_index_get",
+                                  "rna_BoidSettings_active_boid_state_index_set",
+                                  "rna_BoidSettings_active_boid_state_index_range");
        RNA_def_property_ui_text(prop, "Active Boid State Index", "");
 
        /* character properties */
@@ -577,7 +589,8 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "air_ave_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "air_max_ave");
        RNA_def_property_range(prop, 0.0, 1.0);
-       RNA_def_property_ui_text(prop, "Max Air Angular Velocity", "Maximum angular velocity in air (relative to 180 degrees)");
+       RNA_def_property_ui_text(prop, "Max Air Angular Velocity",
+                                "Maximum angular velocity in air (relative to 180 degrees)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        prop = RNA_def_property(srna, "air_personal_space", PROP_FLOAT, PROP_NONE);
@@ -599,18 +612,21 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "land_acc_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "land_max_acc");
        RNA_def_property_range(prop, 0.0, 1.0);
-       RNA_def_property_ui_text(prop, "Max Land Acceleration", "Maximum acceleration on land (relative to maximum speed)");
+       RNA_def_property_ui_text(prop, "Max Land Acceleration",
+                                "Maximum acceleration on land (relative to maximum speed)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        prop = RNA_def_property(srna, "land_ave_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "land_max_ave");
        RNA_def_property_range(prop, 0.0, 1.0);
-       RNA_def_property_ui_text(prop, "Max Land Angular Velocity", "Maximum angular velocity on land (relative to 180 degrees)");
+       RNA_def_property_ui_text(prop, "Max Land Angular Velocity",
+                                "Maximum angular velocity on land (relative to 180 degrees)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        prop = RNA_def_property(srna, "land_personal_space", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0.0, 10.0);
-       RNA_def_property_ui_text(prop, "Land Personal Space", "Radius of boids personal space on land (% of particle size)");
+       RNA_def_property_ui_text(prop, "Land Personal Space",
+                                "Radius of boids personal space on land (% of particle size)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        prop = RNA_def_property(srna, "land_stick_force", PROP_FLOAT, PROP_NONE);
index a7b5afbb8a0069ed765c1362a593dc69f90d28e3..01c426ae9c14e2dcc8455d5f62b38c067b72bfe8 100644 (file)
@@ -300,7 +300,8 @@ static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
        brush->unprojected_radius = value;
 }
 
-static EnumPropertyItem *rna_Brush_direction_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *UNUSED(free))
+static EnumPropertyItem *rna_Brush_direction_itemf(bContext *UNUSED(C), PointerRNA *ptr,
+                                                   PropertyRNA *UNUSED(prop), int *UNUSED(free))
 {
        static EnumPropertyItem prop_default_items[] = {
                {0, NULL, 0, NULL, NULL}};
@@ -593,14 +594,16 @@ static void rna_def_brush(BlenderRNA *brna)
        RNA_def_property_float_default(prop, 0);
        RNA_def_property_range(prop, -2.0f, 2.0f);
        RNA_def_property_ui_range(prop, -0.5f, 0.5f, 0.001, 0.001);
-       RNA_def_property_ui_text(prop, "Plane Offset", "Adjust plane on which the brush acts towards or away from the object surface");
+       RNA_def_property_ui_text(prop, "Plane Offset",
+                                "Adjust plane on which the brush acts towards or away from the object surface");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
        prop = RNA_def_property(srna, "plane_trim", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "plane_trim");
        RNA_def_property_float_default(prop, 0.5f);
        RNA_def_property_range(prop, 0, 1.0f);
-       RNA_def_property_ui_text(prop, "Plane Trim", "If a vertex is further away from offset plane than this, then it is not affected");
+       RNA_def_property_ui_text(prop, "Plane Trim",
+                                "If a vertex is further away from offset plane than this, then it is not affected");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
        prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_DISTANCE);
@@ -647,7 +650,8 @@ static void rna_def_brush(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_original_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ORIGINAL_NORMAL);
-       RNA_def_property_ui_text(prop, "Original Normal", "When locked keep using normal of surface where stroke was initiated");
+       RNA_def_property_ui_text(prop, "Original Normal",
+                                "When locked keep using normal of surface where stroke was initiated");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
        
        prop = RNA_def_property(srna, "use_wrap", PROP_BOOLEAN, PROP_NONE);
@@ -738,18 +742,22 @@ static void rna_def_brush(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_space_attenuation", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE_ATTEN);
-       RNA_def_property_ui_text(prop, "Use Automatic Strength Adjustment", "Automatically adjust strength to give consistent results for different spacings");
+       RNA_def_property_ui_text(prop, "Use Automatic Strength Adjustment",
+                                "Automatically adjust strength to give consistent results for different spacings");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
        /* adaptive space is not implemented yet */
        prop = RNA_def_property(srna, "use_adaptive_space", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ADAPTIVE_SPACE);
-       RNA_def_property_ui_text(prop, "Adaptive Spacing", "Space daubs according to surface orientation instead of screen space");
+       RNA_def_property_ui_text(prop, "Adaptive Spacing",
+                                "Space daubs according to surface orientation instead of screen space");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
        prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LOCK_SIZE);
-       RNA_def_property_ui_text(prop, "Use Blender Units", "When locked brush stays same size relative to object; when unlocked brush size is given in pixels");
+       RNA_def_property_ui_text(prop, "Use Blender Units",
+                                "When locked brush stays same size relative to object; when unlocked brush size is "
+                                "given in pixels");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
        prop = RNA_def_property(srna, "use_texture_overlay", PROP_BOOLEAN, PROP_NONE);
@@ -794,11 +802,11 @@ static void rna_def_brush(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_paint_weight", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_WEIGHT_PAINT);
-       RNA_def_property_ui_text(prop, "Use Weight", "Use this brush in weight paint mode");    
+       RNA_def_property_ui_text(prop, "Use Weight", "Use this brush in weight paint mode");
 
        prop = RNA_def_property(srna, "use_paint_image", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_TEXTURE_PAINT);
-       RNA_def_property_ui_text(prop, "Use Texture", "Use this brush in texture paint mode");  
+       RNA_def_property_ui_text(prop, "Use Texture", "Use this brush in texture paint mode");
 
        /* texture */
        prop = RNA_def_property(srna, "texture_slot", PROP_POINTER, PROP_NONE);
@@ -919,7 +927,8 @@ static void rna_def_operator_stroke_element(BlenderRNA *brna)
        /* XXX: Tool (this will be for pressing a modifier key for a different brush,
                        e.g. switching to a Smooth brush in the middle of the stroke */
 
-       /* XXX: i don't think blender currently supports the ability to properly do a remappable modifier in the middle of a stroke */
+       /* XXX: i don't think blender currently supports the ability to properly do a remappable modifier
+        *      in the middle of a stroke */
 }
 
 void RNA_def_brush(BlenderRNA *brna)
index 084e299140d8fca6b083d257fb739c63a2fc0250..180479d6f6355f0f1f7ee1f106f27795e012b4fc 100644 (file)
@@ -247,7 +247,8 @@ void RNA_def_camera(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "show_passepartout", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CAM_SHOWPASSEPARTOUT);
-       RNA_def_property_ui_text(prop, "Show Passepartout", "Show a darkened overlay outside the image area in Camera view");
+       RNA_def_property_ui_text(prop, "Show Passepartout",
+                                "Show a darkened overlay outside the image area in Camera view");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, NULL);
 
        prop = RNA_def_property(srna, "show_title_safe", PROP_BOOLEAN, PROP_NONE);
@@ -272,7 +273,8 @@ void RNA_def_camera(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_panorama", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CAM_PANORAMA);
-       RNA_def_property_ui_text(prop, "Panorama", "Render the scene with a cylindrical camera for pseudo-fisheye lens effects");
+       RNA_def_property_ui_text(prop, "Panorama",
+                                "Render the scene with a cylindrical camera for pseudo-fisheye lens effects");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, NULL);
 
        /* pointers */
@@ -290,4 +292,3 @@ void RNA_def_camera(BlenderRNA *brna)
 }
 
 #endif
-
index 3cd33be1b8658bc1ea8868bff214bfe7357d361c..14391e74239e85db7b369d521186b0df010dd919 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
index 34a9dc592b94b2ebce6509f5cd0a925f4294ace8..2f6a31ff8eed658d13655f523b80d22e109f3404 100644 (file)
@@ -222,19 +222,22 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "goal_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "mingoal");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Goal Minimum", "Goal minimum, vertex group weights are scaled to match this range");
+       RNA_def_property_ui_text(prop, "Goal Minimum",
+                                "Goal minimum, vertex group weights are scaled to match this range");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "goal_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "maxgoal");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Goal Maximum", "Goal maximum, vertex group weights are scaled to match this range");
+       RNA_def_property_ui_text(prop, "Goal Maximum",
+                                "Goal maximum, vertex group weights are scaled to match this range");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "goal_default", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "defgoal");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Goal Default", "Default Goal (vertex target position) value, when no Vertex Group used");
+       RNA_def_property_ui_text(prop, "Goal Default",
+                                "Default Goal (vertex target position) value, when no Vertex Group used");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
        
        prop = RNA_def_property(srna, "goal_spring", PROP_FLOAT, PROP_NONE);
@@ -328,7 +331,8 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "spring_damping", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "Cdis");
        RNA_def_property_range(prop, 0.0f, 50.0f);
-       RNA_def_property_ui_text(prop, "Spring Damping", "Damping of cloth velocity (higher = more smooth, less jiggling)");
+       RNA_def_property_ui_text(prop, "Spring Damping",
+                                "Damping of cloth velocity (higher = more smooth, less jiggling)");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
        
        prop = RNA_def_property(srna, "structural_stiffness", PROP_FLOAT, PROP_NONE);
@@ -345,7 +349,8 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "vertex_group_structural_stiffness", PROP_STRING, PROP_NONE);
-       RNA_def_property_string_funcs(prop, "rna_ClothSettings_struct_vgroup_get", "rna_ClothSettings_struct_vgroup_length",
+       RNA_def_property_string_funcs(prop, "rna_ClothSettings_struct_vgroup_get",
+                                     "rna_ClothSettings_struct_vgroup_length",
                                      "rna_ClothSettings_struct_vgroup_set");
        RNA_def_property_ui_text(prop, "Structural Stiffness Vertex Group",
                                 "Vertex group for fine control over structural stiffness");
@@ -354,7 +359,8 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "bending_stiffness", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "bending");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
-       RNA_def_property_ui_text(prop, "Bending Stiffness", "Wrinkle coefficient (higher = less smaller but more big wrinkles)");
+       RNA_def_property_ui_text(prop, "Bending Stiffness",
+                                "Wrinkle coefficient (higher = less smaller but more big wrinkles)");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "bending_stiffness_max", PROP_FLOAT, PROP_NONE);
@@ -367,7 +373,8 @@ static void rna_def_cloth_sim_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "vertex_group_bending", PROP_STRING, PROP_NONE);
        RNA_def_property_string_funcs(prop, "rna_ClothSettings_bend_vgroup_get", "rna_ClothSettings_bend_vgroup_length",
                                      "rna_ClothSettings_bend_vgroup_set");
-       RNA_def_property_ui_text(prop, "Bending Stiffness Vertex Group", "Vertex group for fine control over bending stiffness");
+       RNA_def_property_ui_text(prop, "Bending Stiffness Vertex Group",
+                                "Vertex group for fine control over bending stiffness");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
@@ -501,7 +508,8 @@ static void rna_def_cloth_collision_settings(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "self_loop_count");
        RNA_def_property_range(prop, 1, 10);
        RNA_def_property_ui_text(prop, "Self Collision Quality",
-                                "How many self collision iterations should be done (higher is better quality but slower)");
+                                "How many self collision iterations should be done "
+                                "(higher is better quality but slower)");
        RNA_def_property_update(prop, 0, "rna_cloth_update");
 
        prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
@@ -517,4 +525,3 @@ void RNA_def_cloth(BlenderRNA *brna)
 }
 
 #endif
-
index 490f06c6fbf33e246088ce6a262b9bf18cdd5821..8ced52bd63c683ade23ad8b2a2c366a8aa5b0e03 100644 (file)
@@ -140,11 +140,11 @@ static char *rna_ColorRamp_path(PointerRNA *ptr)
                ID *id = ptr->id.data;
                
                switch (GS(id->name)) {
-                       case ID_MA:     /* material has 2 cases - diffuse and specular */ 
+                       case ID_MA:     /* material has 2 cases - diffuse and specular */
                        {
                                Material *ma = (Material*)id;
                                
-                               if (ptr->data == ma->ramp_col) 
+                               if (ptr->data == ma->ramp_col)
                                        return BLI_strdup("diffuse_ramp");
                                else if (ptr->data == ma->ramp_spec)
                                        return BLI_strdup("specular_ramp");
@@ -164,18 +164,18 @@ static char *rna_ColorRampElement_path(PointerRNA *ptr)
        char *path = NULL;
        int index;
        
-       /* helper macro for use here to try and get the path 
+       /* helper macro for use here to try and get the path
         *      - this calls the standard code for getting a path to a texture...
         */
 
 #define COLRAMP_GETPATH                                                       \
 {                                                                             \
-       prop = RNA_struct_find_property(&ramp_ptr, "elements");                    \
+       prop = RNA_struct_find_property(&ramp_ptr, "elements");                   \
        if (prop) {                                                               \
-               index = RNA_property_collection_lookup_index(&ramp_ptr, prop, ptr);    \
+               index = RNA_property_collection_lookup_index(&ramp_ptr, prop, ptr);   \
                if (index >= 0) {                                                     \
-                       char *texture_path = rna_ColorRamp_path(&ramp_ptr);                \
-                       path = BLI_sprintfN("%s.elements[%d]", texture_path, index);       \
+                       char *texture_path = rna_ColorRamp_path(&ramp_ptr);               \
+                       path = BLI_sprintfN("%s.elements[%d]", texture_path, index);      \
                        MEM_freeN(texture_path);                                          \
                }                                                                     \
        }                                                                         \
@@ -205,7 +205,7 @@ static char *rna_ColorRampElement_path(PointerRNA *ptr)
                                break;
                                
                                /* TODO: node trees need special attention */
-                       case ID_NT: 
+                       case ID_NT:
                        {
                                bNodeTree *ntree = (bNodeTree *)id;
                                bNode *node;
@@ -372,7 +372,9 @@ static void rna_def_curvemapping(BlenderRNA *brna)
        PropertyRNA *prop;
 
        srna = RNA_def_struct(brna, "CurveMapping", NULL);
-       RNA_def_struct_ui_text(srna, "CurveMapping", "Curve mapping to map color, vector and scalar values to other values using a user defined curve");
+       RNA_def_struct_ui_text(srna, "CurveMapping",
+                              "Curve mapping to map color, vector and scalar values to other values using "
+                              "a user defined curve");
        
        prop = RNA_def_property(srna, "use_clip", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CUMA_DO_CLIP);
@@ -404,7 +406,9 @@ static void rna_def_curvemapping(BlenderRNA *brna)
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_CurveMapping_clipmaxy_range");
 
        prop = RNA_def_property(srna, "curves", PROP_COLLECTION, PROP_NONE);
-       RNA_def_property_collection_funcs(prop, "rna_CurveMapping_curves_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_CurveMapping_curves_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_CurveMapping_curves_begin", "rna_iterator_array_next",
+                                         "rna_iterator_array_end", "rna_iterator_array_get",
+                                         "rna_CurveMapping_curves_length", NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "CurveMap");
        RNA_def_property_ui_text(prop, "Curves", "");
 
@@ -520,7 +524,8 @@ static void rna_def_color_ramp(BlenderRNA *brna)
        prop = RNA_def_float(func, "position", 1.0f, 0.0f, 1.0f, "Position", "Evaluate ColorRamp at position", 0.0f, 1.0f);
        RNA_def_property_flag(prop, PROP_REQUIRED);
        /* return */
-       prop = RNA_def_float_color(func, "color", 4, NULL, -FLT_MAX, FLT_MAX, "Color", "Color at given position", -FLT_MAX, FLT_MAX);
+       prop = RNA_def_float_color(func, "color", 4, NULL, -FLT_MAX, FLT_MAX, "Color", "Color at given position",
+                                  -FLT_MAX, FLT_MAX);
        RNA_def_property_flag(prop, PROP_THICK_WRAP);
        RNA_def_function_output(func, prop);
 }
@@ -611,4 +616,3 @@ void RNA_def_color(BlenderRNA *brna)
 }
 
 #endif
-
index 883b72ef832d9bd37c905566113eac32b2626430..6c067bba4e7df9244115e5a21ee1b49762a348d2 100644 (file)
@@ -60,12 +60,15 @@ EnumPropertyItem constraint_type_items[] = {
        {CONSTRAINT_TYPE_TRANSFORM, "TRANSFORM", ICON_CONSTRAINT_DATA, "Transformation", ""},
        {0, "", 0, "Tracking", ""},
        {CONSTRAINT_TYPE_CLAMPTO, "CLAMP_TO", ICON_CONSTRAINT_DATA, "Clamp To", ""},
-       {CONSTRAINT_TYPE_DAMPTRACK, "DAMPED_TRACK", ICON_CONSTRAINT_DATA, "Damped Track", "Tracking by taking the shortest path"},
+       {CONSTRAINT_TYPE_DAMPTRACK, "DAMPED_TRACK", ICON_CONSTRAINT_DATA, "Damped Track",
+                                   "Tracking by taking the shortest path"},
        {CONSTRAINT_TYPE_KINEMATIC, "IK", ICON_CONSTRAINT_DATA, "Inverse Kinematics", ""},
-       {CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", ICON_CONSTRAINT_DATA, "Locked Track", "Tracking along a single axis"},
+       {CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", ICON_CONSTRAINT_DATA, "Locked Track",
+                                   "Tracking along a single axis"},
        {CONSTRAINT_TYPE_SPLINEIK, "SPLINE_IK", ICON_CONSTRAINT_DATA, "Spline IK", ""},
        {CONSTRAINT_TYPE_STRETCHTO, "STRETCH_TO",ICON_CONSTRAINT_DATA, "Stretch To", ""},
-       {CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", ICON_CONSTRAINT_DATA, "Track To", "Legacy tracking constraint prone to twisting artifacts"},
+       {CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", ICON_CONSTRAINT_DATA, "Track To",
+                                 "Legacy tracking constraint prone to twisting artifacts"},
        {0, "", 0, "Relationship", ""},
        {CONSTRAINT_TYPE_ACTION, "ACTION", ICON_CONSTRAINT_DATA, "Action", ""},
        {CONSTRAINT_TYPE_CHILDOF, "CHILD_OF", ICON_CONSTRAINT_DATA, "Child Of", ""},
@@ -78,24 +81,39 @@ EnumPropertyItem constraint_type_items[] = {
        {0, NULL, 0, NULL, NULL}};
 
 static EnumPropertyItem target_space_pchan_items[] = {
-       {CONSTRAINT_SPACE_WORLD,    "WORLD", 0, "World Space", "The transformation of the target is evaluated relative to the world coordinate system"},
-       {CONSTRAINT_SPACE_POSE,     "POSE", 0, "Pose Space", "The transformation of the target is only evaluated in the Pose Space, the target armature object transformation is ignored"},
-       {CONSTRAINT_SPACE_PARLOCAL, "LOCAL_WITH_PARENT", 0, "Local With Parent", "The transformation of the target bone is evaluated relative its local coordinate system, with the parent transformation added"},
-       {CONSTRAINT_SPACE_LOCAL,    "LOCAL", 0, "Local Space", "The transformation of the target is evaluated relative to its local coordinate system"},
+       {CONSTRAINT_SPACE_WORLD,    "WORLD", 0, "World Space",
+                                   "The transformation of the target is evaluated relative to the world "
+                                   "coordinate system"},
+       {CONSTRAINT_SPACE_POSE,     "POSE", 0, "Pose Space",
+                                   "The transformation of the target is only evaluated in the Pose Space, "
+                                   "the target armature object transformation is ignored"},
+       {CONSTRAINT_SPACE_PARLOCAL, "LOCAL_WITH_PARENT", 0, "Local With Parent",
+                                   "The transformation of the target bone is evaluated relative its local "
+                                   "coordinate system, with the parent transformation added"},
+       {CONSTRAINT_SPACE_LOCAL,    "LOCAL", 0, "Local Space",
+                                   "The transformation of the target is evaluated relative to its local "
+                                   "coordinate system"},
        {0, NULL, 0, NULL, NULL}};
 
 static EnumPropertyItem owner_space_pchan_items[] = {
-       {CONSTRAINT_SPACE_WORLD,    "WORLD", 0, "World Space", "The constraint is applied relative to the world coordinate system"},
-       {CONSTRAINT_SPACE_POSE,     "POSE", 0, "Pose Space", "The constraint is applied in Pose Space, the object transformation is ignored"},
-       {CONSTRAINT_SPACE_PARLOCAL, "LOCAL_WITH_PARENT", 0, "Local With Parent", "The constraint is applied relative to the local coordinate system of the object, with the parent transformation added"},
-       {CONSTRAINT_SPACE_LOCAL,    "LOCAL", 0, "Local Space", "The constraint is applied relative to the local coordinate sytem of the object"},
+       {CONSTRAINT_SPACE_WORLD,    "WORLD", 0, "World Space",
+                                   "The constraint is applied relative to the world coordinate system"},
+       {CONSTRAINT_SPACE_POSE,     "POSE", 0, "Pose Space",
+                                   "The constraint is applied in Pose Space, the object transformation is ignored"},
+       {CONSTRAINT_SPACE_PARLOCAL, "LOCAL_WITH_PARENT", 0, "Local With Parent",
+                                   "The constraint is applied relative to the local coordinate system of the object, "
+                                   "with the parent transformation added"},
+       {CONSTRAINT_SPACE_LOCAL,    "LOCAL", 0, "Local Space",
+                                   "The constraint is applied relative to the local coordinate sytem of the object"},
        {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
 
 static EnumPropertyItem space_object_items[] = {
-       {CONSTRAINT_SPACE_WORLD, "WORLD", 0, "World Space", "The transformation of the target is evaluated relative to the world coordinate system"},
-       {CONSTRAINT_SPACE_LOCAL, "LOCAL", 0, "Local Space", "The transformation of the target is evaluated relative to its local coordinate system"},
+       {CONSTRAINT_SPACE_WORLD, "WORLD", 0, "World Space",
+                                "The transformation of the target is evaluated relative to the world coordinate system"},
+       {CONSTRAINT_SPACE_LOCAL, "LOCAL", 0, "Local Space",
+                                "The transformation of the target is evaluated relative to its local coordinate system"},
        {0, NULL, 0, NULL, NULL}};
 
 #include "BKE_animsys.h"
@@ -139,7 +157,7 @@ static StructRNA *rna_ConstraintType_refine(struct PointerRNA *ptr)
                case CONSTRAINT_TYPE_RIGIDBODYJOINT:
                        return &RNA_RigidBodyJointConstraint;
                case CONSTRAINT_TYPE_CLAMPTO:
-                       return &RNA_ClampToConstraint;                  
+                       return &RNA_ClampToConstraint;
                case CONSTRAINT_TYPE_TRANSFORM:
                        return &RNA_TransformConstraint;
                case CONSTRAINT_TYPE_ROTLIMIT:
@@ -189,7 +207,7 @@ static void rna_Constraint_name_set(PointerRNA *ptr, const char *value)
                
                /* if we have the list, check for unique name, otherwise give up */
                if (list)
-                       unique_constraint_name(con, list); 
+                       unique_constraint_name(con, list);
        }
        
        /* fix all the animation data which may link to this */
@@ -204,7 +222,8 @@ static char *rna_Constraint_path(PointerRNA *ptr)
        ListBase *lb = get_constraint_lb(ob, con, &pchan);
 
        if (lb == NULL)
-               printf("rna_Constraint_path: internal error, constraint '%s' not found in object '%s'\n", con->name, ob->id.name);
+               printf("rna_Constraint_path: internal error, constraint '%s' not found in object '%s'\n",
+                      con->name, ob->id.name);
 
        if (pchan) {
                return BLI_sprintfN("pose.bones[\"%s\"].constraints[\"%s\"]", pchan->name, con->name);
@@ -251,7 +270,8 @@ static void rna_Constraint_ik_type_set(struct PointerRNA *ptr, int value)
        }
 }
 
-static EnumPropertyItem *rna_Constraint_owner_space_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *UNUSED(free))
+static EnumPropertyItem *rna_Constraint_owner_space_itemf(bContext *UNUSED(C), PointerRNA *ptr,
+                                                          PropertyRNA *UNUSED(prop), int *UNUSED(free))
 {
        Object *ob = (Object*)ptr->id.data;
        bConstraint *con = (bConstraint*)ptr->data;
@@ -262,7 +282,8 @@ static EnumPropertyItem *rna_Constraint_owner_space_itemf(bContext *UNUSED(C), P
                return space_object_items;
 }
 
-static EnumPropertyItem *rna_Constraint_target_space_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *UNUSED(free))
+static EnumPropertyItem *rna_Constraint_target_space_itemf(bContext *UNUSED(C), PointerRNA *ptr,
+                                                           PropertyRNA *UNUSED(prop), int *UNUSED(free))
 {
        bConstraint *con = (bConstraint*)ptr->data;
        bConstraintTypeInfo *cti = constraint_get_typeinfo(con);
@@ -404,9 +425,15 @@ static void rna_Constraint_objectSolver_camera_set(PointerRNA *ptr, PointerRNA v
 #else
 
 EnumPropertyItem constraint_distance_items[] = {
-       {LIMITDIST_INSIDE, "LIMITDIST_INSIDE", 0, "Inside", "The object is constrained inside a virtual sphere around the target object, with a radius defined by the limit distance"},
-       {LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", 0, "Outside", "The object is constrained outside a virtual sphere around the target object, with a radius defined by the limit distance"},
-       {LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", 0, "On Surface", "The object is constrained on the surface of a virtual sphere around the target object, with a radius defined by the limit distance"},
+       {LIMITDIST_INSIDE, "LIMITDIST_INSIDE", 0, "Inside",
+                          "The object is constrained inside a virtual sphere around the target object, "
+                          "with a radius defined by the limit distance"},
+       {LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", 0, "Outside",
+                           "The object is constrained outside a virtual sphere around the target object, "
+                           "with a radius defined by the limit distance"},
+       {LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", 0, "On Surface",
+                             "The object is constrained on the surface of a virtual sphere around the target object, "
+                             "with a radius defined by the limit distance"},
        {0, NULL, 0, NULL, NULL}
 };
 
@@ -440,9 +467,9 @@ static void rna_def_constraint_childof(BlenderRNA *brna)
        StructRNA *srna;
        PropertyRNA *prop;
 
-       srna = RNA_def_struct(brna, "ChildOfConstraint", "Constraint"); 
-       RNA_def_struct_ui_text(srna, "Child Of Constraint", "Create constraint-based parent-child relationship"); 
-       RNA_def_struct_sdna_from(srna, "bChildOfConstraint", "data"); 
+       srna = RNA_def_struct(brna, "ChildOfConstraint", "Constraint");
+       RNA_def_struct_ui_text(srna, "Child Of Constraint", "Create constraint-based parent-child relationship");
+       RNA_def_struct_sdna_from(srna, "bChildOfConstraint", "data");
 
        prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "tar");
@@ -621,7 +648,8 @@ static void rna_def_constraint_kinematic(BlenderRNA *brna)
        prop = RNA_def_property(srna, "reference_axis", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
        RNA_def_property_enum_items(prop, constraint_ik_axisref_items);
-       RNA_def_property_ui_text(prop, "Axis Reference", "Constraint axis Lock options relative to Bone or Target reference");
+       RNA_def_property_ui_text(prop, "Axis Reference",
+                                "Constraint axis Lock options relative to Bone or Target reference");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
        prop = RNA_def_property(srna, "use_location", PROP_BOOLEAN, PROP_NONE);
@@ -926,7 +954,8 @@ static void rna_def_constraint_same_volume(BlenderRNA *brna)
        {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "MaintainVolumeConstraint", "Constraint");
-       RNA_def_struct_ui_text(srna, "Maintain Volume Constraint", "Maintain a constant volume along a single scaling axis");
+       RNA_def_struct_ui_text(srna, "Maintain Volume Constraint",
+                              "Maintain a constant volume along a single scaling axis");
        RNA_def_struct_sdna_from(srna, "bSameVolumeConstraint", "data");
 
        prop = RNA_def_property(srna, "free_axis", PROP_ENUM, PROP_NONE);
@@ -1055,7 +1084,8 @@ static void rna_def_constraint_action(BlenderRNA *brna)
        prop = RNA_def_property(srna, "transform_channel", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "type");
        RNA_def_property_enum_items(prop, transform_channel_items);
-       RNA_def_property_ui_text(prop, "Transform Channel", "Transformation channel from the target that is used to key the Action");
+       RNA_def_property_ui_text(prop, "Transform Channel",
+                                "Transformation channel from the target that is used to key the Action");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
        prop = RNA_def_property(srna, "action", PROP_POINTER, PROP_NONE);
@@ -1112,7 +1142,8 @@ static void rna_def_constraint_locked_track(BlenderRNA *brna)
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "LockedTrackConstraint", "Constraint");
-       RNA_def_struct_ui_text(srna, "Locked Track Constraint", "Point toward the target along the track axis, while locking the other axis");
+       RNA_def_struct_ui_text(srna, "Locked Track Constraint",
+                              "Point toward the target along the track axis, while locking the other axis");
        
        prop = RNA_def_property(srna, "head_tail", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, "bConstraint", "headtail");
@@ -1206,7 +1237,9 @@ static void rna_def_constraint_follow_path(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_fixed_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "followflag", FOLLOWPATH_STATIC);
-       RNA_def_property_ui_text(prop, "Fixed Position", "Object will stay locked to a single point somewhere along the length of the curve regardless of time");
+       RNA_def_property_ui_text(prop, "Fixed Position",
+                                "Object will stay locked to a single point somewhere along the length of the curve "
+                                "regardless of time");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
        prop = RNA_def_property(srna, "use_curve_radius", PROP_BOOLEAN, PROP_NONE);
@@ -1285,8 +1318,10 @@ static void rna_def_constraint_rigid_body_joint(BlenderRNA *brna)
        static EnumPropertyItem pivot_items[] = {
                {CONSTRAINT_RB_BALL, "BALL", 0, "Ball", "Allow rotations around all axes"},
                {CONSTRAINT_RB_HINGE, "HINGE", 0, "Hinge", "Work in one plane, allow rotations around one axis only"},
-               {CONSTRAINT_RB_CONETWIST, "CONE_TWIST", 0, "Cone Twist", "Allow rotations around all axes with limits for the cone and twist axes"},
-               {CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", 0, "Generic 6 DoF", "No constraints by default, limits can be set individually"},
+               {CONSTRAINT_RB_CONETWIST, "CONE_TWIST", 0, "Cone Twist",
+                                         "Allow rotations around all axes with limits for the cone and twist axes"},
+               {CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", 0, "Generic 6 DoF",
+                                           "No constraints by default, limits can be set individually"},
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "RigidBodyJointConstraint", "Constraint");
@@ -1459,7 +1494,8 @@ static void rna_def_constraint_clamp_to(BlenderRNA *brna)
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "ClampToConstraint", "Constraint");
-       RNA_def_struct_ui_text(srna, "Clamp To Constraint", "Constrains an object's location to the nearest point along the target path");
+       RNA_def_struct_ui_text(srna, "Clamp To Constraint",
+                              "Constrains an object's location to the nearest point along the target path");
        RNA_def_struct_sdna_from(srna, "bClampToConstraint", "data");
 
        prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
@@ -1899,13 +1935,16 @@ static void rna_def_constraint_shrinkwrap(BlenderRNA *brna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", 0, "Nearest Surface Point", "Shrink the location to the nearest target surface"},
-               {MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project", "Shrink the location to the nearest target surface along a given axis"},
-               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex", "Shrink the location to the nearest target vertex"},
+               {MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", 0, "Nearest Surface Point",
+                                                "Shrink the location to the nearest target surface"},
+               {MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project",
+                                        "Shrink the location to the nearest target surface along a given axis"},
+               {MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex",
+                                               "Shrink the location to the nearest target vertex"},
                {0, NULL, 0, NULL, NULL}};
        
-       srna = RNA_def_struct(brna, "ShrinkwrapConstraint", "Constraint"); 
-       RNA_def_struct_ui_text(srna, "Shrinkwrap Constraint", "Create constraint-based shrinkwrap relationship"); 
+       srna = RNA_def_struct(brna, "ShrinkwrapConstraint", "Constraint");
+       RNA_def_struct_ui_text(srna, "Shrinkwrap Constraint", "Create constraint-based shrinkwrap relationship");
        RNA_def_struct_sdna_from(srna, "bShrinkwrapConstraint", "data");
        
        prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
@@ -1958,7 +1997,8 @@ static void rna_def_constraint_damped_track(BlenderRNA *brna)
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "DampedTrackConstraint", "Constraint");
-       RNA_def_struct_ui_text(srna, "Damped Track Constraint", "Point toward target by taking the shortest rotation path");
+       RNA_def_struct_ui_text(srna, "Damped Track Constraint",
+                              "Point toward target by taking the shortest rotation path");
        
        prop = RNA_def_property(srna, "head_tail", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, "bConstraint", "headtail");
@@ -1992,8 +2032,10 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        
        static EnumPropertyItem splineik_xz_scale_mode[] = {
                {CONSTRAINT_SPLINEIK_XZS_NONE, "NONE", 0, "None", "Don't scale the X and Z axes (Default)"},
-               {CONSTRAINT_SPLINEIK_XZS_ORIGINAL, "BONE_ORIGINAL", 0, "Bone Original", "Use the original scaling of the bones"},
-               {CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC, "VOLUME_PRESERVE", 0, "Volume Preservation", "Scale of the X and Z axes is the inverse of the Y-Scale"},
+               {CONSTRAINT_SPLINEIK_XZS_ORIGINAL, "BONE_ORIGINAL", 0, "Bone Original",
+                                                  "Use the original scaling of the bones"},
+               {CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC, "VOLUME_PRESERVE", 0, "Volume Preservation",
+                                                    "Scale of the X and Z axes is the inverse of the Y-Scale"},
                {0, NULL, 0, NULL, NULL}};
 
        srna = RNA_def_struct(brna, "SplineIKConstraint", "Constraint");
@@ -2009,9 +2051,11 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "chain_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "chainlen");
-       RNA_def_property_range(prop, 1, 255); /* TODO: this should really check the max length of the chain the constraint is attached to */
+               /* TODO: this should really check the max length of the chain the constraint is attached to */
+       RNA_def_property_range(prop, 1, 255);
        RNA_def_property_ui_text(prop, "Chain Length", "How many bones are included in the chain");
-       RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update"); /* XXX: this update goes wrong... needs extra flush? */
+               /* XXX: this update goes wrong... needs extra flush? */
+       RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
        
        /* direct access to bindings */
        /* NOTE: only to be used by experienced users */
@@ -2019,8 +2063,11 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        RNA_def_property_array(prop, 32); /* XXX this is the maximum value allowed - why?  */
        RNA_def_property_flag(prop, PROP_DYNAMIC);
        RNA_def_property_dynamic_array_funcs(prop, "rna_SplineIKConstraint_joint_bindings_get_length");
-       RNA_def_property_float_funcs(prop, "rna_SplineIKConstraint_joint_bindings_get", "rna_SplineIKConstraint_joint_bindings_set", NULL);
-       RNA_def_property_ui_text(prop, "Joint Bindings", "(EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages");
+       RNA_def_property_float_funcs(prop, "rna_SplineIKConstraint_joint_bindings_get",
+                                    "rna_SplineIKConstraint_joint_bindings_set", NULL);
+       RNA_def_property_ui_text(prop, "Joint Bindings",
+                                "(EXPERIENCED USERS ONLY) The relative positions of the joints along the chain, "
+                                "as percentages");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        /* settings */
@@ -2031,7 +2078,8 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_even_divisions", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_SPLINEIK_EVENSPLITS);
-       RNA_def_property_ui_text(prop, "Even Divisions", "Ignore the relative lengths of the bones when fitting to the curve");
+       RNA_def_property_ui_text(prop, "Even Divisions",
+                                "Ignore the relative lengths of the bones when fitting to the curve");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        prop = RNA_def_property(srna, "use_y_stretch", PROP_BOOLEAN, PROP_NONE);
@@ -2041,13 +2089,16 @@ static void rna_def_constraint_spline_ik(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_curve_radius", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_SPLINEIK_NO_CURVERAD);
-       RNA_def_property_ui_text(prop, "Use Curve Radius", "Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode");
+       RNA_def_property_ui_text(prop, "Use Curve Radius",
+                                "Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, "
+                                "on top of XZ Scale mode");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        prop = RNA_def_property(srna, "xz_scale_mode", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "xzScaleMode");
        RNA_def_property_enum_items(prop, splineik_xz_scale_mode);
-       RNA_def_property_ui_text(prop, "XZ Scale Mode", "Method used for determining the scaling of the X and Z axes of the bones");
+       RNA_def_property_ui_text(prop, "XZ Scale Mode",
+                                "Method used for determining the scaling of the X and Z axes of the bones");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 }
 
@@ -2058,9 +2109,12 @@ static void rna_def_constraint_pivot(BlenderRNA *brna)
 
        static EnumPropertyItem pivot_rotAxis_items[] = {
                {PIVOTCON_AXIS_NONE, "ALWAYS_ACTIVE", 0, "Always", "Use the pivot point in every rotation"},
-               {PIVOTCON_AXIS_X_NEG, "NX", 0, "-X Rot", "Use the pivot point in the negative rotation range around the X-axis"},
-               {PIVOTCON_AXIS_Y_NEG, "NY", 0, "-Y Rot", "Use the pivot point in the negative rotation range around the Y-axis"},
-               {PIVOTCON_AXIS_Z_NEG, "NZ", 0, "-Z Rot", "Use the pivot point in the negative rotation range around the Z-axis"},
+               {PIVOTCON_AXIS_X_NEG, "NX", 0, "-X Rot",
+                                     "Use the pivot point in the negative rotation range around the X-axis"},
+               {PIVOTCON_AXIS_Y_NEG, "NY", 0, "-Y Rot",
+                                     "Use the pivot point in the negative rotation range around the Y-axis"},
+               {PIVOTCON_AXIS_Z_NEG, "NZ", 0, "-Z Rot",
+                                     "Use the pivot point in the negative rotation range around the Z-axis"},
                {PIVOTCON_AXIS_X, "X", 0, "X Rot", "Use the pivot point in the positive rotation range around the X-axis"},
                {PIVOTCON_AXIS_Y, "Y", 0, "Y Rot", "Use the pivot point in the positive rotation range around the Y-axis"},
                {PIVOTCON_AXIS_Z, "Z", 0, "Z Rot", "Use the pivot point in the positive rotation range around the Z-axis"},
@@ -2091,12 +2145,15 @@ static void rna_def_constraint_pivot(BlenderRNA *brna)
        /* pivot offset */
        prop = RNA_def_property(srna, "use_relative_location", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PIVOTCON_FLAG_OFFSET_ABS);
-       RNA_def_property_ui_text(prop, "Use Relative Offset", "Offset will be an absolute point in space instead of relative to the target");
+       RNA_def_property_ui_text(prop, "Use Relative Offset",
+                                "Offset will be an absolute point in space instead of relative to the target");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_XYZ);
        RNA_def_property_float_sdna(prop, NULL, "offset");
-       RNA_def_property_ui_text(prop, "Offset", "Offset of pivot from target (when set), or from owner's location (when Fixed Position is off), or the absolute pivot point");
+       RNA_def_property_ui_text(prop, "Offset",
+                                "Offset of pivot from target (when set), or from owner's location "
+                                "(when Fixed Position is off), or the absolute pivot point");
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
        
        /* rotation-based activation */
@@ -2150,18 +2207,22 @@ static void rna_def_constraint_follow_track(BlenderRNA *brna)
        /* camera */
        prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "camera");
-       RNA_def_property_ui_text(prop, "Camera", "Camera to which motion is parented (if empty active scene camera is used)");
+       RNA_def_property_ui_text(prop, "Camera",
+                                "Camera to which motion is parented (if empty active scene camera is used)");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
-       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_followTrack_camera_set", NULL, "rna_Constraint_cameraObject_poll");
+       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_followTrack_camera_set", NULL,
+                                      "rna_Constraint_cameraObject_poll");
 
        /* depth object */
        prop = RNA_def_property(srna, "depth_object", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "depth_ob");
-       RNA_def_property_ui_text(prop, "Depth Object", "Object used to define depth in camera space by projecting onto surface of this object");
+       RNA_def_property_ui_text(prop, "Depth Object",
+                                "Object used to define depth in camera space by projecting onto surface of this object");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
-       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_followTrack_depthObject_set", NULL, "rna_Constraint_followTrack_depthObject_poll");
+       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_followTrack_depthObject_set", NULL,
+                                      "rna_Constraint_followTrack_depthObject_poll");
 }
 
 static void rna_def_constraint_camera_solver(BlenderRNA *brna)
@@ -2218,10 +2279,12 @@ static void rna_def_constraint_object_solver(BlenderRNA *brna)
        /* camera */
        prop = RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "camera");
-       RNA_def_property_ui_text(prop, "Camera", "Camera to which motion is parented (if empty active scene camera is used)");
+       RNA_def_property_ui_text(prop, "Camera",
+                                "Camera to which motion is parented (if empty active scene camera is used)");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
-       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_objectSolver_camera_set", NULL, "rna_Constraint_cameraObject_poll");
+       RNA_def_property_pointer_funcs(prop, NULL, "rna_Constraint_objectSolver_camera_set", NULL,
+                                      "rna_Constraint_cameraObject_poll");
 }
 
 /* base struct for constraints */
@@ -2286,7 +2349,8 @@ void RNA_def_constraint(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "is_proxy_local", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_PROXY_LOCAL);
-       RNA_def_property_ui_text(prop, "Proxy Local", "Constraint was added in this proxy instance (i.e. did not belong to source Armature)");
+       RNA_def_property_ui_text(prop, "Proxy Local",
+                                "Constraint was added in this proxy instance (i.e. did not belong to source Armature)");
        
        /* values */
        prop = RNA_def_property(srna, "influence", PROP_FLOAT, PROP_FACTOR);
@@ -2299,12 +2363,14 @@ void RNA_def_constraint(BlenderRNA *brna)
        prop = RNA_def_property(srna, "error_location", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "lin_error");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Lin error", "Amount of residual error in Blender space unit for constraints that work on position");
+       RNA_def_property_ui_text(prop, "Lin error",
+                                "Amount of residual error in Blender space unit for constraints that work on position");
 
        prop = RNA_def_property(srna, "error_rotation", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rot_error");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-       RNA_def_property_ui_text(prop, "Rot error", "Amount of residual error in radiant for constraints that work on orientation");
+       RNA_def_property_ui_text(prop, "Rot error",
+                                "Amount of residual error in radiant for constraints that work on orientation");
 
        /* pointers */
        rna_def_constrainttarget(brna);
@@ -2340,4 +2406,3 @@ void RNA_def_constraint(BlenderRNA *brna)
 }
 
 #endif
-
index b066114a0cbd257ae58c28a9b7eb5ba8076f8d13..fa18c92b86ac1ba5daebfd0d4a1b16206932e06e 100644 (file)
@@ -195,7 +195,8 @@ void RNA_def_controller(BlenderRNA *brna)
        srna = RNA_def_struct(brna, "Controller", NULL);
        RNA_def_struct_sdna(srna, "bController");
        RNA_def_struct_refine_func(srna, "rna_Controller_refine");
-       RNA_def_struct_ui_text(srna, "Controller", "Game engine logic brick to process events, connecting sensors to actuators");
+       RNA_def_struct_ui_text(srna, "Controller",
+                              "Game engine logic brick to process events, connecting sensors to actuators");
 
        RNA_api_controller(srna);
 
@@ -215,12 +216,14 @@ void RNA_def_controller(BlenderRNA *brna)
        prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONT_SHOW);
        RNA_def_property_ui_text(prop, "Expanded", "Set controller expanded in the user interface");
-       RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);     
+       RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_priority", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONT_PRIO);
-       RNA_def_property_ui_text(prop, "Priority", "Mark controller for execution before all non-marked controllers (good for startup scripts)");
+       RNA_def_property_ui_text(prop, "Priority",
+                                "Mark controller for execution before all non-marked controllers "
+                                "(good for startup scripts)");
        RNA_def_property_ui_icon(prop, ICON_BOOKMARKS, 1);
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
@@ -228,7 +231,9 @@ void RNA_def_controller(BlenderRNA *brna)
        RNA_def_property_collection_sdna(prop, NULL, "links", NULL);
        RNA_def_property_struct_type(prop, "Actuator");
        RNA_def_property_ui_text(prop, "Actuators", "The list containing the actuators connected to the controller");
-       RNA_def_property_collection_funcs(prop, "rna_Controller_actuators_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_dereference_get", "rna_Controller_actuators_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_Controller_actuators_begin", "rna_iterator_array_next",
+                                         "rna_iterator_array_end", "rna_iterator_array_dereference_get",
+                                         "rna_Controller_actuators_length", NULL, NULL, NULL);
 
        /* State */
        
@@ -251,7 +256,8 @@ void RNA_def_controller(BlenderRNA *brna)
        /* Expression Controller */
        srna = RNA_def_struct(brna, "ExpressionController", "Controller");
        RNA_def_struct_sdna_from(srna, "bExpressionCont", "data");
-       RNA_def_struct_ui_text(srna, "Expression Controller", "Controller passing on events based on the evaluation of an expression");
+       RNA_def_struct_ui_text(srna, "Expression Controller",
+                              "Controller passing on events based on the evaluation of an expression");
 
        prop = RNA_def_property(srna, "expression", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "str");
@@ -276,12 +282,16 @@ void RNA_def_controller(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "module", PROP_STRING, PROP_NONE);
-       RNA_def_property_ui_text(prop, "Module", "Module name and function to run, e.g. \"someModule.main\" (internal texts and external python files can be used)");
+       RNA_def_property_ui_text(prop, "Module",
+                                "Module name and function to run, e.g. \"someModule.main\" "
+                                "(internal texts and external python files can be used)");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        prop = RNA_def_property(srna, "use_debug", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CONT_PY_DEBUG);
-       RNA_def_property_ui_text(prop, "D", "Continuously reload the module from disk for editing external modules without restarting");
+       RNA_def_property_ui_text(prop, "D",
+                                "Continuously reload the module from disk for editing external modules "
+                                "without restarting");
        RNA_def_property_update(prop, NC_LOGIC, NULL);
 
        /* Other Controllers */
@@ -305,4 +315,3 @@ void RNA_def_controller(BlenderRNA *brna)
 }
 
 #endif
-
index 3c517868baf351d407cbe115ee2cba6921ca87fc..6fe90e1721be0951f84233187fae34ee16c80483 100644 (file)
@@ -4,7 +4,7 @@
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,7 +18,7 @@
  * The Original Code is Copyright (C) 2010 Blender Foundation.
  * All rights reserved.
  *
- * 
+ *
  * Contributor(s):
  *
  * ***** END GPL LICENSE BLOCK *****
@@ -67,16 +67,16 @@ void RNA_api_controller(StructRNA *srna)
 
        func = RNA_def_function(srna, "link", "rna_Controller_link");
        RNA_def_function_ui_description(func, "Link the controller with a sensor/actuator");
-       parm = RNA_def_pointer(func, "sensor", "Sensor", "", "Sensor to link the controller to"); 
+       parm = RNA_def_pointer(func, "sensor", "Sensor", "", "Sensor to link the controller to");
        RNA_def_property_update(parm, NC_LOGIC, NULL);
-       parm = RNA_def_pointer(func, "actuator", "Actuator", "", "Actuator to link the controller to"); 
+       parm = RNA_def_pointer(func, "actuator", "Actuator", "", "Actuator to link the controller to");
        RNA_def_property_update(parm, NC_LOGIC, NULL);
 
        func = RNA_def_function(srna, "unlink", "rna_Controller_unlink");
        RNA_def_function_ui_description(func, "Unlink the controller from a sensor/actuator");
-       parm = RNA_def_pointer(func, "sensor", "Sensor", "", "Sensor to unlink the controller from"); 
+       parm = RNA_def_pointer(func, "sensor", "Sensor", "", "Sensor to unlink the controller from");
        RNA_def_property_update(parm, NC_LOGIC, NULL);
-       parm = RNA_def_pointer(func, "actuator", "Actuator", "", "Actuator to unlink the controller from"); 
+       parm = RNA_def_pointer(func, "actuator", "Actuator", "", "Actuator to unlink the controller from");
        RNA_def_property_update(parm, NC_LOGIC, NULL);
 }
 
index dbd0320bd2fa2f118bbde43604a7ba90a2b9fbb5..bb6d5ba93abe4ea925593e9c241e756e6e90ab14 100644 (file)
@@ -274,7 +274,8 @@ static void rna_Curve_dimension_set(PointerRNA *ptr, int value)
        update_curve_dimension(cu);
 }
 
-static EnumPropertyItem *rna_Curve_fill_mode_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *UNUSED(free))
+static EnumPropertyItem *rna_Curve_fill_mode_itemf(bContext *UNUSED(C), PointerRNA *ptr,
+                                                   PropertyRNA *UNUSED(prop), int *UNUSED(free))
 {
        Curve *cu = (Curve*)ptr->id.data;
 
@@ -298,7 +299,8 @@ static void rna_Nurb_type_set(PointerRNA *ptr, int value)
 static void rna_BPoint_array_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        Nurb *nu = (Nurb*)ptr->data;
-       rna_iterator_array_begin(iter, (void*)nu->bp, sizeof(BPoint), nu->pntsv>0 ? nu->pntsu*nu->pntsv : nu->pntsu, 0, NULL);
+       rna_iterator_array_begin(iter, (void*)nu->bp, sizeof(BPoint),
+                                nu->pntsv > 0 ? nu->pntsu*nu->pntsv : nu->pntsu, 0, NULL);
 }
 
 static void rna_Curve_update_data_id(Main *UNUSED(bmain), Scene *UNUSED(scene), ID *id)
@@ -459,11 +461,14 @@ void rna_Curve_body_set(PointerRNA *ptr, const char *value)
 
        cu->len = cu->pos = len;
 
-       if (cu->str)            MEM_freeN(cu->str);
-       if (cu->strinfo)        MEM_freeN(cu->strinfo);
+       if (cu->str)
+               MEM_freeN(cu->str);
+       if (cu->strinfo)
+               MEM_freeN(cu->strinfo);
 
        cu->str = MEM_callocN(len + sizeof(wchar_t), "str");
-       cu->strinfo = MEM_callocN( (len+4) *sizeof(CharInfo), "strinfo"); /* don't know why this is +4, just duplicating load_editText() */
+       /* don't know why this is +4, just duplicating load_editText() */
+       cu->strinfo = MEM_callocN((len+4) *sizeof(CharInfo), "strinfo");
 
        /*BLI_strncpy_wchar_as_utf8(cu->str, value, len+1);  *//* value is not wchar_t */
        BLI_strncpy(cu->str, value, len+1);
@@ -833,7 +838,9 @@ static void rna_def_path(BlenderRNA *brna, StructRNA *srna)
        prop = RNA_def_property(srna, "path_duration", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "pathlen");
        RNA_def_property_range(prop, 1, MAXFRAME);
-       RNA_def_property_ui_text(prop, "Path Length", "The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting");
+       RNA_def_property_ui_text(prop, "Path Length",
+                                "The number of frames that are needed to traverse the path, "
+                                "defining the maximum value for the 'Evaluation Time' setting");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
        /* flags */
@@ -857,11 +864,12 @@ static void rna_def_path(BlenderRNA *brna, StructRNA *srna)
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CU_DEFORM_BOUNDS_OFF);
        RNA_def_property_ui_text(prop, "Bounds Clamp", "Option for curve-deform: "
                                 "Use the mesh bounds to clamp the deformation");
-       RNA_def_property_update(prop, 0, "rna_Curve_update_data");      
+       RNA_def_property_update(prop, 0, "rna_Curve_update_data");
 
        prop = RNA_def_property(srna, "use_time_offset", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_OFFS_PATHDIST);
-       RNA_def_property_ui_text(prop, "Offset Path Distance", "Children will use TimeOffs value as path distance offset");
+       RNA_def_property_ui_text(prop, "Offset Path Distance",
+                                "Children will use TimeOffs value as path distance offset");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
 
        prop = RNA_def_property(srna, "use_radius", PROP_BOOLEAN, PROP_NONE);
@@ -976,7 +984,10 @@ static void rna_def_font(BlenderRNA *brna, StructRNA *srna)
        /* strings */
        prop = RNA_def_property(srna, "family", PROP_STRING, PROP_NONE);
        RNA_def_property_string_maxlength(prop, MAX_ID_NAME-2);
-       RNA_def_property_ui_text(prop, "Object Font", "Use Blender Objects as font characters (give font objects a common name followed by the character they represent, eg. familya, familyb, etc, and turn on Verts Duplication)");
+       RNA_def_property_ui_text(prop, "Object Font",
+                                "Use Blender Objects as font characters (give font objects a common name "
+                                "followed by the character they represent, eg. familya, familyb, etc, "
+                                "and turn on Verts Duplication)");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
        prop = RNA_def_property(srna, "body", PROP_STRING, PROP_NONE);
@@ -1243,7 +1254,8 @@ static void rna_def_curve(BlenderRNA *brna)
 
        static const EnumPropertyItem curve_axis_items[] = {
                {0, "2D", 0, "2D", "Clamp the Z axis of the curve"},
-               {CU_3D, "3D", 0, "3D", "Allow editing on the Z axis of this curve, also allows tilt and curve radius to be used"},
+               {CU_3D, "3D", 0, "3D",
+                       "Allow editing on the Z axis of this curve, also allows tilt and curve radius to be used"},
                {0, NULL, 0, NULL, NULL}};
                        
        srna = RNA_def_struct(brna, "Curve", "ID");
@@ -1263,7 +1275,9 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_collection_sdna(prop, NULL, "nurb", NULL);
 #else
        /* this way we get editmode nurbs too, keyframe in editmode */
-       RNA_def_property_collection_funcs(prop, "rna_Curve_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_Curve_splines_begin", "rna_iterator_listbase_next",
+                                         "rna_iterator_listbase_end", "rna_iterator_listbase_get",
+                                         NULL, NULL, NULL, NULL);
 #endif
        RNA_def_property_struct_type(prop, "Spline");
        RNA_def_property_ui_text(prop, "Splines", "Collection of splines in this curve data object");
@@ -1286,7 +1300,8 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "bevresol");
        RNA_def_property_range(prop, 0, 32);
        RNA_def_property_ui_range(prop, 0, 32, 1.0, 0);
-       RNA_def_property_ui_text(prop, "Bevel Resolution", "Bevel resolution when depth is non-zero and no specific bevel object has been defined");
+       RNA_def_property_ui_text(prop, "Bevel Resolution",
+                                "Bevel resolution when depth is non-zero and no specific bevel object has been defined");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
        prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE|PROP_UNIT_LENGTH);
@@ -1327,18 +1342,22 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "resolu_ren");
        RNA_def_property_range(prop, 0, SHRT_MAX);
        RNA_def_property_ui_range(prop, 0, 64, 1, 0);
-       RNA_def_property_ui_text(prop, "Render Resolution U", "Surface resolution in U direction used while rendering (zero skips this property)");
+       RNA_def_property_ui_text(prop, "Render Resolution U",
+                                "Surface resolution in U direction used while rendering (zero skips this property)");
        
        prop = RNA_def_property(srna, "render_resolution_v", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "resolv_ren");
        RNA_def_property_ui_range(prop, 0, 64, 1, 0);
        RNA_def_property_range(prop, 0, SHRT_MAX);
-       RNA_def_property_ui_text(prop, "Render Resolution V", "Surface resolution in V direction used while rendering (zero skips this property)");
+       RNA_def_property_ui_text(prop, "Render Resolution V",
+                                "Surface resolution in V direction used while rendering (zero skips this property)");
        
        
        prop = RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ctime");
-       RNA_def_property_ui_text(prop, "Evaluation Time", "Parametric position along the length of the curve that Objects 'following' it should be at (position is evaluated by dividing by the 'Path Length' value)");
+       RNA_def_property_ui_text(prop, "Evaluation Time",
+                                "Parametric position along the length of the curve that Objects 'following' it should be "
+                                "at (position is evaluated by dividing by the 'Path Length' value)");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
        /* pointers */
@@ -1348,7 +1367,8 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Bevel Object", "Curve object name that defines the bevel shape");
        RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
-       RNA_def_property_pointer_funcs(prop, "rna_Curve_bevelObject_get", "rna_Curve_bevelObject_set", NULL, "rna_Curve_otherObject_poll");
+       RNA_def_property_pointer_funcs(prop, "rna_Curve_bevelObject_get", "rna_Curve_bevelObject_set", NULL,
+                                      "rna_Curve_otherObject_poll");
 
        prop = RNA_def_property(srna, "taper_object", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "Object");
@@ -1356,7 +1376,8 @@ static void rna_def_curve(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Taper Object", "Curve object name that defines the taper (width)");
        RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
-       RNA_def_property_pointer_funcs(prop, "rna_Curve_taperObject_get", "rna_Curve_taperObject_set", NULL, "rna_Curve_otherObject_poll");
+       RNA_def_property_pointer_funcs(prop, "rna_Curve_taperObject_get", "rna_Curve_taperObject_set", NULL,
+                                      "rna_Curve_otherObject_poll");
 
        /* Flags */
 
@@ -1400,14 +1421,15 @@ static void rna_def_curve(BlenderRNA *brna)
        /* texture space */
        prop = RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "texflag", CU_AUTOSPACE);
-       RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjust active object's texture space automatically when transforming object");
+       RNA_def_property_ui_text(prop, "Auto Texture Space",
+                                "Adjust active object's texture space automatically when transforming object");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, "rna_Curve_texspace_set");
 
        prop = RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
        RNA_def_property_array(prop, 3);
        RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
        RNA_def_property_editable_func(prop, "rna_Curve_texspace_editable");
-       RNA_def_property_float_funcs(prop, "rna_Curve_texspace_loc_get", "rna_Curve_texspace_loc_set", NULL);   
+       RNA_def_property_float_funcs(prop, "rna_Curve_texspace_loc_get", "rna_Curve_texspace_loc_set", NULL);
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
        
        prop = RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
@@ -1453,12 +1475,15 @@ static void rna_def_curve_nurb(BlenderRNA *brna)
 
        srna = RNA_def_struct(brna, "Spline", NULL);
        RNA_def_struct_sdna(srna, "Nurb");
-       RNA_def_struct_ui_text(srna, "Spline", "Element of a curve, either NURBS, Bezier or Polyline or a character with text objects");
+       RNA_def_struct_ui_text(srna, "Spline",
+                              "Element of a curve, either NURBS, Bezier or Polyline or a character with text objects");
 
        prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "bp", NULL);
        RNA_def_property_struct_type(prop, "SplinePoint");
-       RNA_def_property_collection_funcs(prop, "rna_BPoint_array_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_Nurb_length", NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_BPoint_array_begin", "rna_iterator_array_next",
+                                         "rna_iterator_array_end", "rna_iterator_array_get", "rna_Nurb_length",
+                                         NULL, NULL, NULL);
        RNA_def_property_ui_text(prop, "Points", "Collection of points that make up this poly or nurbs spline");
        rna_def_curve_spline_points(brna, prop);
 
@@ -1503,13 +1528,17 @@ static void rna_def_curve_nurb(BlenderRNA *brna)
        prop = RNA_def_property(srna, "order_u", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "orderu");
        RNA_def_property_range(prop, 2, 6);
-       RNA_def_property_ui_text(prop, "Order U", "NURBS order in the U direction (for splines and surfaces, higher values let points influence a greater area)");
+       RNA_def_property_ui_text(prop, "Order U",
+                                "NURBS order in the U direction (for splines and surfaces, higher values "
+                                "let points influence a greater area)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
 
        prop = RNA_def_property(srna, "order_v", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "orderv");
        RNA_def_property_range(prop, 2, 6);
-       RNA_def_property_ui_text(prop, "Order V", "NURBS order in the V direction (for surfaces only, higher values let points influence a greater area)");
+       RNA_def_property_ui_text(prop, "Order V",
+                                "NURBS order in the V direction (for surfaces only, higher values "
+                                "let points influence a greater area)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
 
 
@@ -1541,22 +1570,30 @@ static void rna_def_curve_nurb(BlenderRNA *brna)
        /* Note, endpoint and bezier flags should never be on at the same time! */
        prop = RNA_def_property(srna, "use_endpoint_u", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_ENDPOINT);
-       RNA_def_property_ui_text(prop, "Endpoint U", "Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)");
+       RNA_def_property_ui_text(prop, "Endpoint U",
+                                "Make this nurbs curve or surface meet the endpoints in the U direction "
+                                "(Cyclic U must be disabled)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
 
        prop = RNA_def_property(srna, "use_endpoint_v", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_ENDPOINT);
-       RNA_def_property_ui_text(prop, "Endpoint V", "Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)");
+       RNA_def_property_ui_text(prop, "Endpoint V",
+                                "Make this nurbs surface meet the endpoints in the V direction "
+                                "(Cyclic V must be disabled)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
 
        prop = RNA_def_property(srna, "use_bezier_u", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_BEZIER);
-       RNA_def_property_ui_text(prop, "Bezier U", "Make this nurbs curve or surface act like a Bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)");
+       RNA_def_property_ui_text(prop, "Bezier U",
+                                "Make this nurbs curve or surface act like a Bezier spline in the U direction "
+                                "(Order U must be 3 or 4, Cyclic U must be disabled)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
 
        prop = RNA_def_property(srna, "use_bezier_v", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_BEZIER);
-       RNA_def_property_ui_text(prop, "Bezier V", "Make this nurbs surface act like a Bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)");
+       RNA_def_property_ui_text(prop, "Bezier V",
+                                "Make this nurbs surface act like a Bezier spline in the V direction "
+                                "(Order V must be 3 or 4, Cyclic V must be disabled)");
        RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
 
 
@@ -1579,7 +1616,8 @@ static void rna_def_curve_nurb(BlenderRNA *brna)
        prop = RNA_def_property(srna, "character_index", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "charidx");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
-       RNA_def_property_ui_text(prop, "Character Index", "Location of this character in the text data (only for text curves)");
+       RNA_def_property_ui_text(prop, "Character Index",
+                                "Location of this character in the text data (only for text curves)");
        RNA_def_property_update(prop, 0, "rna_Curve_update_data");
 
        RNA_def_struct_path_func(srna, "rna_Curve_spline_path");
@@ -1598,4 +1636,3 @@ void RNA_def_curve(BlenderRNA *brna)
 }
 
 #endif
-
index 78780678af4fcc5a0d97b7cfb46edd6990521a91..5d68bcbd4d79088649b218a6b98f8a96df17c871 100644 (file)
@@ -58,9 +58,9 @@ BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1};
 /* pedantic check for '.', do this since its a hassle for translators */
 #ifndef NDEBUG
 #  define DESCR_CHECK(description, id1, id2)                                  \
-       if (description && (description)[0]) {                                     \
+       if (description && (description)[0]) {                                    \
                int i = strlen(description);                                          \
-               if ((description)[i - 1] == '.') {                                     \
+               if ((description)[i - 1] == '.') {                                    \
                        fprintf(stderr, "%s: '%s' '%s' description ends with a '.' !\n",  \
                                __func__, id1 ? id1 : "", id2 ? id2 : "");                \
                }                                                                     \
@@ -687,7 +687,9 @@ StructRNA *RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *
 
                if (DefRNA.preprocess) {
                        RNA_def_property_struct_type(prop, "Property");
-                       RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", "rna_iterator_listbase_end", "rna_builtin_properties_get", NULL, NULL, "rna_builtin_properties_lookup_string", NULL);
+                       RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next",
+                                                         "rna_iterator_listbase_end", "rna_builtin_properties_get", NULL, NULL,
+                                                         "rna_builtin_properties_lookup_string", NULL);
                }
                else {
 #ifdef RNA_RUNTIME
@@ -890,7 +892,8 @@ PropertyRNA *RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier
                char error[512];
                
                if (rna_validate_identifier(identifier, error, 1) == 0) {
-                       fprintf(stderr, "%s: property identifier \"%s.%s\" - %s\n", __func__, CONTAINER_RNA_ID(cont), identifier, error);
+                       fprintf(stderr, "%s: property identifier \"%s.%s\" - %s\n", __func__,
+                               CONTAINER_RNA_ID(cont), identifier, error);
                        DefRNA.error = 1;
                }
                
@@ -1057,19 +1060,22 @@ void RNA_def_property_array(PropertyRNA *prop, int length)
        StructRNA *srna = DefRNA.laststruct;
 
        if (length<0) {
-               fprintf(stderr, "%s: \"%s.%s\", array length must be zero of greater.\n", __func__, srna->identifier, prop->identifier);
+               fprintf(stderr, "%s: \"%s.%s\", array length must be zero of greater.\n", __func__,
+                       srna->identifier, prop->identifier);
                DefRNA.error = 1;
                return;
        }
 
        if (length>RNA_MAX_ARRAY_LENGTH) {
-               fprintf(stderr, "%s: \"%s.%s\", array length must be smaller than %d.\n", __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
+               fprintf(stderr, "%s: \"%s.%s\", array length must be smaller than %d.\n", __func__,
+                       srna->identifier, prop->identifier, RNA_MAX_ARRAY_LENGTH);
                DefRNA.error = 1;
                return;
        }
 
        if (prop->arraydimension > 1) {
-               fprintf(stderr, "%s: \"%s.%s\", array dimensions has been set to %u but would be overwritten as 1.\n", __func__, srna->identifier, prop->identifier, prop->arraydimension);
+               fprintf(stderr, "%s: \"%s.%s\", array dimensions has been set to %u but would be overwritten as 1.\n",
+                       __func__, srna->identifier, prop->identifier, prop->arraydimension);
                DefRNA.error = 1;
                return;
        }
@@ -1083,7 +1089,8 @@ void RNA_def_property_array(PropertyRNA *prop, int length)
                        prop->arraydimension = 1;
                        break;
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1095,7 +1102,8 @@ void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int le
        int i;
        
        if (dimension < 1 || dimension > RNA_MAX_ARRAY_DIMENSION) {
-               fprintf(stderr, "%s: \"%s.%s\", array dimension must be between 1 and %d.\n", __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
+               fprintf(stderr, "%s: \"%s.%s\", array dimension must be between 1 and %d.\n",
+                       __func__, srna->identifier, prop->identifier, RNA_MAX_ARRAY_DIMENSION);
                DefRNA.error = 1;
                return;
        }
@@ -1106,7 +1114,8 @@ void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int le
                case PROP_FLOAT:
                        break;
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", only boolean/int/float can be array.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1163,7 +1172,8 @@ void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double
                        break;
                }
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", invalid type for ui range.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", invalid type for ui range.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1218,7 +1228,8 @@ void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
                        break;
                }
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1249,7 +1260,8 @@ void RNA_def_property_struct_runtime(PropertyRNA *prop, StructRNA *type)
                        break;
                }
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1284,7 +1296,8 @@ void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item
                        break;
                }
                default:
-                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n", __func__, srna->identifier, prop->identifier);
+                       fprintf(stderr, "%s: \"%s.%s\", invalid type for struct type.\n",
+                               __func__, srna->identifier, prop->identifier);
                        DefRNA.error = 1;
                        break;
        }
@@ -1446,7 +1459,8 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value)
                                }
 
                                if (eprop->defaultvalue & ~totflag) {
-                                       fprintf(stderr, "%s: \"%s.%s\", default includes unused bits (%d).\n", __func__, srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
+                                       fprintf(stderr, "%s: \"%s.%s\", default includes unused bits (%d).\n",
+                                               __func__, srna->identifier, prop->identifier, eprop->defaultvalue & ~totflag);
                                        DefRNA.error = 1;
                                }
                        }
@@ -1461,7 +1475,8 @@ void RNA_def_property_enum_default(PropertyRNA *prop, int value)
                                                eprop->defaultvalue = eprop->item[0].value;
                                        }
                                        else {
-                                               fprintf(stderr, "%s: \"%s.%s\", default is not in items.\n", __func__, srna->identifier, prop->identifier);
+                                               fprintf(stderr, "%s: \"%s.%s\", default is not in items.\n",
+                                                       __func__, srna->identifier, prop->identifier);
                                                DefRNA.error = 1;
                                        }
                                }
@@ -1558,7 +1573,8 @@ void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, co
                if (DefRNA.silent == 0) {
                        /* error check to ensure floats are not wrapped as ints/bools */
                        if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
-                               fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n", __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                               fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
+                                       __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
                                DefRNA.error = 1;
                                return;
                        }
@@ -1568,7 +1584,8 @@ void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, co
        }
 }
 
-void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int booleanbit)
+void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname,
+                                            const char *propname, int booleanbit)
 {
        PropertyDefRNA *dp;
 
@@ -1602,7 +1619,8 @@ void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const
                /* error check to ensure floats are not wrapped as ints/bools */
                if (DefRNA.silent == 0) {
                        if (dp->dnatype && *dp->dnatype && IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
-                               fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n", __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                               fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
+                                       __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
                                DefRNA.error = 1;
                                return;
                        }
@@ -1652,7 +1670,9 @@ void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, cons
                if (DefRNA.silent == 0) {
                        if (dp->dnatype && *dp->dnatype && IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
                                if (prop->subtype != PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
-                                       fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n", __func__, srna->identifier, prop->identifier, dp->dnatype, RNA_property_typename(prop->type));
+                                       fprintf(stderr, "%s: %s.%s is a '%s' but wrapped as type '%s'.\n",
+                                               __func__, srna->identifier, prop->identifier, dp->dnatype,
+                                               RNA_property_typename(prop->type));
                                        DefRNA.error = 1;
                                        return;
                                }
@@ -1690,7 +1710,8 @@ void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const
                        prop->totarraylength = 0;
 
                        if (!DefRNA.silent) {
-                               fprintf(stderr, "%s: \"%s.%s\", array not supported for enum type.\n", __func__, structname, propname);
+                               fprintf(stderr, "%s: \"%s.%s\", array not supported for enum type.\n",
+                                       __func__, structname, propname);
                                DefRNA.error = 1;
                        }
                }
@@ -1757,14 +1778,16 @@ void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, co
                        prop->totarraylength = 0;
 
                        if (!DefRNA.silent) {
-                               fprintf(stderr, "%s: \"%s.%s\", array not supported for pointer type.\n", __func__, structname, propname);
+                               fprintf(stderr, "%s: \"%s.%s\", array not supported for pointer type.\n",
+                                       __func__, structname, propname);
                                DefRNA.error = 1;
                        }
                }
        }
 }
 
-void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
+void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname,
+                                      const char *lengthpropname)
 {
        PropertyDefRNA *dp;
        CollectionPropertyRNA *cprop = (CollectionPropertyRNA*)prop;
@@ -1787,7 +1810,8 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                        prop->totarraylength = 0;
 
                        if (!DefRNA.silent) {
-                               fprintf(stderr, "%s: \"%s.%s\", array of collections not supported.\n", __func__, structname, propname);
+                               fprintf(stderr, "%s: \"%s.%s\", array of collections not supported.\n",
+                                       __func__, structname, propname);
                                DefRNA.error = 1;
                        }
                }
@@ -1821,7 +1845,7 @@ void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname,
                        cprop->next = (PropCollectionNextFunc)"rna_iterator_array_next";
                        cprop->end = (PropCollectionEndFunc)"rna_iterator_array_end";
 
-                       if (dp->dnapointerlevel >= 2) 
+                       if (dp->dnapointerlevel >= 2)
                                cprop->get = (PropCollectionGetFunc)"rna_iterator_array_dereference_get";
                        else
                                cprop->get = (PropCollectionGetFunc)"rna_iterator_array_get";
@@ -2036,7 +2060,8 @@ void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const cha
        }
 }
 
-void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *typef, const char *poll)
+void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set,
+                                    const char *typef, const char *poll)
 {
        StructRNA *srna = DefRNA.laststruct;
 
@@ -2062,7 +2087,9 @@ void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const ch
        }
 }
 
-void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *assignint)
+void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end,
+                                       const char *get, const char *length, const char *lookupint,
+                                       const char *lookupstring, const char *assignint)
 {
        StructRNA *srna = DefRNA.laststruct;
 
@@ -2104,7 +2131,8 @@ void RNA_def_py_data(PropertyRNA *prop, void *py_data)
 
 /* Compact definitions */
 
-PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value, const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, int default_value,
+                             const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2116,8 +2144,8 @@ PropertyRNA *RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier,
        return prop;
 }
 
-PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
+                                   const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2130,8 +2158,8 @@ PropertyRNA *RNA_def_boolean_array(StructOrFunctionRNA *cont_, const char *ident
        return prop;
 }
 
-PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
+                                   const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2144,8 +2172,8 @@ PropertyRNA *RNA_def_boolean_layer(StructOrFunctionRNA *cont_, const char *ident
        return prop;
 }
 
-PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                          int *default_value, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2158,8 +2186,8 @@ PropertyRNA *RNA_def_boolean_layer_member(StructOrFunctionRNA *cont_, const char
        return prop;
 }
 
-PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, int *default_value,
+                                    const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2172,8 +2200,8 @@ PropertyRNA *RNA_def_boolean_vector(StructOrFunctionRNA *cont_, const char *iden
        return prop;
 }
 
-PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin, int hardmax, 
-       const char *ui_name, const char *ui_description, int softmin, int softmax)
+PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin,
+                         int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2187,8 +2215,9 @@ PropertyRNA *RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int
        return prop;
 }
 
-PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value, 
-       int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
+PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
+                                int hardmin, int hardmax, const char *ui_name, const char *ui_description,
+                                int softmin, int softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2203,8 +2232,9 @@ PropertyRNA *RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifi
        return prop;
 }
 
-PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value, 
-       int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
+PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const int *default_value,
+                               int hardmin, int hardmax, const char *ui_name, const char *ui_description,
+                               int softmin, int softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2219,8 +2249,8 @@ PropertyRNA *RNA_def_int_array(StructOrFunctionRNA *cont_, const char *identifie
        return prop;
 }
 
-PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
+                            const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2233,8 +2263,8 @@ PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier,
        return prop;
 }
 
-PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
+                                      int maxlen, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2247,8 +2277,8 @@ PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont_, const char *id
        return prop;
 }
 
-PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
+                                     int maxlen, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2261,8 +2291,8 @@ PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont_, const char *ide
        return prop;
 }
 
-PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
+                                      int maxlen, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2275,8 +2305,8 @@ PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *id
        return prop;
 }
 
-PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen,
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
+                                      int maxlen, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2289,8 +2319,8 @@ PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont_, const char *id
        return prop;
 }
 
-PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, 
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
+                          int default_value, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2309,8 +2339,8 @@ PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, co
 }
 
 /* same as above but sets 'PROP_ENUM_FLAG' before setting the default value */
-PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value,
-       const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items,
+                               int default_value, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2341,8 +2371,9 @@ void RNA_def_enum_py_data(PropertyRNA *prop, void *py_data)
        eprop->py_data = py_data;
 }
 
-PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value, 
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
+                           float hardmin, float hardmax, const char *ui_name, const char *ui_description,
+                           float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2356,8 +2387,9 @@ PropertyRNA *RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, f
        return prop;
 }
 
-PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, 
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                  const char *ui_description, float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2372,19 +2404,22 @@ PropertyRNA *RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identi
        return prop;
 }
 
-PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, 
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_vector_xyz(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                      const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                      const char *ui_description, float softmin, float softmax)
 {
        PropertyRNA *prop;
        
-       prop = RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description, softmin, softmax);
+       prop = RNA_def_float_vector(cont_, identifier, len, default_value, hardmin, hardmax, ui_name, ui_description,
+                                   softmin, softmax);
        prop->subtype = PROP_XYZ_LENGTH;
 
        return prop;
 }
 
-PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value, 
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                 const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                 const char *ui_description, float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2400,8 +2435,9 @@ PropertyRNA *RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identif
 }
 
 
-PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns, const float *default_value, 
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identifier, int rows, int columns,
+                                  const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                  const char *ui_description, float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2420,8 +2456,9 @@ PropertyRNA *RNA_def_float_matrix(StructOrFunctionRNA *cont_, const char *identi
        return prop;
 }
 
-PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                    const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                    const char *ui_description, float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2442,8 +2479,9 @@ PropertyRNA *RNA_def_float_rotation(StructOrFunctionRNA *cont_, const char *iden
        return prop;
 }
 
-PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len, const float *default_value,
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, int len,
+                                 const float *default_value, float hardmin, float hardmax, const char *ui_name,
+                                 const char *ui_description, float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2459,7 +2497,8 @@ PropertyRNA *RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identif
 }
 
 PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+                                      float hardmin, float hardmax, const char *ui_name, const char *ui_description,
+                                      float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2474,7 +2513,8 @@ PropertyRNA *RNA_def_float_percentage(StructOrFunctionRNA *cont_, const char *id
 }
 
 PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identifier, float default_value,
-       float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
+                                  float hardmin, float hardmax, const char *ui_name, const char *ui_description,
+                                  float softmin, float softmax)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2489,7 +2529,7 @@ PropertyRNA *RNA_def_float_factor(StructOrFunctionRNA *cont_, const char *identi
 }
 
 PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
-       const char *ui_name, const char *ui_description)
+                             const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2502,7 +2542,7 @@ PropertyRNA *RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier,
 }
 
 PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
-       const char *ui_name, const char *ui_description)
+                                     const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2515,7 +2555,7 @@ PropertyRNA *RNA_def_pointer_runtime(StructOrFunctionRNA *cont_, const char *ide
 }
 
 PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifier, const char *type,
-       const char *ui_name, const char *ui_description)
+                                const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2528,7 +2568,7 @@ PropertyRNA *RNA_def_collection(StructOrFunctionRNA *cont_, const char *identifi
 }
 
 PropertyRNA *RNA_def_collection_runtime(StructOrFunctionRNA *cont_, const char *identifier, StructRNA *type,
-       const char *ui_name, const char *ui_description)
+                                        const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
@@ -2614,11 +2654,13 @@ FunctionRNA *RNA_def_function_runtime(StructRNA *srna, const char *identifier, C
 void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
 {
        if (ret->flag & PROP_DYNAMIC) {
-               fprintf(stderr, "%s: \"%s.%s\", dynamic values are not allowed as strict returns, use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
+               fprintf(stderr, "%s: \"%s.%s\", dynamic values are not allowed as strict returns, "
+                       "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
                return;
        }
        else if (ret->arraydimension) {
-               fprintf(stderr, "%s: \"%s.%s\", arrays are not allowed as strict returns, use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
+               fprintf(stderr, "%s: \"%s.%s\", arrays are not allowed as strict returns, "
+                       "use RNA_def_function_output instead.\n", __func__, func->identifier, ret->identifier);
                return;
        }
 
@@ -2749,7 +2791,9 @@ void RNA_enum_items_add_value(EnumPropertyItem **items, int *totitem, EnumProper
        for (; item->identifier; item++) {
                if (item->value == value) {
                        RNA_enum_item_add(items, totitem, item);
-                       break; /* break on first match - does this break anything? (is quick hack to get object->parent_type working ok for armature/lattice) */
+                       /* break on first match - does this break anything?
+                        * (is quick hack to get object->parent_type working ok for armature/lattice) */
+                       break;
                }
        }
 }
@@ -2805,7 +2849,8 @@ void RNA_def_property_duplicate_pointers(StructOrFunctionRNA *cont_, PropertyRNA
        int *iarray;
        int a;
 
-       /* annoying since we just added this to a hash, could make this add the correct key to the hash in the first place */
+       /* annoying since we just added this to a hash, could make this add the correct key to the hash
+        * in the first place */
        if (prop->identifier) {
                if (cont->prophash) {
                        BLI_ghash_remove(cont->prophash, (void*)prop->identifier, NULL, NULL);
@@ -2850,9 +2895,12 @@ void RNA_def_property_duplicate_pointers(StructOrFunctionRNA *cont_, PropertyRNA
                                eprop->item = earray;
 
                                for (a = 0; a<eprop->totitem; a++) {
-                                       if (eprop->item[a].identifier) eprop->item[a].identifier = BLI_strdup(eprop->item[a].identifier);
-                                       if (eprop->item[a].name) eprop->item[a].name = BLI_strdup(eprop->item[a].name);
-                                       if (eprop->item[a].description) eprop->item[a].description = BLI_strdup(eprop->item[a].description);
+                                       if (eprop->item[a].identifier)
+                                               eprop->item[a].identifier = BLI_strdup(eprop->item[a].identifier);
+                                       if (eprop->item[a].name)
+                                               eprop->item[a].name = BLI_strdup(eprop->item[a].name);
+                                       if (eprop->item[a].description)
+                                               eprop->item[a].description = BLI_strdup(eprop->item[a].description);
                                }
                        }
                        break;
@@ -2869,7 +2917,8 @@ void RNA_def_property_duplicate_pointers(StructOrFunctionRNA *cont_, PropertyRNA
                }
                case PROP_STRING: {
                        StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
-                       if (sprop->defaultvalue) sprop->defaultvalue = BLI_strdup(sprop->defaultvalue);
+                       if (sprop->defaultvalue)
+                               sprop->defaultvalue = BLI_strdup(sprop->defaultvalue);
                        break;
                }
                default:
@@ -2884,34 +2933,44 @@ void RNA_def_property_free_pointers(PropertyRNA *prop)
        if (prop->flag & PROP_FREE_POINTERS) {
                int a;
 
-               if (prop->identifier) MEM_freeN((void*)prop->identifier);
-               if (prop->name) MEM_freeN((void*)prop->name);
-               if (prop->description) MEM_freeN((void*)prop->description);
-               if (prop->py_data) MEM_freeN(prop->py_data);
+               if (prop->identifier)
+                       MEM_freeN((void*)prop->identifier);
+               if (prop->name)
+                       MEM_freeN((void*)prop->name);
+               if (prop->description)
+                       MEM_freeN((void*)prop->description);
+               if (prop->py_data)
+                       MEM_freeN(prop->py_data);
 
                switch (prop->type) {
                        case PROP_BOOLEAN: {
                                BoolPropertyRNA *bprop = (BoolPropertyRNA*)prop;
-                               if (bprop->defaultarray) MEM_freeN((void*)bprop->defaultarray);
+                               if (bprop->defaultarray)
+                                       MEM_freeN((void*)bprop->defaultarray);
                                break;
                        }
                        case PROP_INT: {
                                IntPropertyRNA *iprop = (IntPropertyRNA*)prop;
-                               if (iprop->defaultarray) MEM_freeN((void*)iprop->defaultarray);
+                               if (iprop->defaultarray)
+                                       MEM_freeN((void*)iprop->defaultarray);
                                break;
                        }
                        case PROP_FLOAT: {
                                FloatPropertyRNA *fprop = (FloatPropertyRNA*)prop;
-                               if (fprop->defaultarray) MEM_freeN((void*)fprop->defaultarray);
+                               if (fprop->defaultarray)
+                                       MEM_freeN((void*)fprop->defaultarray);
                                break;
                        }
                        case PROP_ENUM: {
                                EnumPropertyRNA *eprop = (EnumPropertyRNA*)prop;
 
                                for (a = 0; a<eprop->totitem; a++) {
-                                       if (eprop->item[a].identifier) MEM_freeN((void*)eprop->item[a].identifier);
-                                       if (eprop->item[a].name) MEM_freeN((void*)eprop->item[a].name);
-                                       if (eprop->item[a].description) MEM_freeN((void*)eprop->item[a].description);
+                                       if (eprop->item[a].identifier)
+                                               MEM_freeN((void*)eprop->item[a].identifier);
+                                       if (eprop->item[a].name)
+                                               MEM_freeN((void*)eprop->item[a].name);
+                                       if (eprop->item[a].description)
+                                               MEM_freeN((void*)eprop->item[a].description);
                                }
 
                                if (eprop->item) MEM_freeN((void*)eprop->item);
@@ -2919,7 +2978,8 @@ void RNA_def_property_free_pointers(PropertyRNA *prop)
                        }
                        case PROP_STRING: {
                                StringPropertyRNA *sprop = (StringPropertyRNA*)prop;
-                               if (sprop->defaultvalue) MEM_freeN((void*)sprop->defaultvalue);
+                               if (sprop->defaultvalue)
+                                       MEM_freeN((void*)sprop->defaultvalue);
                                break;
                        }
                        default:
index e9e7f58b6380f7512690b32ac10d6f37bdb844d0..1e47965be1575ad0f2e33223e752777df2ca43c5 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -6,11 +6,25 @@
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
  * Contributor(s): Miika Hämäläinen
  *
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/makesrna/intern/rna_dynamicpaint.c
+ *  \ingroup RNA
+ */
+
+
 #include <stdlib.h>
 #include <limits.h>
 
@@ -211,7 +225,8 @@ static int rna_DynamicPaint_is_output_exists(DynamicPaintSurface *surface, Objec
 }
 
 
-static EnumPropertyItem *rna_DynamicPaint_surface_type_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *free)
+static EnumPropertyItem *rna_DynamicPaint_surface_type_itemf(bContext *C, PointerRNA *ptr,
+                                                             PropertyRNA *UNUSED(prop), int *free)
 {
        DynamicPaintSurface *surface = (DynamicPaintSurface*)ptr->data;
 
@@ -271,7 +286,8 @@ static void rna_def_canvas_surfaces(BlenderRNA *brna, PropertyRNA *cprop)
 
        prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
-       RNA_def_property_int_funcs(prop, "rna_Surface_active_point_index_get", "rna_Surface_active_point_index_set", "rna_Surface_active_point_range");
+       RNA_def_property_int_funcs(prop, "rna_Surface_active_point_index_get", "rna_Surface_active_point_index_set",
+                                  "rna_Surface_active_point_range");
        RNA_def_property_ui_text(prop, "Active Point Cache Index", "");
 
        prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
@@ -500,7 +516,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_dissolve_log", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_DISSOLVE_LOG);
-       RNA_def_property_ui_text(prop, "Slow", "Use logarithmic dissolve (makes high values to fade faster than low values)");
+       RNA_def_property_ui_text(prop, "Slow",
+                                "Use logarithmic dissolve (makes high values to fade faster than low values)");
        
        prop = RNA_def_property(srna, "use_spread", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
@@ -613,7 +630,8 @@ static void rna_def_canvas_surface(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_range(prop, 0.00, 50.0);
        RNA_def_property_ui_range(prop, 0.00, 5.0, 1, 2);
-       RNA_def_property_ui_text(prop, "Max Displace", "Maximum level of depth intersection in object space (use 0.0 to disable)");
+       RNA_def_property_ui_text(prop, "Max Displace",
+                                "Maximum level of depth intersection in object space (use 0.0 to disable)");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
 
        prop = RNA_def_property(srna, "displace_factor", PROP_FLOAT, PROP_NONE);
@@ -694,7 +712,9 @@ static void rna_def_dynamic_paint_canvas_settings(BlenderRNA *brna)
         *      Surface Slots
         */
        prop = RNA_def_property(srna, "canvas_surfaces", PROP_COLLECTION, PROP_NONE);
-       RNA_def_property_collection_funcs(prop, "rna_DynamicPaint_surfaces_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
+       RNA_def_property_collection_funcs(prop, "rna_DynamicPaint_surfaces_begin", "rna_iterator_listbase_next",
+                                         "rna_iterator_listbase_end", "rna_iterator_listbase_get",
+                                         NULL, NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "DynamicPaintSurface");
        RNA_def_property_ui_text(prop, "Paint Surface List", "Paint surface list");
        rna_def_canvas_surfaces(brna, prop);
@@ -761,19 +781,22 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "mat");
-       RNA_def_property_ui_text(prop, "Material", "Material to use (if not defined, material linked to the mesh is used)");
+       RNA_def_property_ui_text(prop, "Material",
+                                "Material to use (if not defined, material linked to the mesh is used)");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
        
        prop = RNA_def_property(srna, "use_absolute_alpha", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_ABS_ALPHA);
-       RNA_def_property_ui_text(prop, "Absolute Alpha", "Only increase alpha value if paint alpha is higher than existing");
+       RNA_def_property_ui_text(prop, "Absolute Alpha",
+                                "Only increase alpha value if paint alpha is higher than existing");
        
        prop = RNA_def_property(srna, "paint_wetness", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "wetness");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_range(prop, 0.0, 1.0, 5, 2);
-       RNA_def_property_ui_text(prop, "Paint Wetness", "Paint wetness, visible in wetmap (some effects only affect wet paint)");
+       RNA_def_property_ui_text(prop, "Paint Wetness",
+                                "Paint wetness, visible in wetmap (some effects only affect wet paint)");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
        
        prop = RNA_def_property(srna, "use_paint_erase", PROP_BOOLEAN, PROP_NONE);
@@ -794,7 +817,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        prop = RNA_def_property(srna, "wave_clamp", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0.00, 50.0);
        RNA_def_property_ui_range(prop, 0.00, 5.0, 1, 2);
-       RNA_def_property_ui_text(prop, "Clamp Waves", "Maximum level of surface intersection used to influence waves (use 0.0 to disable)");
+       RNA_def_property_ui_text(prop, "Clamp Waves",
+                                "Maximum level of surface intersection used to influence waves (use 0.0 to disable)");
 
        prop = RNA_def_property(srna, "use_smudge", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_DO_SMUDGE);
@@ -809,7 +833,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "max_velocity");
        RNA_def_property_range(prop, 0.0001, 10.0);
        RNA_def_property_ui_range(prop, 0.1, 2.0, 5, 2);
-       RNA_def_property_ui_text(prop, "Max Velocity", "Velocity considered as maximum influence (Blender units per frame)");
+       RNA_def_property_ui_text(prop, "Max Velocity",
+                                "Velocity considered as maximum influence (Blender units per frame)");
 
        prop = RNA_def_property(srna, "use_velocity_alpha", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_VELOCITY_ALPHA);
@@ -818,7 +843,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
 
        prop = RNA_def_property(srna, "use_velocity_depth", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_VELOCITY_DEPTH);
-       RNA_def_property_ui_text(prop, "Multiply Depth", "Multiply brush intersection depth (displace, waves) by velocity ramp alpha");
+       RNA_def_property_ui_text(prop, "Multiply Depth",
+                                "Multiply brush intersection depth (displace, waves) by velocity ramp alpha");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
 
        prop = RNA_def_property(srna, "use_velocity_color", PROP_BOOLEAN, PROP_NONE);
@@ -840,7 +866,8 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "paint_distance");
        RNA_def_property_range(prop, 0.0, 500.0);
        RNA_def_property_ui_range(prop, 0.0, 500.0, 10, 3);
-       RNA_def_property_ui_text(prop, "Proximity Distance", "Maximum distance from brush to mesh surface to affect paint");
+       RNA_def_property_ui_text(prop, "Proximity Distance",
+                                "Maximum distance from brush to mesh surface to affect paint");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
        
        prop = RNA_def_property(srna, "use_proximity_ramp_alpha", PROP_BOOLEAN, PROP_NONE);
@@ -857,13 +884,16 @@ static void rna_def_dynamic_paint_brush_settings(BlenderRNA *brna)
        
        prop = RNA_def_property(srna, "use_proximity_project", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_DPAINT_PROX_PROJECT);
-       RNA_def_property_ui_text(prop, "Project", "Brush is projected to canvas from defined direction within brush proximity");
+       RNA_def_property_ui_text(prop, "Project",
+                                "Brush is projected to canvas from defined direction within brush proximity");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
 
        prop = RNA_def_property(srna, "ray_direction", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "ray_dir");
        RNA_def_property_enum_items(prop, prop_dynamicpaint_brush_ray_dir);
-       RNA_def_property_ui_text(prop, "Ray Direction", "Ray direction to use for projection (if brush object is located in that direction it's painted)");
+       RNA_def_property_ui_text(prop, "Ray Direction",
+                                "Ray direction to use for projection (if brush object is located in that direction "
+                                "it's painted)");
        RNA_def_property_update(prop, NC_OBJECT|ND_MODIFIER, "rna_DynamicPaint_redoModifier");
 
        prop = RNA_def_property(srna, "invert_proximity", PROP_BOOLEAN, PROP_NONE);
index 88878a5332f300bbdffa97a958d6bcb0e1afbb95..2108daf23be2d68e7a03332b9fc7f70463388af9 100644 (file)
@@ -372,7 +372,7 @@ static void rna_FCurve_group_set(PointerRNA *ptr, PointerRNA value)
                return;
        }
        
-       /* can only change group if we have info about the action the F-Curve is in 
+       /* can only change group if we have info about the action the F-Curve is in
         * (i.e. for drivers or random F-Curves, this cannot be done)
         */
        if (act == NULL) {
@@ -735,7 +735,7 @@ static void rna_def_fmodifier_envelope_ctrl(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Envelope Control Point", "Control point for envelope F-Modifier");
        RNA_def_struct_sdna(srna, "FCM_EnvelopeData");
        
-       /* min/max extents 
+       /* min/max extents
         *      - 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...
         */
@@ -802,7 +802,8 @@ static void rna_def_fmodifier_cycles(BlenderRNA *brna)
                {FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything"},
                {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is"},
                {FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", 0, "Repeat with Offset",
-                                               "Repeat keyframe range, but with offset based on gradient between start and end values"},
+                                               "Repeat keyframe range, but with offset based on gradient between "
+                                               "start and end values"},
                {FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored",
      &nbs