Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / armature / armature_edit.c
index fe07224..9fcf6ad 100644 (file)
@@ -29,7 +29,7 @@
  *  \ingroup edarmature
  */
 
-#include <assert.h> 
+#include <assert.h>
 
 #include "DNA_armature_types.h"
 #include "DNA_constraint_types.h"
@@ -94,20 +94,20 @@ void ED_armature_transform_bones(struct bArmature *arm, float mat[4][4], const b
        /* Do the rotations */
        for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                float tmat[3][3];
-               
+
                /* find the current bone's roll matrix */
                ED_armature_ebone_to_mat3(ebone, tmat);
-               
+
                /* transform the roll matrix */
                mul_m3_m3m3(tmat, mat3, tmat);
-               
+
                /* transform the bone */
                mul_m4_v3(mat, ebone->head);
                mul_m4_v3(mat, ebone->tail);
 
                /* apply the transformed roll back */
                mat3_to_vec_roll(tmat, NULL, &ebone->roll);
-               
+
                if (do_props) {
                        ebone->rad_head *= scale;
                        ebone->rad_tail *= scale;
@@ -181,13 +181,13 @@ void ED_armature_origin_set(Object *ob, float cursor[3], int centermode, int aro
                        mid_v3_v3v3(cent, min, max);
                }
        }
-       
+
        /* Do the adjustments */
        for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                sub_v3_v3(ebone->head, cent);
                sub_v3_v3(ebone->tail, cent);
        }
-       
+
        /* Turn the list into an armature */
        if (is_editmode == false) {
                ED_armature_from_edit(arm);
@@ -292,7 +292,7 @@ static const EnumPropertyItem prop_calc_roll_types[] = {
 };
 
 
-static int armature_calc_roll_exec(bContext *C, wmOperator *op) 
+static int armature_calc_roll_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
        eCalcRollTypes type = RNA_enum_get(op->ptr, "type");
@@ -319,12 +319,12 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                View3D *v3d = CTX_wm_view3d(C); /* can be NULL */
                float cursor_local[3];
                const View3DCursor *cursor = ED_view3d_cursor3d_get(scene, v3d);
-               
+
                invert_m4_m4(ob->imat, ob->obmat);
                copy_v3_v3(cursor_local, cursor->location);
                mul_m4_v3(ob->imat, cursor_local);
 
-               
+
                /* cursor */
                for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                        if (EBONE_VISIBLE(arm, ebone) && EBONE_EDITABLE(ebone)) {
@@ -393,7 +393,7 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                                BKE_report(op->reports, RPT_ERROR, "No region view3d available");
                                return OPERATOR_CANCELLED;
                        }
-                       
+
                        copy_v3_v3(vec, rv3d->viewinv[2]);
                        mul_m3_v3(imat, vec);
                }
@@ -404,7 +404,7 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                                BKE_report(op->reports, RPT_ERROR, "No active bone set");
                                return OPERATOR_CANCELLED;
                        }
-                       
+
                        ED_armature_ebone_to_mat3(ebone, mat);
                        copy_v3_v3(vec, mat[2]);
                }
@@ -415,9 +415,9 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                        mul_m3_v3(imat, vec);
                        normalize_v3(vec);
                }
-               
+
                if (axis_flip) negate_v3(vec);
-               
+
                for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                        if (EBONE_VISIBLE(arm, ebone) && EBONE_EDITABLE(ebone)) {
                                /* roll func is a callback which assumes that all is well */
@@ -425,7 +425,7 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                        }
                }
        }
-       
+
        if (arm->flag & ARM_MIRROR_EDIT) {
                for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                        if ((EBONE_VISIBLE(arm, ebone) && EBONE_EDITABLE(ebone)) == 0) {
@@ -436,10 +436,10 @@ static int armature_calc_roll_exec(bContext *C, wmOperator *op)
                        }
                }
        }
-       
+
        /* note, notifier might evolve */
        WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
-       
+
        return OPERATOR_FINISHED;
 }
 
@@ -449,12 +449,12 @@ void ARMATURE_OT_calculate_roll(wmOperatorType *ot)
        ot->name = "Recalculate Roll";
        ot->idname = "ARMATURE_OT_calculate_roll";
        ot->description = "Automatically fix alignment of select bones' axes";
-       
+
        /* api callbacks */
        ot->invoke = WM_menu_invoke;
        ot->exec = armature_calc_roll_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
@@ -521,10 +521,10 @@ void ARMATURE_OT_roll_clear(wmOperatorType *ot)
 /* temporary data-structure for merge/fill bones */
 typedef struct EditBonePoint {
        struct EditBonePoint *next, *prev;
-       
+
        EditBone *head_owner;       /* EditBone which uses this point as a 'head' point */
        EditBone *tail_owner;       /* EditBone which uses this point as a 'tail' point */
-       
+
        float vec[3];               /* the actual location of the point in local/EditMode space */
 } EditBonePoint;
 
@@ -533,11 +533,11 @@ static void chains_find_tips(ListBase *edbo, ListBase *list)
 {
        EditBone *curBone, *ebo;
        LinkData *ld;
-       
+
        /* note: this is potentially very slow ... there's got to be a better way */
        for (curBone = edbo->first; curBone; curBone = curBone->next) {
                short stop = 0;
-               
+
                /* is this bone contained within any existing chain? (skip if so) */
                for (ld = list->first; ld; ld = ld->next) {
                        for (ebo = ld->data; ebo; ebo = ebo->parent) {
@@ -546,12 +546,12 @@ static void chains_find_tips(ListBase *edbo, ListBase *list)
                                        break;
                                }
                        }
-                       
+
                        if (stop) break;
                }
                /* skip current bone if it is part of an existing chain */
                if (stop) continue;
-               
+
                /* is any existing chain part of the chain formed by this bone? */
                stop = 0;
                for (ebo = curBone->parent; ebo; ebo = ebo->parent) {
@@ -562,12 +562,12 @@ static void chains_find_tips(ListBase *edbo, ListBase *list)
                                        break;
                                }
                        }
-                       
+
                        if (stop) break;
                }
                /* current bone has already been added to a chain? */
                if (stop) continue;
-               
+
                /* add current bone to a new chain */
                ld = MEM_callocN(sizeof(LinkData), "BoneChain");
                ld->data = curBone;
@@ -582,14 +582,14 @@ static void fill_add_joint(EditBone *ebo, short eb_tail, ListBase *points)
        EditBonePoint *ebp;
        float vec[3];
        short found = 0;
-       
+
        if (eb_tail) {
                copy_v3_v3(vec, ebo->tail);
        }
        else {
                copy_v3_v3(vec, ebo->head);
        }
-       
+
        for (ebp = points->first; ebp; ebp = ebp->next) {
                if (equals_v3v3(ebp->vec, vec)) {
                        if (eb_tail) {
@@ -610,11 +610,11 @@ static void fill_add_joint(EditBone *ebo, short eb_tail, ListBase *points)
                        }
                }
        }
-       
+
        /* allocate a new point if no existing point was related */
        if (found == 0) {
                ebp = MEM_callocN(sizeof(EditBonePoint), "EditBonePoint");
-               
+
                if (eb_tail) {
                        copy_v3_v3(ebp->vec, ebo->tail);
                        ebp->tail_owner = ebo;
@@ -623,7 +623,7 @@ static void fill_add_joint(EditBone *ebo, short eb_tail, ListBase *points)
                        copy_v3_v3(ebp->vec, ebo->head);
                        ebp->head_owner = ebo;
                }
-               
+
                BLI_addtail(points, ebp);
        }
 }
@@ -666,7 +666,7 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                }
        }
        CTX_DATA_END;
-       
+
        /* the number of joints determines how we fill:
         *  1) between joint and cursor (joint=head, cursor=tail)
         *  2) between the two joints (order is dependent on active-bone/hierarchy)
@@ -699,14 +699,14 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
        if (count == 1) {
                EditBonePoint *ebp;
                float curs[3];
-               
+
                /* Get Points - selected joint */
                ebp = points.first;
-               
+
                /* Get points - cursor (tail) */
                invert_m4_m4(obedit->imat, obedit->obmat);
                mul_v3_m4v3(curs, obedit->imat, ED_view3d_cursor3d_get(scene, v3d)->location);
-               
+
                /* Create a bone */
                newbone = add_points_bone(obedit, ebp->vec, curs);
        }
@@ -714,11 +714,11 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                EditBonePoint *ebp_a, *ebp_b;
                float head[3], tail[3];
                short headtail = 0;
-               
+
                /* check that the points don't belong to the same bone */
                ebp_a = (EditBonePoint *)points.first;
                ebp_b = ebp_a->next;
-               
+
                if (((ebp_a->head_owner == ebp_b->tail_owner) && (ebp_a->head_owner != NULL)) ||
                    ((ebp_a->tail_owner == ebp_b->head_owner) && (ebp_a->tail_owner != NULL)))
                {
@@ -726,7 +726,7 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                        BLI_freelistN(&points);
                        return OPERATOR_CANCELLED;
                }
-               
+
                /* find which one should be the 'head' */
                if ((ebp_a->head_owner && ebp_b->head_owner) || (ebp_a->tail_owner && ebp_b->tail_owner)) {
                        /* use active, nice predictable */
@@ -759,7 +759,7 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                else if (ebp_b->head_owner) {
                        headtail = 2;
                }
-               
+
                /* assign head/tail combinations */
                if (headtail == 2) {
                        copy_v3_v3(head, ebp_a->vec);
@@ -769,11 +769,11 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                        copy_v3_v3(head, ebp_b->vec);
                        copy_v3_v3(tail, ebp_a->vec);
                }
-               
+
                /* add new bone and parent it to the appropriate end */
                if (headtail) {
                        newbone = add_points_bone(obedit, head, tail);
-                       
+
                        /* do parenting (will need to set connected flag too) */
                        if (headtail == 2) {
                                /* ebp tail or head - tail gets priority */
@@ -808,13 +808,13 @@ static int armature_fill_bones_exec(bContext *C, wmOperator *op)
                arm->act_edbone = newbone;
                newbone->flag |= BONE_TIPSEL;
        }
-       
+
        /* updates */
        WM_event_add_notifier(C, NC_OBJECT | ND_POSE, obedit);
-       
+
        /* free points */
        BLI_freelistN(&points);
-       
+
        return OPERATOR_FINISHED;
 }
 
@@ -824,18 +824,18 @@ void ARMATURE_OT_fill(wmOperatorType *ot)
        ot->name = "Fill Between Joints";
        ot->idname = "ARMATURE_OT_fill";
        ot->description = "Add bone between selected joint(s) and/or 3D-Cursor";
-       
+
        /* callbacks */
        ot->exec = armature_fill_bones_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
 /* --------------------- */
 
-/* this function merges between two bones, removes them and those in-between, 
+/* this function merges between two bones, removes them and those in-between,
  * and adjusts the parent relationships for those in-between
  */
 static void bones_merge(Object *obedit, EditBone *start, EditBone *end, EditBone *endchild, ListBase *chains)
@@ -844,7 +844,7 @@ static void bones_merge(Object *obedit, EditBone *start, EditBone *end, EditBone
        EditBone *ebo, *ebone, *newbone;
        LinkData *chain;
        float head[3], tail[3];
-       
+
        /* check if same bone */
        if (start == end) {
                if (G.debug & G_DEBUG) {
@@ -852,7 +852,7 @@ static void bones_merge(Object *obedit, EditBone *start, EditBone *end, EditBone
                        printf("\tstart = %s, end = %s\n", start->name, end->name);
                }
        }
-       
+
        /* step 1: add a new bone
         *      - head = head/tail of start (default head)
         *      - tail = head/tail of end (default tail)
@@ -876,17 +876,17 @@ static void bones_merge(Object *obedit, EditBone *start, EditBone *end, EditBone
        /* TODO, copy more things to the new bone */
        newbone->flag = start->flag & (BONE_HINGE | BONE_NO_DEFORM | BONE_NO_SCALE |
                                       BONE_NO_CYCLICOFFSET | BONE_NO_LOCAL_LOCATION | BONE_DONE);
-       
-       /* step 2a: reparent any side chains which may be parented to any bone in the chain of bones to merge 
+
+       /* step 2a: reparent any side chains which may be parented to any bone in the chain of bones to merge
         *      - potentially several tips for side chains leading to some tree exist...
         */
        for (chain = chains->first; chain; chain = chain->next) {
-               /* traverse down chain until we hit the bottom or if we run into the tip of the chain of bones we're 
-                * merging (need to stop in this case to avoid corrupting this chain too!) 
+               /* traverse down chain until we hit the bottom or if we run into the tip of the chain of bones we're
+                * merging (need to stop in this case to avoid corrupting this chain too!)
                 */
                for (ebone = chain->data; (ebone) && (ebone != end); ebone = ebone->parent) {
                        short found = 0;
-                       
+
                        /* check if this bone is parented to one in the merging chain
                         * ! WATCHIT: must only go check until end of checking chain
                         */
@@ -898,23 +898,23 @@ static void bones_merge(Object *obedit, EditBone *start, EditBone *end, EditBone
                                        break;
                                }
                        }
-                       
+
                        /* carry on to the next tip now  */
-                       if (found) 
+                       if (found)
                                break;
                }
        }
-       
+
        /* step 2b: parent child of end to newbone (child from this chain) */
        if (endchild)
                endchild->parent = newbone;
-       
+
        /* step 3: delete all bones between and including start and end */
        for (ebo = end; ebo; ebo = ebone) {
                ebone = (ebo == start) ? (NULL) : (ebo->parent);
                bone_free(arm, ebo);
        }
-       
+
        newbone->flag |= (BONE_ROOTSEL | BONE_TIPSEL | BONE_SELECTED);
        ED_armature_edit_sync_selection(arm->edbo);
 }
@@ -925,33 +925,33 @@ static int armature_merge_exec(bContext *C, wmOperator *op)
        Object *obedit = CTX_data_edit_object(C);
        bArmature *arm = (obedit) ? obedit->data : NULL;
        short type = RNA_enum_get(op->ptr, "type");
-       
+
        /* sanity checks */
        if (ELEM(NULL, obedit, arm))
                return OPERATOR_CANCELLED;
-       
+
        /* for now, there's only really one type of merging that's performed... */
        if (type == 1) {
                /* go down chains, merging bones */
                ListBase chains = {NULL, NULL};
                LinkData *chain, *nchain;
                EditBone *ebo;
-               
+
                armature_tag_select_mirrored(arm);
-               
+
                /* get chains (ends on chains) */
                chains_find_tips(arm->edbo, &chains);
                if (BLI_listbase_is_empty(&chains)) return OPERATOR_CANCELLED;
-               
+
                /* each 'chain' is the last bone in the chain (with no children) */
                for (chain = chains.first; chain; chain = nchain) {
                        EditBone *bstart = NULL, *bend = NULL;
                        EditBone *bchild = NULL, *child = NULL;
-                       
+
                        /* temporarily remove chain from list of chains */
                        nchain = chain->next;
                        BLI_remlink(&chains, chain);
-                       
+
                        /* only consider bones that are visible and selected */
                        for (ebo = chain->data; ebo; child = ebo, ebo = ebo->parent) {
                                /* check if visible + selected */
@@ -964,37 +964,37 @@ static int armature_merge_exec(bContext *C, wmOperator *op)
                                                bend = ebo;
                                                bchild = child;
                                        }
-                                       else 
+                                       else
                                                bstart = ebo;
                                }
                                else {
                                        /* chain is broken... merge any continous segments then clear */
                                        if (bstart && bend)
                                                bones_merge(obedit, bstart, bend, bchild, &chains);
-                                       
+
                                        bstart = NULL;
                                        bend = NULL;
                                        bchild = NULL;
                                }
                        }
-                       
+
                        /* merge from bstart to bend if something not merged */
                        if (bstart && bend)
                                bones_merge(obedit, bstart, bend, bchild, &chains);
-                       
+
                        /* put back link */
                        BLI_insertlinkbefore(&chains, nchain, chain);
                }
-               
+
                armature_tag_unselect(arm);
-               
+
                BLI_freelistN(&chains);
        }
-       
+
        /* updates */
        ED_armature_edit_sync_selection(arm->edbo);
        WM_event_add_notifier(C, NC_OBJECT | ND_POSE, obedit);
-       
+
        return OPERATOR_FINISHED;
 }
 
@@ -1009,15 +1009,15 @@ void ARMATURE_OT_merge(wmOperatorType *ot)
        ot->name = "Merge Bones";
        ot->idname = "ARMATURE_OT_merge";
        ot->description = "Merge continuous chains of selected bones";
-       
+
        /* callbacks */
        ot->invoke = WM_menu_invoke;
        ot->exec = armature_merge_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-       
+
        /* properties */
        ot->prop = RNA_def_enum(ot->srna, "type", merge_types, 0, "Type", "");
 }
@@ -1029,41 +1029,41 @@ void ARMATURE_OT_merge(wmOperatorType *ot)
  * easy to retrieve any hierarchical/chain relationships which are necessary for
  * this to be done easily.
  */
+
 /* helper to clear BONE_TRANSFORM flags */
 static void armature_clear_swap_done_flags(bArmature *arm)
 {
        EditBone *ebone;
-       
+
        for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                ebone->flag &= ~BONE_TRANSFORM;
        }
 }
 
-static int armature_switch_direction_exec(bContext *C, wmOperator *UNUSED(op)) 
+static int armature_switch_direction_exec(bContext *C, wmOperator *UNUSED(op))
 {
        Object *ob = CTX_data_edit_object(C);
        bArmature *arm = (bArmature *)ob->data;
        ListBase chains = {NULL, NULL};
        LinkData *chain;
-       
+
        /* get chains of bones (ends on chains) */
        chains_find_tips(arm->edbo, &chains);
        if (BLI_listbase_is_empty(&chains)) return OPERATOR_CANCELLED;
-       
+
        /* ensure that mirror bones will also be operated on */
        armature_tag_select_mirrored(arm);
-       
-       /* clear BONE_TRANSFORM flags 
+
+       /* clear BONE_TRANSFORM flags
         * - used to prevent duplicate/canceling operations from occurring [#34123]
         * - BONE_DONE cannot be used here as that's already used for mirroring
         */
        armature_clear_swap_done_flags(arm);
-       
+
        /* loop over chains, only considering selected and visible bones */
        for (chain = chains.first; chain; chain = chain->next) {
                EditBone *ebo, *child = NULL, *parent = NULL;
-               
+
                /* loop over bones in chain */
                for (ebo = chain->data; ebo; ebo = parent) {
                        /* parent is this bone's original parent
@@ -1071,14 +1071,14 @@ static int armature_switch_direction_exec(bContext *C, wmOperator *UNUSED(op))
                         *        but the value of ebo->parent may change here...
                         */
                        parent = ebo->parent;
-                       
+
                        /* skip bone if already handled... [#34123] */
                        if ((ebo->flag & BONE_TRANSFORM) == 0) {
                                /* only if selected and editable */
                                if (EBONE_VISIBLE(arm, ebo) && EBONE_EDITABLE(ebo)) {
                                        /* swap head and tail coordinates */
                                        swap_v3_v3(ebo->head, ebo->tail);
-                                       
+
                                        /* do parent swapping:
                                         *      - use 'child' as new parent
                                         *      - connected flag is only set if points are coincidental
@@ -1088,44 +1088,44 @@ static int armature_switch_direction_exec(bContext *C, wmOperator *UNUSED(op))
                                                ebo->flag |= BONE_CONNECTED;
                                        else
                                                ebo->flag &= ~BONE_CONNECTED;
-                                       
-                                       /* get next bones 
+
+                                       /* get next bones
                                         *      - child will become the new parent of next bone
                                         */
                                        child = ebo;
                                }
                                else {
-                                       /* not swapping this bone, however, if its 'parent' got swapped, unparent us from it 
+                                       /* not swapping this bone, however, if its 'parent' got swapped, unparent us from it
                                         * as it will be facing in opposite direction
                                         */
                                        if ((parent) && (EBONE_VISIBLE(arm, parent) && EBONE_EDITABLE(parent))) {
                                                ebo->parent = NULL;
                                                ebo->flag &= ~BONE_CONNECTED;
                                        }
-                                       
+
                                        /* get next bones
-                                        *      - child will become new parent of next bone (not swapping occurred, 
+                                        *      - child will become new parent of next bone (not swapping occurred,
                                         *        so set to NULL to prevent infinite-loop)
                                         */
                                        child = NULL;
                                }
-                               
+
                                /* tag as done (to prevent double-swaps) */
                                ebo->flag |= BONE_TRANSFORM;
                        }
                }
        }
-       
+
        /* free chains */
        BLI_freelistN(&chains);
-       
+
        /* clear temp flags */
        armature_clear_swap_done_flags(arm);
        armature_tag_unselect(arm);
-       
+
        /* note, notifier might evolve */
        WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
-       
+
        return OPERATOR_FINISHED;
 }
 
@@ -1135,11 +1135,11 @@ void ARMATURE_OT_switch_direction(wmOperatorType *ot)
        ot->name = "Switch Direction";
        ot->idname = "ARMATURE_OT_switch_direction";
        ot->description = "Change the direction that a chain of bones points in (head <-> tail swap)";
-       
+
        /* api callbacks */
        ot->exec = armature_switch_direction_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
@@ -1150,10 +1150,10 @@ void ARMATURE_OT_switch_direction(wmOperatorType *ot)
 static void fix_connected_bone(EditBone *ebone)
 {
        float diff[3];
-       
+
        if (!(ebone->parent) || !(ebone->flag & BONE_CONNECTED) || equals_v3v3(ebone->parent->tail, ebone->head))
                return;
-       
+
        /* if the parent has moved we translate child's head and tail accordingly */
        sub_v3_v3v3(diff, ebone->parent->tail, ebone->head);
        add_v3_v3(ebone->head, diff);
@@ -1164,14 +1164,14 @@ static void fix_connected_bone(EditBone *ebone)
 static void fix_editbone_connected_children(ListBase *edbo, EditBone *ebone)
 {
        EditBone *selbone;
-       
+
        for (selbone = edbo->first; selbone; selbone = selbone->next) {
                if ((selbone->parent) && (selbone->parent == ebone) && (selbone->flag & BONE_CONNECTED)) {
                        fix_connected_bone(selbone);
                        fix_editbone_connected_children(edbo, selbone);
                }
        }
-}                      
+}
 
 static void bone_align_to_bone(ListBase *edbo, EditBone *selbone, EditBone *actbone)
 {
@@ -1186,21 +1186,21 @@ static void bone_align_to_bone(ListBase *edbo, EditBone *selbone, EditBone *actb
        mul_v3_fl(actboneaxis, length);
        add_v3_v3v3(selbone->tail, selbone->head, actboneaxis);
        selbone->roll = actbone->roll;
-       
+
        /* if the bone being aligned has connected descendants they must be moved
         * according to their parent new position, otherwise they would be left
         * in an inconsistent state: connected but away from the parent*/
        fix_editbone_connected_children(edbo, selbone);
 }
 
-static int armature_align_bones_exec(bContext *C, wmOperator *op) 
+static int armature_align_bones_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
        bArmature *arm = (bArmature *)ob->data;
        EditBone *actbone = CTX_data_active_bone(C);
        EditBone *actmirb = NULL;
        int num_selected_bones;
-       
+
        /* there must be an active bone */
        if (actbone == NULL) {
                BKE_report(op->reports, RPT_ERROR, "Operation requires an active bone");
@@ -1208,28 +1208,28 @@ static int armature_align_bones_exec(bContext *C, wmOperator *op)
        }
        else if (arm->flag & ARM_MIRROR_EDIT) {
                /* For X-Axis Mirror Editing option, we may need a mirror copy of actbone
-                * - if there's a mirrored copy of selbone, try to find a mirrored copy of actbone 
+                * - if there's a mirrored copy of selbone, try to find a mirrored copy of actbone
                 *   (i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
                 *   This is useful for arm-chains, for example parenting lower arm to upper arm
                 * - if there's no mirrored copy of actbone (i.e. actbone = "parent.C" or "parent")
                 *   then just use actbone. Useful when doing upper arm to spine.
                 */
                actmirb = ED_armature_ebone_get_mirrored(arm->edbo, actbone);
-               if (actmirb == NULL) 
+               if (actmirb == NULL)
                        actmirb = actbone;
        }
-       
-       /* if there is only 1 selected bone, we assume that that is the active bone, 
+
+       /* if there is only 1 selected bone, we assume that that is the active bone,
         * since a user will need to have clicked on a bone (thus selecting it) to make it active
         */
        num_selected_bones = CTX_DATA_COUNT(C, selected_editable_bones);
        if (num_selected_bones <= 1) {
                /* When only the active bone is selected, and it has a parent,
-                * align it to the parent, as that is the only possible outcome. 
+                * align it to the parent, as that is the only possible outcome.
                 */
                if (actbone->parent) {
                        bone_align_to_bone(arm->edbo, actbone, actbone->parent);
-                       
+
                        if ((arm->flag & ARM_MIRROR_EDIT) && (actmirb->parent))
                                bone_align_to_bone(arm->edbo, actmirb, actmirb->parent);
 
@@ -1240,11 +1240,11 @@ static int armature_align_bones_exec(bContext *C, wmOperator *op)
                /* Align 'selected' bones to the active one
                 * - the context iterator contains both selected bones and their mirrored copies,
                 *   so we assume that unselected bones are mirrored copies of some selected bone
-                * - since the active one (and/or its mirror) will also be selected, we also need 
+                * - since the active one (and/or its mirror) will also be selected, we also need
                 *   to check that we are not trying to operate on them, since such an operation
                 *   would cause errors
                 */
-               
+
                /* align selected bones to the active one */
                CTX_DATA_BEGIN(C, EditBone *, ebone, selected_editable_bones)
                {
@@ -1262,7 +1262,7 @@ static int armature_align_bones_exec(bContext *C, wmOperator *op)
 
        /* note, notifier might evolve */
        WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
-       
+
        return OPERATOR_FINISHED;
 }
 
@@ -1272,11 +1272,11 @@ void ARMATURE_OT_align(wmOperatorType *ot)
        ot->name = "Align Bones";
        ot->idname = "ARMATURE_OT_align";
        ot->description = "Align selected bones to the active bone (or to their parent)";
-       
+
        /* api callbacks */
        ot->exec = armature_align_bones_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
@@ -1388,12 +1388,12 @@ void ARMATURE_OT_delete(wmOperatorType *ot)
        ot->name = "Delete Selected Bone(s)";
        ot->idname = "ARMATURE_OT_delete";
        ot->description = "Remove selected bones from the armature";
-       
+
        /* api callbacks */
        ot->invoke = WM_operator_confirm;
        ot->exec = armature_delete_selected_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
@@ -1597,11 +1597,11 @@ void ARMATURE_OT_hide(wmOperatorType *ot)
        ot->name = "Hide Selected Bones";
        ot->idname = "ARMATURE_OT_hide";
        ot->description = "Tag selected bones to not be visible in Edit Mode";
-       
+
        /* api callbacks */
        ot->exec = armature_hide_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
@@ -1615,7 +1615,7 @@ static int armature_reveal_exec(bContext *C, wmOperator *op)
        bArmature *arm = obedit->data;
        EditBone *ebone;
        const bool select = RNA_boolean_get(op->ptr, "select");
-       
+
        for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                if (arm->layer & ebone->layer) {
                        if (ebone->flag & BONE_HIDDEN_A) {
@@ -1640,11 +1640,11 @@ void ARMATURE_OT_reveal(wmOperatorType *ot)
        ot->name = "Reveal Bones";
        ot->idname = "ARMATURE_OT_reveal";
        ot->description = "Reveal all bones hidden in Edit Mode";
-       
+
        /* api callbacks */
        ot->exec = armature_reveal_exec;
        ot->poll = ED_operator_editarmature;
-       
+
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;