Cleanup: style
authorCampbell Barton <ideasman42@gmail.com>
Mon, 14 Jan 2019 21:47:04 +0000 (08:47 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 14 Jan 2019 23:36:52 +0000 (10:36 +1100)
12 files changed:
source/blender/blenkernel/intern/gpencil.c
source/blender/draw/engines/gpencil/gpencil_draw_utils.c
source/blender/draw/engines/gpencil/gpencil_engine.h
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/gpencil/gpencil_primitive.c
source/blender/editors/gpencil/gpencil_select.c
source/blender/editors/mesh/editmesh_bevel.c
source/blender/imbuf/IMB_imbuf_types.h
source/blender/modifiers/intern/MOD_bevel.c
source/blender/modifiers/intern/MOD_mirror.c
source/blender/windowmanager/intern/wm_window.c

index 54025a3cd20cd60831f02bfafc5072e740220edc..989649f65b88e3e527ab1ed939f09053872c382a 100644 (file)
@@ -1645,7 +1645,7 @@ void BKE_gpencil_stroke_2d_flat_ref(
                copy_v3_v3(v3, &pt3->x);
        }
 
-       sub_v3_v3v3(loc3,v3, &pt0->x);
+       sub_v3_v3v3(loc3, v3, &pt0->x);
 
        /* vector orthogonal to polygon plane */
        cross_v3_v3v3(normal, locx, loc3);
@@ -1686,7 +1686,7 @@ void BKE_gpencil_stroke_2d_flat_ref(
                else {
                        copy_v3_v3(v1, &pt->x);
                }
-               
+
                /* Get local space using first point as origin (ref stroke) */
                sub_v3_v3v3(loc, v1, &pt0->x);
 
index f925f9fb506e1c9571f2412b9d9e797d368e710f..f11082c2e0910a1ff85c94a8beea73608c5c8fdb 100644 (file)
@@ -1253,7 +1253,7 @@ void DRW_gpencil_populate_buffer_strokes(GPENCIL_e_data *e_data, void *vedata, T
        const bool is_show_gizmo = (((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) && ((v3d->gizmo_flag & V3D_GIZMO_HIDE_TOOL) == 0));
 
        if ((overlay) && (is_cppoint || is_speed_guide) && (is_show_gizmo) &&
-               ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0))
+           ((gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0))
        {
                DRWShadingGroup *shgrp = DRW_shgroup_create(
                        e_data->gpencil_edit_point_sh, psl->drawing_pass);
index c560321df9fd6bccc51dcba8ed5044bcb43b7c02..b9bb5db5c2e2facc7597f83a3ae1ec4c2ce2fe49 100644 (file)
@@ -366,7 +366,7 @@ typedef struct GpencilBatchCache {
 struct DRWShadingGroup *DRW_gpencil_shgroup_stroke_create(
         struct GPENCIL_e_data *e_data, struct GPENCIL_Data *vedata, struct DRWPass *pass, struct GPUShader *shader,
         struct Object *ob, struct bGPdata *gpd, struct bGPDstroke *gps,
-               struct MaterialGPencilStyle *gp_style, int id, bool onion);
+        struct MaterialGPencilStyle *gp_style, int id, bool onion);
 void DRW_gpencil_populate_datablock(
         struct GPENCIL_e_data *e_data, void *vedata,
         struct Object *ob, struct tGPencilObjectCache *cache_ob);
index 72f65ce8a3782451fe2635807eeff20db0ee356d..5c6f7de942678329cb55217a0f3ffcfbf9eceabc 100644 (file)
@@ -2545,14 +2545,21 @@ static int gp_stroke_caps_set_exec(bContext *C, wmOperator *op)
                        MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
 
                        /* skip strokes that are not selected or invalid for current view */
-                       if (((gps->flag & GP_STROKE_SELECT) == 0) || ED_gpencil_stroke_can_use(C, gps) == false)
+                       if (((gps->flag & GP_STROKE_SELECT) == 0) ||
+                           (ED_gpencil_stroke_can_use(C, gps) == false))
+                       {
                                continue;
+                       }
                        /* skip hidden or locked colors */
-                       if (!gp_style || (gp_style->flag & GP_STYLE_COLOR_HIDE) || (gp_style->flag & GP_STYLE_COLOR_LOCKED))
+                       if (!gp_style ||
+                           (gp_style->flag & GP_STYLE_COLOR_HIDE) ||
+                           (gp_style->flag & GP_STYLE_COLOR_LOCKED))
+                       {
                                continue;
+                       }
 
                        if ((type == GP_STROKE_CAPS_TOGGLE_BOTH) ||
-                               (type == GP_STROKE_CAPS_TOGGLE_START))
+                           (type == GP_STROKE_CAPS_TOGGLE_START))
                        {
                                ++gps->caps[0];
                                if (gps->caps[0] >= GP_STROKE_CAP_MAX) {
@@ -2560,7 +2567,7 @@ static int gp_stroke_caps_set_exec(bContext *C, wmOperator *op)
                                }
                        }
                        if ((type == GP_STROKE_CAPS_TOGGLE_BOTH) ||
-                               (type == GP_STROKE_CAPS_TOGGLE_END))
+                           (type == GP_STROKE_CAPS_TOGGLE_END))
                        {
                                ++gps->caps[1];
                                if (gps->caps[1] >= GP_STROKE_CAP_MAX) {
@@ -3851,7 +3858,7 @@ static void gpencil_cutter_dissolve(bGPDlayer *hit_layer, bGPDstroke *hit_stroke
 
        /* if all points selected delete or only 2 points and 1 selected */
        if (((totselect == 1) && (hit_stroke->totpoints == 2)) ||
-               (hit_stroke->totpoints == totselect))
+           (hit_stroke->totpoints == totselect))
        {
                BLI_remlink(&hit_layer->actframe->strokes, hit_stroke);
                BKE_gpencil_free_stroke(hit_stroke);
@@ -3950,7 +3957,7 @@ static int gpencil_cutter_lasso_select(
                }
                /* if mark all points inside lasso set to remove all stroke */
                if ((tot_inside == oldtot) ||
-                       ((tot_inside == 1) && (oldtot == 2)))
+                   ((tot_inside == 1) && (oldtot == 2)))
                {
                        for (i = 0; i < gps->totpoints; i++) {
                                pt = &gps->points[i];
index b138fa8a0d23e93eee6532d1d3dc8787afa55cf2..baf8ca4106296fba63f8254a1b25f4a01d731dde 100644 (file)
@@ -2628,10 +2628,12 @@ static void gp_rotate_v2_v2v2fl(float v[2], const float p[2], const float origin
 /* Helper to snap value to grid */
 static float gp_snap_to_grid_fl(float v, const float offset, const float spacing)
 {
-       if (spacing > 0.0f)
+       if (spacing > 0.0f) {
                return roundf(v / spacing) * spacing + fmodf(offset, spacing);
-       else 
+       }
+       else {
                return v;
+       }
 }
 
 static void UNUSED_FUNCTION(gp_snap_to_grid_v2)(float v[2], const float offset[2], const float spacing)
@@ -2666,7 +2668,8 @@ static void gp_origin_get(tGPsdata *p, float origin[2])
                copy_v3_v3(location, guide->location);
        }
        else if (guide->reference_point == GP_GUIDE_REF_OBJECT &&
-               guide->reference_object != NULL) {
+                guide->reference_object != NULL)
+       {
                copy_v3_v3(location, guide->reference_object->loc);
        }
        else {
@@ -2762,7 +2765,7 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                p->straight = 0;
 
                /* save initial mouse */
-               copy_v2_v2(p->mvali, p->mval); 
+               copy_v2_v2(p->mvali, p->mval);
 
                /* calculate once and store snapping distance and origin */
                RegionView3D * rv3d = p->ar->regiondata;
@@ -2791,9 +2794,10 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                 * it requires direction which needs at least two points
                 */
                if (!ELEM(p->paintmode, GP_PAINTMODE_ERASER, GP_PAINTMODE_SET_CP) &&
-                       guide->use_guide &&
-                       guide->use_snapping &&
-                       (guide->type == GP_GUIDE_GRID)) {
+                   guide->use_guide &&
+                   guide->use_snapping &&
+                   (guide->type == GP_GUIDE_GRID))
+               {
                        p->flags |= GP_PAINTFLAG_REQ_VECTOR;
                }
        }
@@ -2809,7 +2813,7 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                /* create fake events */
                float tmp[2];
                float pt[2];
-               copy_v2_v2(tmp, p->mval);                                               
+               copy_v2_v2(tmp, p->mval);
                sub_v2_v2v2(pt, p->mval, p->mvali);
                gpencil_draw_apply_event(C, op, event, CTX_data_depsgraph(C), pt[0], pt[1]);
                if (len_v2v2(p->mval, p->mvalo)) {
@@ -2820,8 +2824,9 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
        }
 
        /* check if stroke is straight or guided */
-       if ((p->paintmode != GP_PAINTMODE_ERASER)
-               && ((p->straight) || (guide->use_guide))) {
+       if ((p->paintmode != GP_PAINTMODE_ERASER) &&
+           ((p->straight) || (guide->use_guide)))
+       {
                /* guided stroke */
                if (guide->use_guide) {
                        switch (guide->type) {
@@ -2836,12 +2841,11 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                                        }
 
                                        dist_ensure_v2_v2fl(p->mval, p->origin, distance);
+                                       break;
                                }
-                               break;
                                case GP_GUIDE_RADIAL:
                                {
-                                       if (guide->use_snapping &&
-                                               (guide->angle_snap > 0.0f)) {
+                                       if (guide->use_snapping && (guide->angle_snap > 0.0f)) {
                                                float point[2];
                                                float xy[2];
                                                float angle;
@@ -2857,8 +2861,8 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                                        else {
                                                closest_to_line_v2(p->mval, p->mval, p->mvali, p->origin);
                                        }
+                                       break;
                                }
-                               break;
                                case GP_GUIDE_PARALLEL:
                                {
                                        float point[2];
@@ -2867,21 +2871,17 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                                        unit[0] += 1.0f; /* start from horizontal */
                                        gp_rotate_v2_v2v2fl(point, unit, p->mvali, guide->angle);
                                        closest_to_line_v2(p->mval, p->mval, p->mvali, point);
-                                       
-                                       if (guide->use_snapping &&
-                                               (guide->spacing > 0.0f)) {                                              
+
+                                       if (guide->use_snapping && (guide->spacing > 0.0f)) {
                                                gp_rotate_v2_v2v2fl(p->mval, p->mval, p->origin, -guide->angle);
                                                p->mval[1] = gp_snap_to_grid_fl(p->mval[1] - p->half_spacing, p->origin[1], p->guide_spacing);
                                                gp_rotate_v2_v2v2fl(p->mval, p->mval, p->origin, guide->angle);
                                        }
-
+                                       break;
                                }
-                               break;
                                case GP_GUIDE_GRID:
                                {
-                                       if (guide->use_snapping &&
-                                               (guide->spacing > 0.0f)) {
-       
+                                       if (guide->use_snapping && (guide->spacing > 0.0f)) {
                                                float point[2];
                                                float unit[2];
                                                float angle;
@@ -2904,11 +2904,11 @@ static void gpencil_draw_apply_event(bContext *C, wmOperator *op, const wmEvent
                                        else {
                                                p->mval[0] = p->mvali[0]; /* replace x */
                                        }
+                                       break;
                                }
-                               break;
                        }
                }
-               else if (p->straight == STROKE_HORIZONTAL) {    
+               else if (p->straight == STROKE_HORIZONTAL) {
                        p->mval[1] = p->mvali[1]; /* replace y */
                }
                else {
@@ -3020,9 +3020,9 @@ static void gpencil_guide_event_handling(bContext *C, wmOperator *op, const wmEv
        /* Enter or exit set center point mode */
        if ((event->type == OKEY) && (event->val == KM_RELEASE)) {
                if (p->paintmode == GP_PAINTMODE_DRAW && guide->reference_point != GP_GUIDE_REF_OBJECT) {
-                       add_notifier = true; 
+                       add_notifier = true;
                        p->paintmode = GP_PAINTMODE_SET_CP;
-                       ED_gpencil_toggle_brush_cursor(C, false, NULL);                 
+                       ED_gpencil_toggle_brush_cursor(C, false, NULL);
                }
        }
        /* Freehand mode, turn off speed guide */
@@ -3052,7 +3052,7 @@ static void gpencil_guide_event_handling(bContext *C, wmOperator *op, const wmEv
        /* Line guides */
        else if ((event->type == LKEY) && (event->val == KM_RELEASE)) {
                add_notifier = true;
-               guide->use_guide = true;                
+               guide->use_guide = true;
                if (event->ctrl) {
                        guide->angle = 0.0f;
                        guide->type = GP_GUIDE_PARALLEL;
@@ -3280,7 +3280,7 @@ static void gpencil_add_missing_events(bContext *C, wmOperator *op, const wmEven
        if (input_samples == 0) {
                return;
        }
-               
+
        RegionView3D *rv3d = p->ar->regiondata;
        float defaultpixsize = rv3d->pixsize * 1000.0f;
        int samples = (GP_MAX_INPUT_SAMPLES - input_samples + 1);
@@ -3383,10 +3383,10 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
                        case RIGHTMOUSE:
                        {
                                if (ELEM(event->val, KM_RELEASE)) {
-                                       drawmode = true;                                
+                                       drawmode = true;
                                }
+                               break;
                        }
-                       break;
                        /* set */
                        case LEFTMOUSE:
                        {
@@ -3394,8 +3394,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
                                        gp_origin_set(op, event->mval);
                                        drawmode = true;
                                }
+                               break;
                        }
-                       break;
                }
                if (drawmode) {
                        p->status = GP_STATUS_IDLING;
@@ -3698,7 +3698,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
        switch (estate) {
                case OPERATOR_FINISHED:
                        /* store stroke angle for parallel guide */
-                       if ((p->straight == 0) || (guide->use_guide && (guide->type == GP_GUIDE_CIRCULAR))){
+                       if ((p->straight == 0) || (guide->use_guide && (guide->type == GP_GUIDE_CIRCULAR))) {
                                float xy[2];
                                sub_v2_v2v2(xy, p->mval, p->mvali);
                                float angle = atan2f(xy[1], xy[0]);
@@ -3770,7 +3770,7 @@ void GPENCIL_OT_draw(wmOperatorType *ot)
 
        prop = RNA_def_boolean(ot->srna, "disable_fill", false, "No Fill Areas", "Disable fill to use stroke as fill boundary");
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
-       
+
        /* guides */
        prop = RNA_def_float(ot->srna, "guide_last_angle", 0.0f, -10000.0f, 10000.0f, "Angle", "Speed guide angle", -10000.0f, 10000.0f);
        prop = RNA_def_float_vector(ot->srna, "guide_origin", 3, NULL, -10000.0f, 10000.0f, "Origin", "Speed guide origin", -10000.0f, 10000.0f);
@@ -3792,7 +3792,7 @@ static int gpencil_guide_rotate(bContext *C, wmOperator *op)
        else {
                guide->angle = angle_compat_rad(angle, M_PI);
        }
-       
+
        return OPERATOR_FINISHED;
 }
 
index d108b4b910e41a37151070fbd6d1f5004d3936a3..8c92cf588cbfe8ff1489f58bd3f3ce8d4c9d3643 100644 (file)
@@ -689,22 +689,22 @@ static void gp_primitive_update_strokes(bContext *C, tGPDprimitive *tgpi)
 
        if (tgpi->tot_edges > 1) {
                switch (tgpi->type) {
-               case GP_STROKE_BOX:
-                       gp_primitive_rectangle(tgpi, points2D);
-                       break;
-               case GP_STROKE_LINE:
-                       gp_primitive_line(tgpi, points2D);
-                       break;
-               case GP_STROKE_CIRCLE:
-                       gp_primitive_circle(tgpi, points2D);
-                       break;
-               case GP_STROKE_ARC:
-                       gp_primitive_arc(tgpi, points2D);
-                       break;
-               case GP_STROKE_CURVE:
-                       gp_primitive_bezier(tgpi, points2D);
-               default:
-                       break;
+                       case GP_STROKE_BOX:
+                               gp_primitive_rectangle(tgpi, points2D);
+                               break;
+                       case GP_STROKE_LINE:
+                               gp_primitive_line(tgpi, points2D);
+                               break;
+                       case GP_STROKE_CIRCLE:
+                               gp_primitive_circle(tgpi, points2D);
+                               break;
+                       case GP_STROKE_ARC:
+                               gp_primitive_arc(tgpi, points2D);
+                               break;
+                       case GP_STROKE_CURVE:
+                               gp_primitive_bezier(tgpi, points2D);
+                       default:
+                               break;
                }
        }
 
@@ -1444,22 +1444,28 @@ static int gpencil_primitive_modal(bContext *C, wmOperator *op, const wmEvent *e
        if (tgpi->flag == IN_MOVE) {
 
                switch (event->type) {
-               case MOUSEMOVE:
-                       gpencil_primitive_move(tgpi, false);
-                       gpencil_primitive_update(C, op, tgpi);
-                       break;
-               case ESCKEY:
-               case LEFTMOUSE:
-                       zero_v2(tgpi->move);
-                       tgpi->flag = IN_CURVE_EDIT;
-                       break;
-               case RIGHTMOUSE:
-                       if (event->val == KM_RELEASE) {
-                               tgpi->flag = IN_CURVE_EDIT;
-                               gpencil_primitive_move(tgpi, true);
+                       case MOUSEMOVE:
+                       {
+                               gpencil_primitive_move(tgpi, false);
                                gpencil_primitive_update(C, op, tgpi);
+                               break;
+                       }
+                       case ESCKEY:
+                       case LEFTMOUSE:
+                       {
+                               zero_v2(tgpi->move);
+                               tgpi->flag = IN_CURVE_EDIT;
+                               break;
+                       }
+                       case RIGHTMOUSE:
+                       {
+                               if (event->val == KM_RELEASE) {
+                                       tgpi->flag = IN_CURVE_EDIT;
+                                       gpencil_primitive_move(tgpi, true);
+                                       gpencil_primitive_update(C, op, tgpi);
+                               }
+                               break;
                        }
-                       break;
                }
                copy_v2_v2(tgpi->mvalo, tgpi->mval);
                return OPERATOR_RUNNING_MODAL;
index 1deeab641f4ae07848494018a47e957ef77b8031..fb5efb01f944244d4a20f9be3ecaa6d5090ae1d5 100644 (file)
@@ -861,11 +861,11 @@ void GPENCIL_OT_select_less(wmOperatorType *ot)
  *       It would be great to de-duplicate the logic here sometime, but that can wait...
  */
 static bool gp_stroke_do_circle_sel(
-               bGPDlayer *gpl,
+        bGPDlayer *gpl,
         bGPDstroke *gps, GP_SpaceConversion *gsc,
         const int mx, const int my, const int radius,
         const bool select, rcti *rect, float diff_mat[4][4], const int selectmode,
-               const float scale)
+        const float scale)
 {
        bGPDspoint *pt1 = NULL;
        bGPDspoint *pt2 = NULL;
@@ -1088,8 +1088,8 @@ static int gpencil_generic_select_exec(
                (ts->gpencil_selectmode == GP_SELECTMODE_STROKE) &&
                ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0));
        const bool segmentmode = (
-                       (ts->gpencil_selectmode == GP_SELECTMODE_SEGMENT) &&
-                       ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0));
+               (ts->gpencil_selectmode == GP_SELECTMODE_SEGMENT) &&
+               ((gpd->flag & GP_DATA_STROKE_PAINTMODE) == 0));
        const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
        const float scale = ts->gp_sculpt.isect_threshold;
 
@@ -1143,9 +1143,7 @@ static int gpencil_generic_select_exec(
                                        changed = true;
 
                                        /* expand selection to segment */
-                                       if ((sel_op_result != -1) &&
-                                               (segmentmode))
-                                       {
+                                       if ((sel_op_result != -1) && (segmentmode)) {
                                                bool hit_select = (bool)(pt->flag & GP_SPOINT_SELECT);
                                                float r_hita[3], r_hitb[3];
                                                ED_gpencil_select_stroke_segment(
@@ -1491,8 +1489,8 @@ static int gpencil_select_exec(bContext *C, wmOperator *op)
                                float r_hita[3], r_hitb[3];
                                bool hit_select = (bool)(hit_point->flag & GP_SPOINT_SELECT);
                                ED_gpencil_select_stroke_segment(
-                                               hit_layer, hit_stroke, hit_point, hit_select,
-                                               false, scale, r_hita, r_hitb);
+                                       hit_layer, hit_stroke, hit_point, hit_select,
+                                       false, scale, r_hita, r_hitb);
                        }
                }
                else {
index 0d99c433c1101a63091387b86b88c73fcf063b48..32ad8a7c5218a77b9150cc24d64d856e04960dbb 100644 (file)
@@ -255,12 +255,12 @@ static bool edbm_bevel_calc(wmOperator *op)
 
                EDBM_op_init(
                        em, &bmop, op,
-                       "bevel geom=%hev offset=%f segments=%i vertex_only=%b offset_type=%i profile=%f clamp_overlap=%b "
-                       "material=%i loop_slide=%b mark_seam=%b mark_sharp=%b harden_normals=%b face_strength_mode=%i "
-                               "smoothresh=%f",
+                       "bevel geom=%hev offset=%f segments=%i vertex_only=%b offset_type=%i profile=%f "
+                       "clamp_overlap=%b material=%i loop_slide=%b mark_seam=%b mark_sharp=%b "
+                       "harden_normals=%b face_strength_mode=%i smoothresh=%f",
                        BM_ELEM_SELECT, offset, segments, vertex_only, offset_type, profile,
-                               clamp_overlap, material, loop_slide, mark_seam, mark_sharp, harden_normals, face_strength_mode,
-                                       me->smoothresh);
+                       clamp_overlap, material, loop_slide, mark_seam, mark_sharp, harden_normals, face_strength_mode,
+                       me->smoothresh);
 
                BMO_op_exec(em->bm, &bmop);
 
index 309c41646ede715337a38c962226b13f5d1347ed..c71bbc3ecd538fc7299df7615a2451074a9e8115 100644 (file)
@@ -295,9 +295,9 @@ enum {
        /** indicates whether image on disk have premul alpha */
        IB_alphamode_premul = 1 << 12,
        /** if this flag is set, alpha mode would be guessed from file */
-       IB_alphamode_detect = 1 << 13 ,
+       IB_alphamode_detect = 1 << 13,
        /** ignore alpha on load and substitute it with 1.0f */
-       IB_ignore_alpha     = 1 << 14 ,
+       IB_ignore_alpha     = 1 << 14,
        IB_thumbnail        = 1 << 15,
        IB_multiview        = 1 << 16,
 };
index 6156ae281090c1c3c74be1f0f616d24c900e2e06..050154921587ee8939bbc589f9fc59e7b8c06fee 100644 (file)
@@ -76,7 +76,6 @@ static void initData(ModifierData *md)
 
 static void copyData(const ModifierData *md_src, ModifierData *md_dst, const int flag)
 {
-       BevelModifierData *bmd_src = (BevelModifierData *)md_src;
        BevelModifierData *bmd_dst = (BevelModifierData *)md_dst;
 
        modifier_copyData_generic(md_src, md_dst, flag);
index 297169a17f8422c4329584cbd0f5d26eba2cdadf..58f8b78fa9f02b17bb584f034bbb21524a9ccd63 100644 (file)
@@ -193,7 +193,7 @@ static Mesh *doMirrorOnAxis(
                        copy_v3_v3(plane_no, itmp[axis]);
                }
        }
-       else if(do_bisect) {
+       else if (do_bisect) {
                copy_v3_v3(plane_co, mtx[3]);
                /* Need to negate here, since that axis is inverted (for mirror transform). */
                negate_v3_v3(plane_no, mtx[axis]);
index 8b76b2a5d32ca185a61953a43cf9cb4d6fca1309..0b1a3bcede85aaf22e4e13309eb3d8864a2bdd65 100644 (file)
@@ -1984,7 +1984,7 @@ void WM_init_native_pixels(bool do_it)
 void WM_init_tablet_api(void)
 {
        if (g_system) {
-               switch(U.tablet_api) {
+               switch (U.tablet_api) {
                        case USER_TABLET_NATIVE:
                                GHOST_SetTabletAPI(g_system, GHOST_kTabletNative);
                                break;