Commit: 292a2802ad376f4a3a2cc7bed763d0f5856dd98c
Author: Campbell Barton
Date:   Mon Apr 16 17:54:33 2018 +0200
Branches: blender2.8
https://developer.blender.org/rB292a2802ad376f4a3a2cc7bed763d0f5856dd98c

Cleanup: indentation

Indent lines for multi object editing, no functional changes.

Also strip trailing space from indented regions.

===================================================================

M       source/blender/editors/armature/armature_edit.c
M       source/blender/editors/mesh/editmesh_select.c
M       source/blender/editors/mesh/editmesh_tools.c
M       source/blender/editors/screen/screen_context.c
M       source/blender/editors/space_view3d/view3d_select.c
M       source/blender/editors/transform/transform.c
M       source/blender/editors/transform/transform_constraints.c
M       source/blender/editors/transform/transform_conversions.c
M       source/blender/editors/transform/transform_generics.c
M       source/blender/editors/transform/transform_snap.c
M       source/blender/editors/uvedit/uvedit_ops.c
M       source/blender/editors/uvedit/uvedit_unwrap_ops.c

===================================================================

diff --git a/source/blender/editors/armature/armature_edit.c 
b/source/blender/editors/armature/armature_edit.c
index 2335e29aca8..6a94443660b 100644
--- a/source/blender/editors/armature/armature_edit.c
+++ b/source/blender/editors/armature/armature_edit.c
@@ -1345,33 +1345,33 @@ static int armature_delete_selected_exec(bContext *C, 
wmOperator *UNUSED(op))
        uint objects_len = 0;
        Object **objects = 
BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, 
&objects_len);
        for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
-       Object *obedit = objects[ob_index];
-       bArmature *arm = obedit->data;
-       bool changed = false;
+               Object *obedit = objects[ob_index];
+               bArmature *arm = obedit->data;
+               bool changed = false;
 
-       armature_select_mirrored(arm);
+               armature_select_mirrored(arm);
 
-       BKE_pose_channels_remove(obedit, armature_delete_ebone_cb, arm);
+               BKE_pose_channels_remove(obedit, armature_delete_ebone_cb, arm);
 
-       for (curBone = arm->edbo->first; curBone; curBone = ebone_next) {
-               ebone_next = curBone->next;
-               if (arm->layer & curBone->layer) {
-                       if (curBone->flag & BONE_SELECTED) {
-                               if (curBone == arm->act_edbone) arm->act_edbone 
= NULL;
-                               ED_armature_ebone_remove(arm, curBone);
-                               changed = true;
+               for (curBone = arm->edbo->first; curBone; curBone = ebone_next) 
{
+                       ebone_next = curBone->next;
+                       if (arm->layer & curBone->layer) {
+                               if (curBone->flag & BONE_SELECTED) {
+                                       if (curBone == arm->act_edbone) 
arm->act_edbone = NULL;
+                                       ED_armature_ebone_remove(arm, curBone);
+                                       changed = true;
+                               }
                        }
                }
-       }
 
-       if (changed) {
-               changed_multi = true;
+               if (changed) {
+                       changed_multi = true;
 
-               ED_armature_edit_sync_selection(arm->edbo);
-               BKE_pose_tag_recalc(CTX_data_main(C), obedit->pose);
+                       ED_armature_edit_sync_selection(arm->edbo);
+                       BKE_pose_tag_recalc(CTX_data_main(C), obedit->pose);
 
-               WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
-       }
+                       WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, 
obedit);
+               }
        }
 
        if (!changed_multi) {
diff --git a/source/blender/editors/mesh/editmesh_select.c 
b/source/blender/editors/mesh/editmesh_select.c
index 20cebc9d4b9..33277cdcd9b 100644
--- a/source/blender/editors/mesh/editmesh_select.c
+++ b/source/blender/editors/mesh/editmesh_select.c
@@ -2712,171 +2712,171 @@ static int edbm_select_linked_exec(bContext *C, 
wmOperator *op)
        Object **objects = 
BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, 
&objects_len);
 
        for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
-       Object *obedit = objects[ob_index];
+               Object *obedit = objects[ob_index];
 
-       BMEditMesh *em = BKE_editmesh_from_object(obedit);
-       BMesh *bm = em->bm;
-       BMIter iter;
-       BMWalker walker;
+               BMEditMesh *em = BKE_editmesh_from_object(obedit);
+               BMesh *bm = em->bm;
+               BMIter iter;
+               BMWalker walker;
 
-       int delimit = delimit_init;
+               int delimit = delimit_init;
 
-       select_linked_delimit_validate(bm, &delimit);
+               select_linked_delimit_validate(bm, &delimit);
 
-       if (delimit) {
-               select_linked_delimit_begin(em->bm, delimit);
-       }
+               if (delimit) {
+                       select_linked_delimit_begin(em->bm, delimit);
+               }
 
-       if (em->selectmode & SCE_SELECT_VERTEX) {
-               BMVert *v;
+               if (em->selectmode & SCE_SELECT_VERTEX) {
+                       BMVert *v;
 
-               BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-                       BM_elem_flag_set(v, BM_ELEM_TAG, BM_elem_flag_test(v, 
BM_ELEM_SELECT));
-               }
+                       BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
+                               BM_elem_flag_set(v, BM_ELEM_TAG, 
BM_elem_flag_test(v, BM_ELEM_SELECT));
+                       }
 
-               /* exclude all delimited verts */
-               if (delimit) {
-                       BMEdge *e;
-                       BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
-                               if (!BMO_edge_flag_test(bm, e, BMO_ELE_TAG)) {
-                                       BM_elem_flag_disable(e->v1, 
BM_ELEM_TAG);
-                                       BM_elem_flag_disable(e->v2, 
BM_ELEM_TAG);
+                       /* exclude all delimited verts */
+                       if (delimit) {
+                               BMEdge *e;
+                               BM_ITER_MESH (e, &iter, em->bm, 
BM_EDGES_OF_MESH) {
+                                       if (!BMO_edge_flag_test(bm, e, 
BMO_ELE_TAG)) {
+                                               BM_elem_flag_disable(e->v1, 
BM_ELEM_TAG);
+                                               BM_elem_flag_disable(e->v2, 
BM_ELEM_TAG);
+                                       }
                                }
                        }
-               }
-
-               BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : 
BMW_VERT_SHELL,
-                        BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, 
BMW_MASK_NOP,
-                        BMW_FLAG_TEST_HIDDEN,
-                        BMW_NIL_LAY);
 
-               if (delimit) {
-                       BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-                               if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
-                                       BMElem *ele_walk;
-                                       BMW_ITER (ele_walk, &walker, v) {
-                                               if (ele_walk->head.htype == 
BM_LOOP) {
-                                                       BMVert *v_step = 
((BMLoop *)ele_walk)->v;
-                                                       
BM_vert_select_set(em->bm, v_step, true);
-                                                       
BM_elem_flag_disable(v_step, BM_ELEM_TAG);
-                                               }
-                                               else {
-                                                       BMEdge *e_step = 
(BMEdge *)ele_walk;
-                                                       
BLI_assert(ele_walk->head.htype == BM_EDGE);
-                                                       
BM_edge_select_set(em->bm, e_step, true);
-                                                       
BM_elem_flag_disable(e_step->v1, BM_ELEM_TAG);
-                                                       
BM_elem_flag_disable(e_step->v2, BM_ELEM_TAG);
+                       BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE 
: BMW_VERT_SHELL,
+                                BMW_MASK_NOP, delimit ? BMO_ELE_TAG : 
BMW_MASK_NOP, BMW_MASK_NOP,
+                                BMW_FLAG_TEST_HIDDEN,
+                                BMW_NIL_LAY);
+
+                       if (delimit) {
+                               BM_ITER_MESH (v, &iter, em->bm, 
BM_VERTS_OF_MESH) {
+                                       if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
+                                               BMElem *ele_walk;
+                                               BMW_ITER (ele_walk, &walker, v) 
{
+                                                       if 
(ele_walk->head.htype == BM_LOOP) {
+                                                               BMVert *v_step 
= ((BMLoop *)ele_walk)->v;
+                                                               
BM_vert_select_set(em->bm, v_step, true);
+                                                               
BM_elem_flag_disable(v_step, BM_ELEM_TAG);
+                                                       }
+                                                       else {
+                                                               BMEdge *e_step 
= (BMEdge *)ele_walk;
+                                                               
BLI_assert(ele_walk->head.htype == BM_EDGE);
+                                                               
BM_edge_select_set(em->bm, e_step, true);
+                                                               
BM_elem_flag_disable(e_step->v1, BM_ELEM_TAG);
+                                                               
BM_elem_flag_disable(e_step->v2, BM_ELEM_TAG);
+                                                       }
                                                }
                                        }
                                }
                        }
-               }
-               else {
-                       BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
-                               if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
-                                       BMEdge *e_walk;
-                                       BMW_ITER (e_walk, &walker, v) {
-                                               BM_edge_select_set(em->bm, 
e_walk, true);
-                                               BM_elem_flag_disable(e_walk, 
BM_ELEM_TAG);
+                       else {
+                               BM_ITER_MESH (v, &iter, em->bm, 
BM_VERTS_OF_MESH) {
+                                       if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
+                                               BMEdge *e_walk;
+                                               BMW_ITER (e_walk, &walker, v) {
+                                                       
BM_edge_select_set(em->bm, e_walk, true);
+                                                       
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
+                                               }
                                        }
                                }
                        }
-               }
 
-               BMW_end(&walker);
+                       BMW_end(&walker);
 
-               EDBM_selectmode_flush(em);
-       }
-       else if (em->selectmode & SCE_SELECT_EDGE) {
-               BMEdge *e;
+                       EDBM_selectmode_flush(em);
+               }
+               else if (em->selectmode & SCE_SELECT_EDGE) {
+                       BMEdge *e;
 
-               if (delimit) {
-                       BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
-                               BM_elem_flag_set(
-                                       e, BM_ELEM_TAG,
-                                       (BM_elem_flag_test(e, BM_ELEM_SELECT) 
&& BMO_edge_flag_test(bm, e, BMO_ELE_TAG)));
+                       if (delimit) {
+                               BM_ITER_MESH (e, &iter, em->bm, 
BM_EDGES_OF_MESH) {
+                                       BM_elem_flag_set(
+                                               e, BM_ELEM_TAG,
+                                               (BM_elem_flag_test(e, 
BM_ELEM_SELECT) && BMO_edge_flag_test(bm, e, BMO_ELE_TAG)));
+                               }
                        }
-               }
-               else {
-                       BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
-                               BM_elem_flag_set(e, BM_ELEM_TAG, 
BM_elem_flag_test(e, BM_ELEM_SELECT));
+                       else {
+                               BM_ITER_MESH (e, &iter, em->bm, 
BM_EDGES_OF_MESH) {
+                                       BM_elem_flag_set(e, BM_ELEM_TAG, 
BM_elem_flag_test(e, BM_ELEM_SELECT));
+                               }
                        }
-               }
-
-               BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE : 
BMW_VERT_SHELL,
-                        BMW_MASK_NOP, delimit ? BMO_ELE_TAG : BMW_MASK_NOP, 
BMW_MASK_NOP,
-                        BMW_FLAG_TEST_HIDDEN,
-                        BMW_NIL_LAY);
 
-               if (delimit) {
-                       BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
-                               if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
-                                       BMElem *ele_walk;
-                                       BMW_ITER (ele_walk, &walker, e) {
-                                               if (ele_walk->head.htype == 
BM_LOOP) {
-                                                       BMLoop *l_step = 
(BMLoop *)ele_walk;
-                                                       
BM_edge_select_set(em->bm, l_step->e, true);
-                                                       
BM_edge_select_set(em->bm, l_step->prev->e, true);
-                                                       
BM_elem_flag_disable(l_step->e, BM_ELEM_TAG);
-                                               }
-                                               else {
-                                                       BMEdge *e_step = 
(BMEdge *)ele_walk;
-                                                       
BLI_assert(ele_walk->head.htype == BM_EDGE);
-                                                       
BM_edge_select_set(em->bm, e_step, true);
-                                                       
BM_elem_flag_disable(e_step, BM_ELEM_TAG);
+                       BMW_init(&walker, em->bm, delimit ? BMW_LOOP_SHELL_WIRE 
: BMW_VERT_SHELL,
+                                BMW_MASK_NOP, delimit ? BMO_ELE_TAG : 
BMW_MASK_NOP, BMW_MASK_NOP,
+                                BMW_FLAG_TEST_HIDDEN,
+                                BMW_NIL_LAY);
+
+                       if (delimit) {
+                               BM_ITER_MESH (e, &iter, em->bm, 
BM_EDGES_OF_MESH) {
+                                       if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
+                                               BMElem *ele_walk;
+                                               BMW_ITER (ele_walk, &walker, e) 
{
+                                                       if 
(ele_walk->head.htype == BM_LOOP) {
+                                                               BMLoop *l_step 
= (BMLoop *)ele_walk;
+                                                               
BM_edge_select_set(em->bm, l_step->e, true);
+                                                               
BM_edge_select_set(em->bm, l_step->prev->e, true);
+                                                               
BM_elem_flag_disable(l_step->e, BM_ELEM_TAG);
+                                                       }
+                                                       else {
+                                                               BMEdge *e_step 
= (BMEdge *)ele_walk;
+                                                               
BLI_assert(ele_walk->head.htype == BM_EDGE);
+                                                               
BM_edge_select_set(em->bm, e_step, true);
+                                                               
BM_elem_flag_disable(e_step, BM_ELEM_TAG);
+                                                       }
                                                }
                                        }
                                }
                        }
-               }
-               else {
-                       BM_ITER_MESH (e, &iter, em->bm, BM_EDGES_OF_MESH) {
-                               if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
-                                       BMEdge *e_walk;
-                                       BMW_ITER (e_walk, &walker, e) {
-                                               BM_edge_select_set(em->bm, 
e_walk, true);
-                                               BM_elem_flag_disable(e_walk, 
BM_ELEM_TAG);
+                       else {
+                               BM_ITER_MESH (e, &iter, em->bm, 
BM_EDGES_OF_MESH) {
+                                       if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
+                                               BMEdge *e_walk;
+                                               BMW_ITER (e_walk, &walker, e) {
+                                                       
BM_edge_select_set(em->bm, e_walk, true);
+                                                       
BM_elem_flag_disable(e_walk, BM_ELEM_TAG);
+                                               }
                                        }
                                }
                        }
-               }
 
-               BMW_end(&walker);
+                       BMW_end(&walker);
 
-               EDBM_selectmode_flush(em);
-       }
-       else {
-               BMFace *f;
-
-               BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
-                       BM_elem_flag_set(f, BM_ELEM_TAG, BM_elem_flag_test(f, 
BM_ELEM_SELECT));
+       

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
Bf-blender-cvs@blender.org
https://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to