Whitespace tweaks and Bugfixes
[blender.git] / source / blender / editors / gpencil / gpencil_edit.c
index 1defcf65ae80358a4a6b802bf93282784919b601..835f5dfa87aa74d130ef854b4f21a489c627e40a 100644 (file)
@@ -471,7 +471,7 @@ static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoin
                                mvalf[1] = (float)pt->y / 100.0f * ar->winy;
                        }
                }
-
+               
                /* convert screen coordinate to 3d coordinates 
                 *      - method taken from editview.c - mouse_cursor() 
                 */
@@ -504,19 +504,22 @@ typedef struct tGpTimingData {
        double inittime;
 } tGpTimingData;
 
+/* init point buffers for timing data */
 static void _gp_timing_data_set_nbr(tGpTimingData *gtd, int nbr)
 {
        float *tmp;
 
        BLI_assert(nbr > gtd->num_points);
-
+       
+       /* distances */
        tmp = gtd->dists;
        gtd->dists = MEM_callocN(sizeof(float) * nbr, __func__);
        if (tmp) {
                memcpy(gtd->dists, tmp, sizeof(float) * gtd->num_points);
                MEM_freeN(tmp);
        }
-
+       
+       /* times */
        tmp = gtd->times;
        gtd->times = MEM_callocN(sizeof(float) * nbr, __func__);
        if (tmp) {
@@ -527,6 +530,7 @@ static void _gp_timing_data_set_nbr(tGpTimingData *gtd, int nbr)
        gtd->num_points = nbr;
 }
 
+/* add stroke point to timing buffers */
 static void gp_timing_data_add_point(tGpTimingData *gtd, double stroke_inittime, float time, float delta_dist)
 {
        if (time < 0.0f) {
@@ -534,13 +538,16 @@ static void gp_timing_data_add_point(tGpTimingData *gtd, double stroke_inittime,
                gtd->tot_time = -(gtd->times[gtd->cur_point] = -(((float)(stroke_inittime - gtd->inittime)) + time));
                gtd->gap_tot_time += gtd->times[gtd->cur_point] - gtd->times[gtd->cur_point - 1];
        }
-       else
+       else {
                gtd->tot_time = (gtd->times[gtd->cur_point] = (((float)(stroke_inittime - gtd->inittime)) + time));
-       gtd->dists[gtd->cur_point] = (gtd->tot_dist += delta_dist);
+       }
+       
+       gtd->tot_dist += delta_dist;
+       gtd->dists[gtd->cur_point] = gtd->tot_dist;
        gtd->cur_point++;
 }
 
-/* In frames! Binary search for FCurve keys have a threshold of 0.01, so we cant set
+/* In frames! Binary search for FCurve keys have a threshold of 0.01, so we can't set
  * arbitrarily close points - this is esp. important with NoGaps mode!
  */
 #define MIN_TIME_DELTA 0.02f
@@ -550,7 +557,7 @@ static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, int idx, int nbr_gaps,
                                      float tot_gaps_time, float delta_time, float *next_delta_time)
 {
        int j;
-
+       
        for (j = idx + 1; j < gtd->num_points; j++) {
                if (gtd->times[j] < 0) {
                        gtd->times[j] = -gtd->times[j];
@@ -572,10 +579,12 @@ static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, int idx, int nbr_gaps,
                                                /* This code ensures that if the first gaps have been shorter than average gap_duration,
                                                 * next gaps will tend to be longer (i.e. try to recover the lateness), and vice-versa!
                                                 */
-                                               delta = delta_time - (gtd->gap_duration * *nbr_done_gaps);
+                                               delta = delta_time - (gtd->gap_duration * (*nbr_done_gaps));
+                                               
                                                /* Clamp min between [-gap_randomness, 0.0], with lower delta giving higher min */
                                                min = -gtd->gap_randomness - delta;
                                                CLAMP(min, -gtd->gap_randomness, 0.0f);
+                                               
                                                /* Clamp max between [0.0, gap_randomness], with lower delta giving higher max */
                                                max = gtd->gap_randomness - delta;
                                                CLAMP(max, 0.0f, gtd->gap_randomness);
@@ -655,11 +664,11 @@ static void gp_stroke_path_animation_add_keyframes(ReportList *reports, PointerR
                        /* This one should *never* be negative! */
                        end_stroke_time = time_start + ((gtd->times[end_stroke_idx] + delta_time) / gtd->tot_time * time_range);
                }
-
+               
                /* Simple proportional stuff... */
                cu->ctime = gtd->dists[i] / gtd->tot_dist * cu->pathlen;
                cfra = time_start + ((gtd->times[i] + delta_time) / gtd->tot_time * time_range);
-
+               
                /* And now, the checks about timing... */
                if (i == start_stroke_idx) {
                        /* If first point of a stroke, be sure it's enough ahead of last valid keyframe, and
@@ -709,45 +718,44 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
        FCurve *fcu;
        PointerRNA ptr;
        PropertyRNA *prop = NULL;
-
        int nbr_gaps = 0, i;
-
+       
        if (gtd->mode == GP_STROKECONVERT_TIMING_NONE)
                return;
-
+       
        /* gap_duration and gap_randomness are in frames, but we need seconds!!! */
        gtd->gap_duration = FRA2TIME(gtd->gap_duration);
        gtd->gap_randomness = FRA2TIME(gtd->gap_randomness);
-
+       
        /* Enable path! */
        cu->flag |= CU_PATH;
        cu->pathlen = gtd->frame_range;
-
-       /* Get or create default action to add F-Curve+keyframe to */
-       act = verify_adt_action((ID*)cu, TRUE);
-       /* Create RNA stuff */
-       RNA_id_pointer_create((ID*)cu, &ptr);
+       
+       /* Get RNA pointer to read/write path time values */
+       RNA_id_pointer_create((ID *)cu, &ptr);
        prop = RNA_struct_find_property(&ptr, "eval_time");
-       /* Get or create fcurve */
+       
+       /* Ensure we have an F-Curve to add keyframes to */
+       act = verify_adt_action((ID *)cu, TRUE);
        fcu = verify_fcurve(act, NULL, &ptr, "eval_time", 0, TRUE);
-
+       
        if (G.debug & G_DEBUG) {
                printf("%s: tot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
                for (i = 0; i < gtd->num_points; i++) {
                        printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
                }
        }
-
+       
        if (gtd->mode == GP_STROKECONVERT_TIMING_LINEAR) {
                float cfra;
-
+               
                /* Linear extrapolation! */
                fcu->extend = FCURVE_EXTRAPOLATE_LINEAR;
-
+               
                cu->ctime = 0.0f;
                cfra = (float)gtd->start_frame;
                insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
-
+               
                cu->ctime = cu->pathlen;
                if (gtd->realtime) {
                        cfra += (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
@@ -760,34 +768,33 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
        else {
                /* Use actual recorded timing! */
                float time_range;
-
+               
                /* CustomGaps specific */
                float tot_gaps_time = 0.0f;
-
-               /* Pre-process gaps, in case we don't want to keep their org timing */
+               
+               /* Pre-process gaps, in case we don't want to keep their original timing */
                if (gtd->mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
                        gp_stroke_path_animation_preprocess_gaps(gtd, &nbr_gaps, &tot_gaps_time);
                }
-
+               
                if (gtd->realtime) {
                        time_range = (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
                }
                else {
                        time_range = (float)(gtd->end_frame - gtd->start_frame);
                }
-
+               
                if (G.debug & G_DEBUG) {
-                       printf("Starting keying!\n");
+                       printf("GP Stroke Path Conversion: Starting keying!\n");
                }
-
+               
                gp_stroke_path_animation_add_keyframes(reports, ptr, prop, fcu, cu, gtd, time_range,
                                                       nbr_gaps, tot_gaps_time);
-
        }
-
+       
        /* As we used INSERTKEY_FAST mode, we need to recompute all curve's handles now */
        calchandles_fcurve(fcu);
-
+       
        if (G.debug & G_DEBUG) {
                printf("%s: \ntot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
                for (i = 0; i < gtd->num_points; i++) {
@@ -795,11 +802,11 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
                }
                printf("\n\n");
        }
-
+       
        WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
-
+       
        /* send updates */
-       DAG_id_tag_update((ID*)cu, 0);
+       DAG_id_tag_update(&cu->id, 0);
 }
 
 #undef MIN_TIME_DELTA
@@ -813,14 +820,15 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                               float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
 {
        bGPDspoint *pt;
-       Nurb *nu = curnu ? *curnu : NULL;
+       Nurb *nu = (curnu) ? *curnu : NULL;
        BPoint *bp, *prev_bp = NULL;
-       int i, old_nbp = 0;
        const int do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
+       int i, old_nbp = 0;
 
        /* create new 'nurb' or extend current one within the curve */
        if (nu) {
                old_nbp = nu->pntsu;
+               
                /* If stitch, the first point of this stroke is already present in current nu.
                 * Else, we have to add to additional points to make the zero-radius link between strokes.
                 */
@@ -837,9 +845,9 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                nu->resolu = cu->resolu;
                nu->resolv = cu->resolv;
                nu->knotsu = NULL;
-
+               
                nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "bpoints");
-
+               
                stitch = FALSE; /* Security! */
        }
 
@@ -861,11 +869,12 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                float delta_time;
 
                prev_bp = NULL;
-               if (old_nbp > 1 && gps->prev && gps->prev->totpoints > 1) {
+               if ((old_nbp > 1) && gps->prev && (gps->prev->totpoints > 1)) {
                        /* Only use last curve segment if previous stroke was not a single-point one! */
                        prev_bp = nu->bp + old_nbp - 2;
                }
                bp = nu->bp + old_nbp - 1;
+               
                /* XXX We do this twice... Not sure it's worth to bother about this! */
                gp_strokepoint_convertcoords(C, gps, gps->points, p, subrect);
                if (prev_bp) {
@@ -874,6 +883,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                else {
                        interp_v3_v3v3(p1, bp->vec, p, GAP_DFAC);
                }
+               
                if (gps->totpoints > 1) {
                        /* XXX We do this twice... Not sure it's worth to bother about this! */
                        gp_strokepoint_convertcoords(C, gps, gps->points + 1, next_p, subrect);
@@ -882,7 +892,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                else {
                        interp_v3_v3v3(p2, p, bp->vec, GAP_DFAC);
                }
-
+               
                /* First point */
                bp++;
                copy_v3_v3(bp->vec, p1);
@@ -898,7 +908,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                        }
                        gp_timing_data_add_point(gtd, gtd->inittime, delta_time, len_v3v3((bp - 1)->vec, p1));
                }
-
+               
                /* Second point */
                bp++;
                copy_v3_v3(bp->vec, p2);
@@ -915,25 +925,26 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                        }
                        gp_timing_data_add_point(gtd, gps->inittime, delta_time, len_v3v3(p1, p2));
                }
-
+               
                old_nbp += 2;
        }
        if (old_nbp && do_gtd) {
                prev_bp = nu->bp + old_nbp - 1;
        }
+       
        /* add points */
-       for (i = stitch ? 1 : 0, pt = gps->points + (stitch ? 1 : 0), bp = nu->bp + old_nbp;
+       for (i = (stitch) ? 1 : 0, pt = gps->points + ((stitch) ? 1 : 0), bp = nu->bp + old_nbp;
             i < gps->totpoints;
             i++, pt++, bp++)
        {
                float p3d[3];
                float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
-
+               
                /* get coordinates to add at */
                gp_strokepoint_convertcoords(C, gps, pt, p3d, subrect);
                copy_v3_v3(bp->vec, p3d);
                bp->vec[3] = 1.0f;
-
+               
                /* set settings */
                bp->f1 = SELECT;
                bp->radius = width * rad_fac;
@@ -945,14 +956,14 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
                else if (bp->weight > minmax_weights[1]) {
                        minmax_weights[1] = bp->weight;
                }
-
+               
                /* Update timing data */
                if (do_gtd) {
-                       gp_timing_data_add_point(gtd, gps->inittime, pt->time, prev_bp ? len_v3v3(prev_bp->vec, p3d) : 0.0f);
+                       gp_timing_data_add_point(gtd, gps->inittime, pt->time, (prev_bp) ? len_v3v3(prev_bp->vec, p3d) : 0.0f);
                }
                prev_bp = bp;
        }
-
+       
        /* add nurb to curve */
        if (!curnu || !*curnu) {
                BLI_addtail(&cu->nurb, nu);
@@ -960,7 +971,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
        if (curnu) {
                *curnu = nu;
        }
-
+       
        BKE_nurb_knot_calc_u(nu);
 }
 
@@ -968,7 +979,7 @@ static int gp_camera_view_subrect(bContext *C, rctf *subrect)
 {
        View3D *v3d = CTX_wm_view3d(C);
        ARegion *ar = CTX_wm_region(C);
-
+       
        if (v3d) {
                RegionView3D *rv3d = ar->regiondata;
                
@@ -979,7 +990,7 @@ static int gp_camera_view_subrect(bContext *C, rctf *subrect)
                        return 1;
                }
        }
-
+       
        return 0;
 }
 
@@ -988,12 +999,12 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                                 float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
 {
        bGPDspoint *pt;
-       Nurb *nu = curnu ? *curnu : NULL;
+       Nurb *nu = (curnu) ? *curnu : NULL;
        BezTriple *bezt, *prev_bezt = NULL;
        int i, tot, old_nbezt = 0;
        float p3d_cur[3], p3d_prev[3], p3d_next[3];
        const int do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
-
+       
        /* create new 'nurb' or extend current one within the curve */
        if (nu) {
                old_nbezt = nu->pntsu;
@@ -1001,17 +1012,17 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                 * so no need to add it.
                 * If no stitch, we want to add two additional points to make a "zero-radius" link between both strokes.
                 */
-               BKE_nurb_bezierPoints_add(nu, gps->totpoints + (stitch ? -1 : 2));
+               BKE_nurb_bezierPoints_add(nu, gps->totpoints + ((stitch) ? -1 : 2));
        }
        else {
                nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_bezier(nurb)");
-
+               
                nu->pntsu = gps->totpoints;
                nu->resolu = 12;
                nu->resolv = 12;
                nu->type = CU_BEZIER;
                nu->bezt = (BezTriple *)MEM_callocN(gps->totpoints * sizeof(BezTriple), "bezts");
-
+               
                stitch = FALSE; /* Security! */
        }
 
@@ -1024,9 +1035,9 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
        /* get initial coordinates */
        pt = gps->points;
        if (tot) {
-               gp_strokepoint_convertcoords(C, gps, pt, stitch ? p3d_prev : p3d_cur, subrect);
+               gp_strokepoint_convertcoords(C, gps, pt, (stitch) ? p3d_prev : p3d_cur, subrect);
                if (tot > 1) {
-                       gp_strokepoint_convertcoords(C, gps, pt + 1, stitch ? p3d_cur : p3d_next, subrect);
+                       gp_strokepoint_convertcoords(C, gps, pt + 1, (stitch) ? p3d_cur : p3d_next, subrect);
                }
                if (stitch && tot > 2) {
                        gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
@@ -1035,7 +1046,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
 
        /* If needed, make the link between both strokes with two zero-radius additional points */
        if (curnu && old_nbezt) {
-               /* Update last point's second handle! */
+               /* Update last point's second handle */
                if (stitch) {
                        float h2[3];
                        bezt = nu->bezt + old_nbezt - 1;
@@ -1043,6 +1054,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                        copy_v3_v3(bezt->vec[2], h2);
                        pt++;
                }
+               
                /* Create "link points" */
                /* About "zero-radius" point interpolations:
                 * - If we have at least two points in current curve (most common case), we linearly extrapolate
@@ -1055,7 +1067,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                else {
                        float h1[3], h2[3], p1[3], p2[3];
                        float delta_time;
-
+                       
                        prev_bezt = NULL;
                        if (old_nbezt > 1 && gps->prev && gps->prev->totpoints > 1) {
                                /* Only use last curve segment if previous stroke was not a single-point one! */
@@ -1074,15 +1086,15 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                        else {
                                interp_v3_v3v3(p2, p3d_cur, bezt->vec[1], GAP_DFAC);
                        }
-
+                       
                        /* Second handle of last point */
                        interp_v3_v3v3(h2, bezt->vec[1], p1, BEZT_HANDLE_FAC);
                        copy_v3_v3(bezt->vec[2], h2);
-
+                       
                        /* First point */
                        interp_v3_v3v3(h1, p1, bezt->vec[1], BEZT_HANDLE_FAC);
                        interp_v3_v3v3(h2, p1, p2, BEZT_HANDLE_FAC);
-
+                       
                        bezt++;
                        copy_v3_v3(bezt->vec[0], h1);
                        copy_v3_v3(bezt->vec[1], p1);
@@ -1090,7 +1102,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                        bezt->h1 = bezt->h2 = HD_FREE;
                        bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
                        minmax_weights[0] = bezt->radius = bezt->weight = 0.0f;
-
+                       
                        if (do_gtd) {
                                if (prev_bezt) {
                                        delta_time = gtd->tot_time + (gtd->tot_time - gtd->times[gtd->cur_point - 1]) * GAP_DFAC;
@@ -1100,11 +1112,11 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                                }
                                gp_timing_data_add_point(gtd, gtd->inittime, delta_time, len_v3v3((bezt - 1)->vec[1], p1));
                        }
-
+                       
                        /* Second point */
                        interp_v3_v3v3(h1, p2, p1, BEZT_HANDLE_FAC);
                        interp_v3_v3v3(h2, p2, p3d_cur, BEZT_HANDLE_FAC);
-
+                       
                        bezt++;
                        copy_v3_v3(bezt->vec[0], h1);
                        copy_v3_v3(bezt->vec[1], p2);
@@ -1112,7 +1124,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                        bezt->h1 = bezt->h2 = HD_FREE;
                        bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
                        minmax_weights[0] = bezt->radius = bezt->weight = 0.0f;
-
+                       
                        if (do_gtd) {
                                /* This negative delta_time marks the gap! */
                                if (tot > 1) {
@@ -1123,7 +1135,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                                }
                                gp_timing_data_add_point(gtd, gps->inittime, delta_time, len_v3v3(p1, p2));
                        }
-
+                       
                        old_nbezt += 2;
                        copy_v3_v3(p3d_prev, p2);
                }
@@ -1131,29 +1143,30 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
        if (old_nbezt && do_gtd) {
                prev_bezt = nu->bezt + old_nbezt - 1;
        }
+       
        /* add points */
        for (i = stitch ? 1 : 0, bezt = nu->bezt + old_nbezt; i < tot; i++, pt++, bezt++) {
                float h1[3], h2[3];
                float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
-
+               
                if (i || old_nbezt) {
                        interp_v3_v3v3(h1, p3d_cur, p3d_prev, BEZT_HANDLE_FAC);
                }
                else {
                        interp_v3_v3v3(h1, p3d_cur, p3d_next, -BEZT_HANDLE_FAC);
                }
-
+               
                if (i < tot - 1) {
                        interp_v3_v3v3(h2, p3d_cur, p3d_next, BEZT_HANDLE_FAC);
                }
                else {
                        interp_v3_v3v3(h2, p3d_cur, p3d_prev, -BEZT_HANDLE_FAC);
                }
-
+               
                copy_v3_v3(bezt->vec[0], h1);
                copy_v3_v3(bezt->vec[1], p3d_cur);
                copy_v3_v3(bezt->vec[2], h2);
-
+               
                /* set settings */
                bezt->h1 = bezt->h2 = HD_FREE;
                bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
@@ -1166,23 +1179,23 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
                else if (bezt->weight > minmax_weights[1]) {
                        minmax_weights[1] = bezt->weight;
                }
-
+               
                /* Update timing data */
                if (do_gtd) {
                        gp_timing_data_add_point(gtd, gps->inittime, pt->time, prev_bezt ? len_v3v3(prev_bezt->vec[1], p3d_cur) : 0.0f);
                }
-
+               
                /* shift coord vects */
                copy_v3_v3(p3d_prev, p3d_cur);
                copy_v3_v3(p3d_cur, p3d_next);
-
+               
                if (i + 2 < tot) {
                        gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
                }
-
+               
                prev_bezt = bezt;
        }
-
+       
        /* must calculate handles or else we crash */
        BKE_nurb_handles_calc(nu);
 
@@ -1200,6 +1213,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
 
 static void gp_stroke_finalize_curve_endpoints(Curve *cu)
 {
+       /* start */
        Nurb *nu = cu->nurb.first;
        int i = 0;
        if (nu->bezt) {
@@ -1214,7 +1228,8 @@ static void gp_stroke_finalize_curve_endpoints(Curve *cu)
                        bp[i].weight = bp[i].radius = 0.0f;
                }
        }
-
+       
+       /* end */
        nu = cu->nurb.last;
        i = nu->pntsu - 1;
        if (nu->bezt) {
@@ -1237,7 +1252,7 @@ static void gp_stroke_norm_curve_weights(Curve *cu, float minmax_weights[2])
        const float delta = minmax_weights[0];
        const float fac = 1.0f / (minmax_weights[1] - delta);
        int i;
-
+       
        for (nu = cu->nurb.first; nu; nu = nu->next) {
                if (nu->bezt) {
                        BezTriple *bezt = nu->bezt;
@@ -1269,11 +1284,11 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
 
        /* camera framing */
        rctf subrect, *subrect_ptr = NULL;
-
+       
        /* error checking */
        if (ELEM3(NULL, gpd, gpl, gpf))
                return;
-
+       
        /* only convert if there are any strokes on this layer's frame to convert */
        if (gpf->strokes.first == NULL)
                return;
@@ -1282,7 +1297,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
        if (gp_camera_view_subrect(C, &subrect)) {
                subrect_ptr = &subrect;
        }
-
+       
        /* init the curve object (remove rotation and get curve data from it)
         *      - must clear transforms set on object, as those skew our results
         */
@@ -1291,28 +1306,34 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
        zero_v3(ob->rot);
        cu = ob->data;
        cu->flag |= CU_3D;
-
+       
        /* rename object and curve to layer name */
        rename_id((ID *)ob, gpl->info);
        rename_id((ID *)cu, gpl->info);
-
-       gtd->inittime = ((bGPDstroke*)gpf->strokes.first)->inittime;
-
+       
+       gtd->inittime = ((bGPDstroke *)gpf->strokes.first)->inittime;
+       
        /* add points to curve */
        for (gps = gpf->strokes.first; gps; gps = gps->next) {
                /* Detect new strokes created because of GP_STROKE_BUFFER_MAX reached,
                 * and stitch them to previous one.
                 */
                int stitch = FALSE;
+               
                if (prev_gps) {
                        bGPDspoint *pt1 = prev_gps->points + prev_gps->totpoints - 1;
                        bGPDspoint *pt2 = gps->points;
-                       if (pt1->x == pt2->x && pt1->y == pt2->y)
+                       
+                       if ((pt1->x == pt2->x) && (pt1->y == pt2->y)) {
                                stitch = TRUE;
+                       }
                }
+               
                /* Decide whether we connect this stroke to previous one */
-               if (!(stitch || link_strokes))
+               if (!(stitch || link_strokes)) {
                        nu = NULL;
+               }
+               
                switch (mode) {
                        case GP_STROKECONVERT_PATH: 
                                gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);
@@ -1332,20 +1353,25 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
                gp_stroke_finalize_curve_endpoints(cu);
 
        /* Update curve's weights, if needed */
-       if (norm_weights && (minmax_weights[0] > 0.0f || minmax_weights[1] < 1.0f))
+       if (norm_weights && ((minmax_weights[0] > 0.0f) || (minmax_weights[1] < 1.0f)))
                gp_stroke_norm_curve_weights(cu, minmax_weights);
 
        /* Create the path animation, if needed */
        gp_stroke_path_animation(C, reports, cu, gtd);
 
-       /* Reset org object as active, else we can't edit operator's settings!!! */
+       /* Reset original object as active, else we can't edit operator's settings!!! */
        /* set layers OK */
        newbase = BASACT;
-       newbase->lay = base->lay;
-       ob->lay = newbase->lay;
+       if (base) {
+               newbase->lay = base->lay;
+               ob->lay = newbase->lay;
+       }
+       
        /* restore, BKE_object_add sets active */
        BASACT = base;
-       base->flag |= SELECT;
+       if (base) {
+               base->flag |= SELECT;
+       }
 }
 
 /* --- */
@@ -1361,13 +1387,14 @@ static int gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOper
        bGPDspoint *pt;
        double base_time, cur_time, prev_time = -1.0;
        int i, valid = TRUE;
-
+       
        do {
                base_time = cur_time = gps->inittime;
                if (cur_time <= prev_time) {
                        valid = FALSE;
                        break;
                }
+               
                prev_time = cur_time;
                for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
                        cur_time = base_time + (double)pt->time;
@@ -1380,11 +1407,12 @@ static int gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOper
                        }
                        prev_time = cur_time;
                }
+               
                if (!valid) {
                        break;
                }
        } while ((gps = gps->next));
-
+       
        if (op) {
                RNA_boolean_set(op->ptr, "use_timing_data", valid);
        }
@@ -1396,6 +1424,7 @@ static void gp_convert_set_end_frame(struct Main *UNUSED(main), struct Scene *UN
 {
        int start_frame = RNA_int_get(ptr, "start_frame");
        int end_frame = RNA_int_get(ptr, "end_frame");
+       
        if (end_frame <= start_frame) {
                RNA_int_set(ptr, "end_frame", start_frame + 1);
        }
@@ -1423,19 +1452,19 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
        int link_strokes = RNA_boolean_get(op->ptr, "use_link_strokes");
        int valid_timing;
        tGpTimingData gtd;
-
+       
        /* check if there's data to work with */
        if (gpd == NULL) {
-               BKE_report(op->reports, RPT_ERROR, "No grease pencil data to work on");
+               BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data to work on");
                return OPERATOR_CANCELLED;
        }
-
+       
        if (!RNA_property_is_set(op->ptr, prop) && !gp_convert_check_has_valid_timing(C, gpl, op)) {
                BKE_report(op->reports, RPT_WARNING,
-                          "Current grease pencil strokes have no valid timing data, most timing options will be hidden!");
+                          "Current Grease Pencil strokes have no valid timing data, most timing options will be hidden!");
        }
        valid_timing = RNA_property_boolean_get(op->ptr, prop);
-
+       
        gtd.mode = RNA_enum_get(op->ptr, "timing_mode");
        /* Check for illegal timing mode! */
        if (!valid_timing && !ELEM(gtd.mode, GP_STROKECONVERT_TIMING_NONE, GP_STROKECONVERT_TIMING_LINEAR)) {
@@ -1445,7 +1474,8 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
        if (!link_strokes) {
                gtd.mode = GP_STROKECONVERT_TIMING_NONE;
        }
-
+       
+       /* grab all relevant settings */
        gtd.frame_range = RNA_int_get(op->ptr, "frame_range");
        gtd.start_frame = RNA_int_get(op->ptr, "start_frame");
        gtd.realtime = valid_timing ? RNA_boolean_get(op->ptr, "use_realtime") : FALSE;
@@ -1458,13 +1488,24 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
        gtd.dists = gtd.times = NULL;
        gtd.tot_dist = gtd.tot_time = gtd.gap_tot_time = 0.0f;
        gtd.inittime = 0.0;
-
+       
+       /* perform conversion */
        gp_layer_to_curve(C, op->reports, gpd, gpl, mode, norm_weights, rad_fac, link_strokes, &gtd);
-
+       
+       /* free temp memory */
+       if (gtd.dists) {
+               MEM_freeN(gtd.dists);
+               gtd.dists = NULL;
+       }
+       if (gtd.times) {
+               MEM_freeN(gtd.times);
+               gtd.times = NULL;
+       }
+       
        /* notifiers */
        WM_event_add_notifier(C, NC_OBJECT | NA_ADDED, NULL);
        WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
-
+       
        /* done */
        return OPERATOR_FINISHED;
 }
@@ -1478,7 +1519,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
        float gap_duration = RNA_float_get(ptr, "gap_duration");
        float gap_randomness = RNA_float_get(ptr, "gap_randomness");
        int valid_timing = RNA_boolean_get(ptr, "use_timing_data");
-
+       
        /* Always show those props */
        if (strcmp(prop_id, "type") == 0 ||
            strcmp(prop_id, "use_normalize_weights") == 0 ||
@@ -1487,7 +1528,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
        {
                return TRUE;
        }
-
+       
        /* Never show this prop */
        if (strcmp(prop_id, "use_timing_data") == 0)
                return FALSE;
@@ -1496,7 +1537,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
                /* Only show when link_stroke is TRUE */
                if (strcmp(prop_id, "timing_mode") == 0)
                        return TRUE;
-
+               
                if (timing_mode != GP_STROKECONVERT_TIMING_NONE) {
                        /* Only show when link_stroke is TRUE and stroke timing is enabled */
                        if (strcmp(prop_id, "frame_range") == 0 ||
@@ -1504,26 +1545,26 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
                        {
                                return TRUE;
                        }
-
+                       
                        /* Only show if we have valid timing data! */
                        if (valid_timing && strcmp(prop_id, "use_realtime") == 0)
                                return TRUE;
-
+                       
                        /* Only show if realtime or valid_timing is FALSE! */
                        if ((!realtime || !valid_timing) && strcmp(prop_id, "end_frame") == 0)
                                return TRUE;
-
+                       
                        if (valid_timing && timing_mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
                                /* Only show for custom gaps! */
                                if (strcmp(prop_id, "gap_duration") == 0)
                                        return TRUE;
-
+                               
                                /* Only show randomness for non-null custom gaps! */
-                               if (strcmp(prop_id, "gap_randomness") == 0 && gap_duration > 0.0f)
+                               if (strcmp(prop_id, "gap_randomness") == 0 && (gap_duration > 0.0f))
                                        return TRUE;
-
+                               
                                /* Only show seed for randomize action! */
-                               if (strcmp(prop_id, "seed") == 0 && gap_duration > 0.0f && gap_randomness > 0.0f)
+                               if (strcmp(prop_id, "seed") == 0 && (gap_duration > 0.0f) && (gap_randomness > 0.0f))
                                        return TRUE;
                        }
                }
@@ -1565,15 +1606,18 @@ void GPENCIL_OT_convert(wmOperatorType *ot)
        
        /* properties */
        ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_convertmodes, 0, "Type", "Which type of curve to convert to");
+       
        RNA_def_boolean(ot->srna, "use_normalize_weights", TRUE, "Normalize Weight",
                        "Normalize weight (set from stroke width)");
        RNA_def_float(ot->srna, "radius_multiplier", 1.0f, 0.0f, 1000.0f, "Radius Fac",
                      "Multiplier for the points' radii (set from stroke width)", 0.0f, 10.0f);
        RNA_def_boolean(ot->srna, "use_link_strokes", TRUE, "Link Strokes",
                        "Whether to link strokes with zero-radius sections of curves");
+       
        prop = RNA_def_enum(ot->srna, "timing_mode", prop_gpencil_convert_timingmodes, GP_STROKECONVERT_TIMING_FULL,
                            "Timing Mode", "How to use timing data stored in strokes");
        RNA_def_enum_funcs(prop, rna_GPConvert_mode_items);
+       
        RNA_def_int(ot->srna, "frame_range", 100, 1, 10000, "Frame Range",
                    "The duration of evaluation of the path control curve", 1, 1000);
        RNA_def_int(ot->srna, "start_frame", 1, 1, 100000, "Start Frame",
@@ -1583,16 +1627,18 @@ void GPENCIL_OT_convert(wmOperatorType *ot)
        prop = RNA_def_int(ot->srna, "end_frame", 250, 1, 100000, "End Frame",
                           "The end frame of the path control curve (if Realtime is not set)", 1, 100000);
        RNA_def_property_update_runtime(prop, gp_convert_set_end_frame);
+       
        RNA_def_float(ot->srna, "gap_duration", 0.0f, 0.0f, 10000.0f, "Gap Duration",
                      "Custom Gap mode: (Average) length of gaps, in frames "
-                     "(note: realtime value, will be scaled if Realtime is not set)", 0.0f, 1000.0f);
+                     "(Note: Realtime value, will be scaled if Realtime is not set)", 0.0f, 1000.0f);
        RNA_def_float(ot->srna, "gap_randomness", 0.0f, 0.0f, 10000.0f, "Gap Randomness",
                      "Custom Gap mode: Number of frames that gap lengths can vary", 0.0f, 1000.0f);
        RNA_def_int(ot->srna, "seed", 0, 0, 1000, "Random Seed",
                    "Custom Gap mode: Random generator seed", 0, 100);
+                               
        /* Note: Internal use, this one will always be hidden by UI code... */
        prop = RNA_def_boolean(ot->srna, "use_timing_data", FALSE, "Has Valid Timing",
-                              "Whether the converted grease pencil layer has valid timing data (internal use)");
+                              "Whether the converted Grease Pencil layer has valid timing data (internal use)");
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }