"Dynamic Sketch" patch, which adds timing data to GP strokes, by storing an inittime in each stroke (value returned by PIL_check_seconds_timer() func), and then a delta time for each of its points, relative to that inittime.

These timing data can then be used during conversion to Curve objects, to create a path animation (i.e. an Evaluation Time F-Curve) exactly reproducing the drawing movements.

Aside from this "main feature", the patch brings several fixes/enhancements:
* Stroke smoothing/simplifying will no more move the start/end points of a stroke (this was rather annoying sometimes!).
* Also optimized smoothing code (even though not really noticeable on a modern computer, it now uses less memory and runs faster).
* When converting to curve, you now have the following new possibilities:
** Normalize the weight values (currently, they will get "stroke width * 0.1", i.e. would range by default from 0.0 to 0.3...).
** Scale the radius values to your liking (again, currently they are set from stroke width times 0.1)!
** Link all strokes into a single curve, using zero-radius sections (this is mandatory to use the dynamic feature!).

Here is a small demo video: http://youtu.be/VwWEXrnQAFI

Will update user manual later today.

2 files changed, 1145 insertions, 140 deletions

diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index ed8a1ea8280..dda97abe5ec 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -40,8 +40,10 @@
 
 #include "BLI_math.h"
 #include "BLI_blenlib.h"
+#include "BLI_rand.h"
 #include "BLI_utildefines.h"
 
+#include "DNA_anim_types.h"
 #include "DNA_curve_types.h"
 #include "DNA_object_types.h"
 #include "DNA_node_types.h"
@@ -51,14 +53,20 @@
 #include "DNA_view3d_types.h"
 #include "DNA_gpencil_types.h"
 
+#include "BKE_animsys.h"
 #include "BKE_context.h"
 #include "BKE_curve.h"
+#include "BKE_depsgraph.h"
+#include "BKE_fcurve.h"
+#include "BKE_global.h"
 #include "BKE_gpencil.h"
 #include "BKE_library.h"
+#include "BKE_main.h"
 #include "BKE_object.h"
 #include "BKE_report.h"
 #include "BKE_tracking.h"
 
+#include "UI_interface.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -71,6 +79,7 @@
 #include "ED_gpencil.h"
 #include "ED_view3d.h"
 #include "ED_clip.h"
+#include "ED_keyframing.h"
 
 #include "gpencil_intern.h"
 
@@ -387,6 +396,14 @@ enum {
 	GP_STROKECONVERT_CURVE,
 };
 
+/* Defines for possible timing modes */
+enum {
+	GP_STROKECONVERT_TIMING_NONE = 1,
+	GP_STROKECONVERT_TIMING_LINEAR = 2,
+	GP_STROKECONVERT_TIMING_FULL = 3,
+	GP_STROKECONVERT_TIMING_CUSTOMGAP = 4,
+};
+
 /* RNA enum define */
 static EnumPropertyItem prop_gpencil_convertmodes[] = {
 	{GP_STROKECONVERT_PATH, "PATH", 0, "Path", ""},
@@ -394,6 +411,31 @@ static EnumPropertyItem prop_gpencil_convertmodes[] = {
 	{0, NULL, 0, NULL, NULL}
 };
 
+static EnumPropertyItem prop_gpencil_convert_timingmodes_restricted[] = {
+	{GP_STROKECONVERT_TIMING_NONE, "NONE", 0, "No Timing", "Ignore timing"},
+	{GP_STROKECONVERT_TIMING_LINEAR, "LINEAR", 0, "Linear", "Simple linear timing"},
+	{0, NULL, 0, NULL, NULL},
+};
+
+static EnumPropertyItem prop_gpencil_convert_timingmodes[] = {
+	{GP_STROKECONVERT_TIMING_NONE, "NONE", 0, "No Timing", "Ignore timing"},
+	{GP_STROKECONVERT_TIMING_LINEAR, "LINEAR", 0, "Linear", "Simple linear timing"},
+	{GP_STROKECONVERT_TIMING_FULL, "FULL", 0, "Original", "Use the original timing, gaps included"},
+	{GP_STROKECONVERT_TIMING_CUSTOMGAP, "CUSTOMGAP", 0, "Custom Gaps",
+	                                    "Use the original timing, but with custom gap lengths (in frames)"},
+	{0, NULL, 0, NULL, NULL},
+};
+
+static EnumPropertyItem *rna_GPConvert_mode_items(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop),
+                                                  int *free)
+{
+	*free = FALSE;
+	if (RNA_boolean_get(ptr, "use_timing_data")) {
+		return prop_gpencil_convert_timingmodes;
+	}
+	return prop_gpencil_convert_timingmodes_restricted;
+}
+
 /* --- */
 
 /* convert the coordinates from the given stroke point into 3d-coordinates 
@@ -440,40 +482,485 @@ static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoin
 
 /* --- */
 
+/* temp struct for gp_stroke_path_animation() */
+typedef struct tGpTimingData {
+	/* Data set from operator settings */
+	int mode;
+	int frame_range; /* Number of frames evaluated for path animation */
+	int start_frame, end_frame;
+	int realtime; /* A bool, actually, will overwrite end_frame in case of Original or CustomGap timing... */
+	float gap_duration, gap_randomness; /* To be used with CustomGap mode*/
+	int seed;
+
+	/* Data set from points, used to compute final timing FCurve */
+	int num_points, cur_point;
+
+	/* Distances */
+	float *dists;
+	float tot_dist;
+
+	/* Times */
+	float *times; /* Note: Gap times will be negative! */
+	float tot_time, gap_tot_time;
+	double inittime;
+} tGpTimingData;
+
+static void _gp_timing_data_set_nbr(tGpTimingData *gtd, int nbr)
+{
+	float *tmp;
+
+	BLI_assert(nbr > gtd->num_points);
+
+	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);
+	}
+
+	tmp = gtd->times;
+	gtd->times = MEM_callocN(sizeof(float) * nbr, __func__);
+	if (tmp) {
+		memcpy(gtd->times, tmp, sizeof(float) * gtd->num_points);
+		MEM_freeN(tmp);
+	}
+
+	gtd->num_points = nbr;
+}
+
+static void gp_timing_data_add_point(tGpTimingData *gtd, double stroke_inittime, float time, float delta_dist)
+{
+	if (time < 0.0f) {
+		/* This is a gap, negative value! */
+		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
+		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->cur_point++;
+}
+
+/* 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
+
+/* Loop over next points to find the end of the stroke, and compute */
+static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, int idx, int nbr_gaps, int *nbr_done_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];
+			if (gtd->mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
+				/* In this mode, gap time between this stroke and the next should be 0 currently...
+				 * So we have to compute its final duration!
+				 */
+				if (gtd->gap_randomness > 0.0f) {
+					/* We want gaps that are in gtd->gap_duration +/- gtd->gap_randomness range,
+					 * and which sum to exactly tot_gaps_time...
+					 */
+					int rem_gaps = nbr_gaps - *nbr_done_gaps;
+					if (rem_gaps < 2) {
+						/* Last gap, just give remaining time! */
+						*next_delta_time = tot_gaps_time;
+					}
+					else {
+						float delta, min, max;
+						/* 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);
+						/* 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);
+						*next_delta_time += gtd->gap_duration + (BLI_frand() * (max - min)) + min;
+					}
+				}
+				else {
+					*next_delta_time += gtd->gap_duration;
+				}
+			}
+			(*nbr_done_gaps)++;
+			break;
+		}
+	}
+
+	return j - 1;
+}
+
+static void gp_stroke_path_animation_preprocess_gaps(tGpTimingData *gtd, int *nbr_gaps, float *tot_gaps_time)
+{
+	int i;
+	float delta_time = 0.0f;
+
+	for (i = 0; i < gtd->num_points; i++) {
+		if (gtd->times[i] < 0 && i) {
+			(*nbr_gaps)++;
+			gtd->times[i] = -gtd->times[i] - delta_time;
+			delta_time += gtd->times[i] - gtd->times[i - 1];
+			gtd->times[i] = -gtd->times[i - 1]; /* Temp marker, values *have* to be different! */
+		}
+		else {
+			gtd->times[i] -= delta_time;
+		}
+	}
+	gtd->tot_time -= delta_time;
+
+	*tot_gaps_time = (float)(*nbr_gaps) * gtd->gap_duration;
+	gtd->tot_time += *tot_gaps_time;
+	if (G.debug & G_DEBUG) {
+		printf("%f, %f, %f, %d\n", gtd->tot_time, delta_time, *tot_gaps_time, *nbr_gaps);
+	}
+	if (gtd->gap_randomness > 0.0f) {
+		BLI_srandom(gtd->seed);
+	}
+}
+
+static void gp_stroke_path_animation_add_keyframes(ReportList *reports, PointerRNA ptr, PropertyRNA *prop, FCurve *fcu,
+                                                   Curve *cu, tGpTimingData *gtd, float cfra, float time_range,
+                                                   int nbr_gaps, float tot_gaps_time)
+{
+	/* Use actual recorded timing! */
+	float time_start = (float)gtd->start_frame;
+
+	float last_valid_time = 0.0f;
+	int end_stroke_idx = -1, start_stroke_idx = 0;
+	float end_stroke_time = 0.0f;
+
+	/* CustomGaps specific */
+	float delta_time = 0.0f, next_delta_time = 0.0f;
+	int nbr_done_gaps = 0;
+
+	int i;
+
+	/* This is a bit tricky, as:
+	 * - We can't add arbitrarily close points on FCurve (in time).
+	 * - We *must* have all "caps" points of all strokes in FCurve, as much as possible!
+	 */
+	for (i = 0; i < gtd->num_points; i++) {
+		/* If new stroke... */
+		if (i > end_stroke_idx) {
+			start_stroke_idx = i;
+			delta_time = next_delta_time;
+			/* find end of that new stroke */
+			end_stroke_idx = gp_find_end_of_stroke_idx(gtd, i, nbr_gaps, &nbr_done_gaps,
+			                                           tot_gaps_time, delta_time, &next_delta_time);
+			/* 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
+			 * that the end point of the stroke is far enough!
+			 * In case it is not, we keep the end point...
+			 * Note that with CustomGaps mode, this is here we set the actual gap timing!
+			 */
+			if ((end_stroke_time - last_valid_time) > MIN_TIME_DELTA * 2) {
+				if ((cfra - last_valid_time) < MIN_TIME_DELTA) {
+					cfra = last_valid_time + MIN_TIME_DELTA;
+				}
+				insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
+				last_valid_time = cfra;
+			}
+			else if (G.debug & G_DEBUG) {
+				printf("\t Skipping start point %d, too close from end point %d\n", i, end_stroke_idx);
+			}
+		}
+		else if (i == end_stroke_idx) {
+			/* Always try to insert end point of a curve (should be safe enough, anyway...) */
+			if ((cfra - last_valid_time) < MIN_TIME_DELTA) {
+				cfra = last_valid_time + MIN_TIME_DELTA;
+			}
+			insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
+			last_valid_time = cfra;
+		}
+		else {
+			/* Else ("middle" point), we only insert it if it's far enough from last keyframe,
+			 * and also far enough from (not yet added!) end_stroke keyframe!
+			 */
+			if ((cfra - last_valid_time) > MIN_TIME_DELTA && (end_stroke_time - cfra) > MIN_TIME_DELTA) {
+				insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
+				last_valid_time = cfra;
+			}
+			else if (G.debug & G_DEBUG) {
+				printf("\t Skipping \"middle\" point %d, too close from last added point or end point %d\n",
+				       i, end_stroke_idx);
+			}
+		}
+	}
+}
+
+static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu, tGpTimingData *gtd)
+{
+	Scene *scene = CTX_data_scene(C);
+	bAction *act;
+	FCurve *fcu;
+	PointerRNA ptr;
+	PropertyRNA *prop = NULL;
+
+	float cfra;
+	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);
+	prop = RNA_struct_find_property(&ptr, "eval_time");
+	/* Get or create fcurve */
+	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) {
+		/* 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 */
+		}
+		else {
+			cfra = (float)gtd->end_frame;
+		}
+		insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
+	}
+	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 */
+		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");
+		}
+
+		gp_stroke_path_animation_add_keyframes(reports, ptr, prop, fcu, cu, gtd, cfra, 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++) {
+			printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
+		}
+		printf("\n\n");
+	}
+
+	WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
+
+	/* send updates */
+	DAG_id_tag_update((ID*)cu, 0);
+}
+
+#undef MIN_TIME_DELTA
+
+#define GAP_DFAC 0.05f
+#define WIDTH_CORR_FAC 0.1f
+#define BEZT_HANDLE_FAC 0.3f
+
 /* convert stroke to 3d path */
-static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect)
+static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu,
+                              float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
 {
 	bGPDspoint *pt;
-	Nurb *nu;
-	BPoint *bp;
-	int i;
+	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);
+
+	/* 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.
+		 */
+		BKE_nurb_points_add(nu, gps->totpoints + (stitch ? -1 : 2));
+	}
+	else {
+		nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_path(nurb)");
+		
+		nu->pntsu = gps->totpoints;
+		nu->pntsv = 1;
+		nu->orderu = 2; /* point-to-point! */
+		nu->type = CU_NURBS;
+		nu->flagu = CU_NURB_ENDPOINT;
+		nu->resolu = cu->resolu;
+		nu->resolv = cu->resolv;
+		nu->knotsu = NULL;
+
+		nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "bpoints");
+
+		stitch = FALSE; /* Security! */
+	}
 
-	/* create new 'nurb' within the curve */
-	nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_path(nurb)");
-	
-	nu->pntsu = gps->totpoints;
-	nu->pntsv = 1;
-	nu->orderu = gps->totpoints;
-	nu->flagu = CU_NURB_ENDPOINT;
-	nu->resolu = 32;
-	
-	nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * gps->totpoints, "bpoints");
-	
+	if (do_gtd) {
+		_gp_timing_data_set_nbr(gtd, nu->pntsu);
+	}
+
+	/* If needed, make the link between both strokes with two zero-radius additional points */
+	/* About "zero-radius" point interpolations:
+	 * - If we have at least two points in current curve (most common case), we linearly extrapolate
+	 *   the last segment to get the first point (p1) position and timing.
+	 * - If we do not have those (quite odd, but may happen), we linearly interpolate the last point
+	 *   with the first point of the current stroke.
+	 * The same goes for the second point, first segment of the current stroke is "negatively" extrapolated
+	 * if it exists, else (if the stroke is a single point), linear interpolation with last curve point...
+	 */
+	if (curnu && !stitch && old_nbp) {
+		float p1[3], p2[3], p[3], next_p[3];
+		float delta_time;
+
+		prev_bp = NULL;
+		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) {
+			interp_v3_v3v3(p1, prev_bp->vec, bp->vec, 1.0f + GAP_DFAC);
+		}
+		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);
+			interp_v3_v3v3(p2, p, next_p, -GAP_DFAC);
+		}
+		else {
+			interp_v3_v3v3(p2, p, bp->vec, GAP_DFAC);
+		}
+
+		/* First point */
+		bp++;
+		copy_v3_v3(bp->vec, p1);
+		bp->vec[3] = 1.0f;
+		bp->f1 = SELECT;
+		minmax_weights[0] = bp->radius = bp->weight = 0.0f;
+		if (do_gtd) {
+			if (prev_bp) {
+				delta_time = gtd->tot_time + (gtd->tot_time - gtd->times[gtd->cur_point - 1]) * GAP_DFAC;
+			}
+			else {
+				delta_time = gtd->tot_time + (((float)(gps->inittime - gtd->inittime)) - gtd->tot_time) * GAP_DFAC;
+			}
+			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);
+		bp->vec[3] = 1.0f;
+		bp->f1 = SELECT;
+		minmax_weights[0] = bp->radius = bp->weight = 0.0f;
+		if (do_gtd) {
+			/* This negative delta_time marks the gap! */
+			if (gps->totpoints > 1) {
+				delta_time = ((gps->points + 1)->time - gps->points->time) * -GAP_DFAC;
+			}
+			else {
+				delta_time = -(((float)(gps->inittime - gtd->inittime)) - gtd->tot_time) * GAP_DFAC;
+			}
+			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 = 0, pt = gps->points, bp = nu->bp; i < gps->totpoints; i++, pt++, bp++) {
+	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 = bp->weight = pt->pressure * gpl->thickness;
+		bp->radius = width * rad_fac;
+		bp->weight = width;
+		CLAMP(bp->weight, 0.0f, 1.0f);
+		if (bp->weight < minmax_weights[0]) {
+			minmax_weights[0] = bp->weight;
+		}
+		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);
+		}
+		prev_bp = bp;
 	}
-	
+
 	/* add nurb to curve */
-	BLI_addtail(&cu->nurb, nu);
+	if (!curnu || !*curnu) {
+		BLI_addtail(&cu->nurb, nu);
+	}
+	if (curnu) {
+		*curnu = nu;
+	}
+
+	BKE_nurb_knot_calc_u(nu);
 }
 
 static int gp_camera_view_subrect(bContext *C, rctf *subrect)
@@ -496,77 +983,288 @@ static int gp_camera_view_subrect(bContext *C, rctf *subrect)
 }
 
 /* convert stroke to 3d bezier */
-static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect)
+static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu,
+                                float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
 {
 	bGPDspoint *pt;
-	Nurb *nu;
-	BezTriple *bezt;
-	int i, tot;
+	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;
+		/* If we do stitch, first point of current stroke is assumed the same as last point of previous stroke,
+		 * 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));
+	}
+	else {
+		nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_bezier(nurb)");
 
-	/* create new 'nurb' within the curve */
-	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");
 
-	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! */
+	}
+
+	if (do_gtd) {
+		_gp_timing_data_set_nbr(gtd, nu->pntsu);
+	}
 
 	tot = gps->totpoints;
 
 	/* get initial coordinates */
 	pt = gps->points;
 	if (tot) {
-		gp_strokepoint_convertcoords(C, gps, pt, 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, 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);
 		}
 	}
 
+	/* If needed, make the link between both strokes with two zero-radius additional points */
+	if (curnu && old_nbezt) {
+		/* Update last point's second handle! */
+		if (stitch) {
+			float h2[3];
+			bezt = nu->bezt + old_nbezt - 1;
+			interp_v3_v3v3(h2, bezt->vec[1], p3d_cur, BEZT_HANDLE_FAC);
+			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
+		 *   the last segment to get the first point (p1) position and timing.
+		 * - If we do not have those (quite odd, but may happen), we linearly interpolate the last point
+		 *   with the first point of the current stroke.
+		 * The same goes for the second point, first segment of the current stroke is "negatively" extrapolated
+		 * if it exists, else (if the stroke is a single point), linear interpolation with last curve point...
+		 */
+		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! */
+				prev_bezt = nu->bezt + old_nbezt - 2;
+			}
+			bezt = nu->bezt + old_nbezt - 1;
+			if (prev_bezt) {
+				interp_v3_v3v3(p1, prev_bezt->vec[1], bezt->vec[1], 1.0f + GAP_DFAC);
+			}
+			else {
+				interp_v3_v3v3(p1, bezt->vec[1], p3d_cur, GAP_DFAC);
+			}
+			if (tot > 1) {
+				interp_v3_v3v3(p2, p3d_cur, p3d_next, -GAP_DFAC);
+			}
+			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);
+			copy_v3_v3(bezt->vec[2], h2);
+			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;
+				}
+				else {
+					delta_time = gtd->tot_time + (((float)(gps->inittime - gtd->inittime)) - gtd->tot_time) * GAP_DFAC;
+				}
+				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);
+			copy_v3_v3(bezt->vec[2], h2);
+			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) {
+					delta_time = ((gps->points + 1)->time - gps->points->time) * -GAP_DFAC;
+				}
+				else {
+					delta_time = -(((float)(gps->inittime - gtd->inittime)) - gtd->tot_time) * GAP_DFAC;
+				}
+				gp_timing_data_add_point(gtd, gps->inittime, delta_time, len_v3v3(p1, p2));
+			}
+
+			old_nbezt += 2;
+			copy_v3_v3(p3d_prev, p2);
+		}
+	}
+	if (old_nbezt && do_gtd) {
+		prev_bezt = nu->bezt + old_nbezt - 1;
+	}
 	/* add points */
-	for (i = 0, bezt = nu->bezt; i < tot; i++, pt++, bezt++) {
+	for (i = stitch ? 1 : 0, bezt = nu->bezt + old_nbezt; i < tot; i++, pt++, bezt++) {
 		float h1[3], h2[3];
-		
-		if (i) interp_v3_v3v3(h1, p3d_cur, p3d_prev, 0.3);
-		else interp_v3_v3v3(h1, p3d_cur, p3d_next, -0.3);
-		
-		if (i < tot - 1) interp_v3_v3v3(h2, p3d_cur, p3d_next, 0.3);
-		else interp_v3_v3v3(h2, p3d_cur, p3d_prev, -0.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;
-		bezt->radius = bezt->weight = pt->pressure * gpl->thickness * 0.1f;
-		
+		bezt->radius = width * rad_fac;
+		bezt->weight = width;
+		CLAMP(bezt->weight, 0.0f, 1.0f);
+		if (bezt->weight < minmax_weights[0]) {
+			minmax_weights[0] = bezt->weight;
+		}
+		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);
 
-	/* add nurb to curve */
-	BLI_addtail(&cu->nurb, nu);
+	if (!curnu || !*curnu) {
+		BLI_addtail(&cu->nurb, nu);
+	}
+	if (curnu) {
+		*curnu = nu;
+	}
+}
+
+#undef GAP_DFAC
+#undef WIDTH_CORR_FAC
+#undef BEZT_HANDLE_FAC
+
+static void gp_stroke_finalize_curve_endpoints(Curve *cu)
+{
+	Nurb *nu = cu->nurb.first;
+	int i = 0;
+	if (nu->bezt) {
+		BezTriple *bezt = nu->bezt;
+		if (bezt) {
+			bezt[i].weight = bezt[i].radius = 0.0f;
+		}
+	}
+	else if (nu->bp) {
+		BPoint *bp = nu->bp;
+		if (bp) {
+			bp[i].weight = bp[i].radius = 0.0f;
+		}
+	}
+
+	nu = cu->nurb.last;
+	i = nu->pntsu - 1;
+	if (nu->bezt) {
+		BezTriple *bezt = nu->bezt;
+		if (bezt) {
+			bezt[i].weight = bezt[i].radius = 0.0f;
+		}
+	}
+	else if (nu->bp) {
+		BPoint *bp = nu->bp;
+		if (bp) {
+			bp[i].weight = bp[i].radius = 0.0f;
+		}
+	}
+}
+
+static void gp_stroke_norm_curve_weights(Curve *cu, float minmax_weights[2])
+{
+	Nurb *nu;
+	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;
+			for (i = 0; i < nu->pntsu; i++, bezt++) {
+				bezt->weight = (bezt->weight - delta) * fac;
+			}
+		}
+		else if (nu->bp) {
+			BPoint *bp = nu->bp;
+			for (i = 0; i < nu->pntsu; i++, bp++) {
+				bp->weight = (bp->weight - delta) * fac;
+			}
+		}
+	}
 }
 
 /* convert a given grease-pencil layer to a 3d-curve representation (using current view if appropriate) */
-static void gp_layer_to_curve(bContext *C, bGPdata *gpd, bGPDlayer *gpl, short mode)
+static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bGPDlayer *gpl, int mode,
+                              int norm_weights, float rad_fac, int link_strokes, tGpTimingData *gtd)
 {
 	Scene *scene = CTX_data_scene(C);
 	bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
-	bGPDstroke *gps;
+	bGPDstroke *gps, *prev_gps = NULL;
 	Object *ob;
 	Curve *cu;
+	Nurb *nu = NULL;
+	Base *base = BASACT, *newbase = NULL;
+	float minmax_weights[2] = {1.0f, 0.0f};
 
 	/* camera framing */
 	rctf subrect, *subrect_ptr = NULL;
@@ -574,7 +1272,7 @@ static void gp_layer_to_curve(bContext *C, bGPdata *gpd, bGPDlayer *gpl, short m
 	/* 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;
@@ -592,29 +1290,116 @@ static void gp_layer_to_curve(bContext *C, bGPdata *gpd, bGPDlayer *gpl, short m
 	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;
+
 	/* 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)
+				stitch = TRUE;
+		}
+		/* Decide whether we connect this stroke to previous one */
+		if (!(stitch || link_strokes))
+			nu = NULL;
 		switch (mode) {
 			case GP_STROKECONVERT_PATH: 
-				gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr);
+				gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);
 				break;
 			case GP_STROKECONVERT_CURVE:
-				gp_stroke_to_bezier(C, gpl, gps, cu, subrect_ptr);
+				gp_stroke_to_bezier(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);
 				break;
 			default:
 				BLI_assert(!"invalid mode");
 				break;
 		}
+		prev_gps = gps;
 	}
+
+	/* If link_strokes, be sure first and last points have a zero weight/size! */
+	if (link_strokes)
+		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))
+		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!!! */
+	/* set layers OK */
+	newbase = BASACT;
+	newbase->lay = base->lay;
+	ob->lay = newbase->lay;
+	/* restore, BKE_object_add sets active */
+	BASACT = base;
+	base->flag |= SELECT;
 }
 
 /* --- */
 
+/* Check a GP layer has valid timing data! Else, most timing options are hidden in the operator.
+ * op may be NULL.
+ */
+static int gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOperator *op)
+{
+	Scene *scene = CTX_data_scene(C);
+	bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
+	bGPDstroke *gps = gpf->strokes.first;
+	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;
+			/* First point of a stroke should have the same time as stroke's inittime,
+			 * so it's the only case where equality is allowed!
+			 */
+			if ((i && cur_time <= prev_time) || (cur_time < prev_time)) {
+				valid = FALSE;
+				break;
+			}
+			prev_time = cur_time;
+		}
+		if (!valid) {
+			break;
+		}
+	} while ((gps = gps->next));
+
+	if (op) {
+		RNA_boolean_set(op->ptr, "use_timing_data", valid);
+	}
+	return valid;
+}
+
+/* Check end_frame is always > start frame! */
+static void gp_convert_set_end_frame(struct Main *UNUSED(main), struct Scene *UNUSED(scene), struct PointerRNA *ptr)
+{
+	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);
+	}
+}
+
 static int gp_convert_poll(bContext *C)
 {
 	bGPdata *gpd = gpencil_data_get_active(C);
@@ -627,10 +1412,16 @@ static int gp_convert_poll(bContext *C)
 
 static int gp_convert_layer_exec(bContext *C, wmOperator *op)
 {
+	PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_timing_data");
 	bGPdata *gpd = gpencil_data_get_active(C);
 	bGPDlayer *gpl = gpencil_layer_getactive(gpd);
 	Scene *scene = CTX_data_scene(C);
 	int mode = RNA_enum_get(op->ptr, "type");
+	int norm_weights = RNA_boolean_get(op->ptr, "use_normalize_weights");
+	float rad_fac = RNA_float_get(op->ptr, "radius_multiplier");
+	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) {
@@ -638,7 +1429,36 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	}
 
-	gp_layer_to_curve(C, gpd, gpl, mode);
+	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!");
+	}
+	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)) {
+		gtd.mode = GP_STROKECONVERT_TIMING_LINEAR;
+		RNA_enum_set(op->ptr, "timing_mode", gtd.mode);
+	}
+	if (!link_strokes) {
+		gtd.mode = GP_STROKECONVERT_TIMING_NONE;
+	}
+
+	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;
+	gtd.end_frame = RNA_int_get(op->ptr, "end_frame");
+	gtd.gap_duration = RNA_float_get(op->ptr, "gap_duration");
+	gtd.gap_randomness = RNA_float_get(op->ptr, "gap_randomness");
+	gtd.gap_randomness = min_ff(gtd.gap_randomness, gtd.gap_duration);
+	gtd.seed = RNA_int_get(op->ptr, "seed");
+	gtd.num_points = gtd.cur_point = 0;
+	gtd.dists = gtd.times = NULL;
+	gtd.tot_dist = gtd.tot_time = gtd.gap_tot_time = 0.0f;
+	gtd.inittime = 0.0;
+
+	gp_layer_to_curve(C, op->reports, gpd, gpl, mode, norm_weights, rad_fac, link_strokes, &gtd);
 
 	/* notifiers */
 	WM_event_add_notifier(C, NC_OBJECT | NA_ADDED, NULL);
@@ -648,24 +1468,131 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
 	return OPERATOR_FINISHED;
 }
 
+static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
+{
+	const char *prop_id = RNA_property_identifier(prop);
+	int link_strokes = RNA_boolean_get(ptr, "use_link_strokes");
+	int timing_mode = RNA_enum_get(ptr, "timing_mode");
+	int realtime = RNA_boolean_get(ptr, "use_realtime");
+	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 ||
+	    strcmp(prop_id, "radius_multiplier") == 0 ||
+	    strcmp(prop_id, "use_link_strokes") == 0)
+	{
+		return TRUE;
+	}
+
+	/* Never show this prop */
+	if (strcmp(prop_id, "use_timing_data") == 0)
+		return FALSE;
+
+	if (link_strokes) {
+		/* 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 ||
+			    strcmp(prop_id, "start_frame") == 0)
+			{
+				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)
+					return TRUE;
+
+				/* Only show seed for randomize action! */
+				if (strcmp(prop_id, "seed") == 0 && gap_duration > 0.0f && gap_randomness > 0.0f)
+					return TRUE;
+			}
+		}
+	}
+
+	/* Else, hidden! */
+	return FALSE;
+}
+
+static void gp_convert_ui(bContext *C, wmOperator *op)
+{
+	uiLayout *layout = op->layout;
+	wmWindowManager *wm = CTX_wm_manager(C);
+	PointerRNA ptr;
+
+	RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
+
+	/* Main auto-draw call */
+	uiDefAutoButsRNA(layout, &ptr, gp_convert_draw_check_prop, '\0');
+}
+
 void GPENCIL_OT_convert(wmOperatorType *ot)
 {
+	PropertyRNA *prop;
+	
 	/* identifiers */
 	ot->name = "Convert Grease Pencil";
 	ot->idname = "GPENCIL_OT_convert";
-	ot->description = "Convert the active Grease Pencil layer to a new Object";
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+	ot->description = "Convert the active Grease Pencil layer to a new Curve Object";
 	
 	/* callbacks */
 	ot->invoke = WM_menu_invoke;
 	ot->exec = gp_convert_layer_exec;
 	ot->poll = gp_convert_poll;
+	ot->ui = gp_convert_ui;
 	
 	/* flags */
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 	
 	/* properties */
-	ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_convertmodes, 0, "Type", "");
+	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, 10.0f, "Radius Fac",
+	              "Multiplier for the points' radii (set from stroke width)", 0.0f, 1000.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",
+	            "The start frame of the path control curve", 1, 100000);
+	RNA_def_boolean(ot->srna, "use_realtime", FALSE, "Realtime",
+	                "Whether the path control curve reproduces the drawing in realtime, starting from Start Frame");
+	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, 1000.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, 10000.0f);
+	RNA_def_float(ot->srna, "gap_randomness", 0.0f, 0.0f, 100.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, 100, "Random Seed",
+	            "Custom Gap mode: Random generator seed", 0, 1000);
+	/* 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)");
+	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }
 
 /* ************************************************ */
diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c
index 9bfd89075af..fa681ae2f70 100644
--- a/source/blender/editors/gpencil/gpencil_paint.c
+++ b/source/blender/editors/gpencil/gpencil_paint.c
@@ -39,6 +39,8 @@
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
 
+#include "PIL_time.h"
+
 #include "BKE_gpencil.h"
 #include "BKE_context.h"
 #include "BKE_global.h"
@@ -99,6 +101,14 @@ typedef struct tGPsdata {
 	short radius;       /* radius of influence for eraser */
 	short flags;        /* flags that can get set during runtime */
 
+	/* Those needs to be doubles, as (at least under unix) they are in seconds since epoch,
+	 * float (and its 7 digits precision) is definitively not enough here!
+	 * double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least.
+	 */
+	double inittime;    /* Used when converting to path */
+	double curtime;     /* Used when converting to path */
+	double ocurtime;    /* Used when converting to path */
+
 	float imat[4][4];   /* inverted transformation matrix applying when converting coords from screen-space
 	                     * to region space */
 	
@@ -201,7 +211,7 @@ static void gp_get_3d_reference(tGPsdata *p, float vec[3])
 	float *fp = give_cursor(p->scene, v3d);
 	
 	/* the reference point used depends on the owner... */
-#if 0 // XXX: disabled for now, since we can't draw relative to the owner yet
+#if 0 /* XXX: disabled for now, since we can't draw relative to the owner yet */
 	if (p->ownerPtr.type == &RNA_Object) {
 		Object *ob = (Object *)p->ownerPtr.data;
 		
@@ -249,7 +259,7 @@ static short gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2])
 }
 
 /* convert screen-coordinates to buffer-coordinates */
-// XXX this method needs a total overhaul!
+/* XXX this method needs a total overhaul! */
 static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3], float *depth)
 {
 	bGPdata *gpd = p->gpd;
@@ -310,7 +320,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3]
 }
 
 /* add current stroke-point to buffer (returns whether point was successfully added) */
-static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
+static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, double curtime)
 {
 	bGPdata *gpd = p->gpd;
 	tGPspoint *pt;
@@ -325,6 +335,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 			/* store settings */
 			copy_v2_v2_int(&pt->x, mval);
 			pt->pressure = pressure;
+			pt->time = (float)(curtime - p->inittime);
 			
 			/* increment buffer size */
 			gpd->sbuffer_size++;
@@ -338,6 +349,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 			/* store settings */
 			copy_v2_v2_int(&pt->x, mval);
 			pt->pressure = pressure;
+			pt->time = (float)(curtime - p->inittime);
 			
 			/* if this is just the second point we've added, increment the buffer size
 			 * so that it will be drawn properly...
@@ -361,6 +373,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 		/* store settings */
 		copy_v2_v2_int(&pt->x, mval);
 		pt->pressure = pressure;
+		pt->time = (float)(curtime - p->inittime);
 		
 		/* increment counters */
 		gpd->sbuffer_size++;
@@ -378,10 +391,11 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 		/* store settings */
 		copy_v2_v2_int(&pt->x, mval);
 		pt->pressure = pressure;
+		pt->time = (float)(curtime - p->inittime);
 		
 		/* if there's stroke for this poly line session add (or replace last) point
 		 * to stroke. This allows to draw lines more interactively (see new segment
-		 * during mouse slide, i.e.) 
+		 * during mouse slide, e.g.)
 		 */
 		if (gp_stroke_added_check(p)) {
 			bGPDstroke *gps = p->gpf->strokes.last;
@@ -410,8 +424,9 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 			/* convert screen-coordinates to appropriate coordinates (and store them) */
 			gp_stroke_convertcoords(p, &pt->x, &pts->x, NULL);
 			
-			/* copy pressure */
+			/* copy pressure and time */
 			pts->pressure = pt->pressure;
+			pts->time = pt->time;
 		}
 		
 		/* increment counters */
@@ -425,18 +440,11 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure)
 	return GP_STROKEADD_INVALID;
 }
 
-
-/* temp struct for gp_stroke_smooth() */
-typedef struct tGpSmoothCo {
-	int x;
-	int y;
-} tGpSmoothCo;
-
 /* smooth a stroke (in buffer) before storing it */
 static void gp_stroke_smooth(tGPsdata *p)
 {
 	bGPdata *gpd = p->gpd;
-	tGpSmoothCo *smoothArray, *spc;
+	tGPspoint *spt, tmp_spt[3];
 	int i = 0, cmx = gpd->sbuffer_size;
 	
 	/* only smooth if smoothing is enabled, and we're not doing a straight line */
@@ -447,30 +455,26 @@ static void gp_stroke_smooth(tGPsdata *p)
 	if ((cmx <= 2) || (gpd->sbuffer == NULL))
 		return;
 	
-	/* create a temporary smoothing coordinates buffer, use to store calculated values to prevent sequential error */
-	smoothArray = MEM_callocN(sizeof(tGpSmoothCo) * cmx, "gp_stroke_smooth smoothArray");
-	
-	/* first pass: calculate smoothing coordinates using weighted-averages */
-	for (i = 0, spc = smoothArray; i < gpd->sbuffer_size; i++, spc++) {
-		const tGPspoint *pc = (((tGPspoint *)gpd->sbuffer) + i);
-		const tGPspoint *pb = (i - 1 > 0) ? (pc - 1) : (pc);
-		const tGPspoint *pa = (i - 2 > 0) ? (pc - 2) : (pb);
-		const tGPspoint *pd = (i + 1 < cmx) ? (pc + 1) : (pc);
+	/* Calculate smoothing coordinates using weighted-averages */
+	/* XXX DO NOT smooth first and last points! */
+	spt = (tGPspoint *)gpd->sbuffer;
+	/* This small array stores the last two points' org coordinates, we don't want to use already averaged ones!
+	 * Note it is used as a cyclic buffer...
+	 */
+	tmp_spt[0] = *spt;
+	for (i = 1, spt++; i < cmx - 1; i++, spt++) {
+		const tGPspoint *pc = spt;
+		const tGPspoint *pb = &tmp_spt[(i - 1) % 3];
+		const tGPspoint *pa = (i - 1 > 0) ? (&tmp_spt[(i - 2) % 3]) : (pb);
+		const tGPspoint *pd = pc + 1;
 		const tGPspoint *pe = (i + 2 < cmx) ? (pc + 2) : (pd);
 		
-		spc->x = (int)(0.1 * pa->x + 0.2 * pb->x + 0.4 * pc->x + 0.2 * pd->x + 0.1 * pe->x);
-		spc->y = (int)(0.1 * pa->y + 0.2 * pb->y + 0.4 * pc->y + 0.2 * pd->y + 0.1 * pe->y);
-	}
-	
-	/* second pass: apply smoothed coordinates */
-	for (i = 0, spc = smoothArray; i < gpd->sbuffer_size; i++, spc++) {
-		tGPspoint *pc = (((tGPspoint *)gpd->sbuffer) + i);
+		/* Store current point's org state for the two next points! */
+		tmp_spt[i % 3] = *spt;
 		
-		copy_v2_v2_int(&pc->x, &spc->x);
+		spt->x = (int)(0.1 * pa->x + 0.2 * pb->x + 0.4 * pc->x + 0.2 * pd->x + 0.1 * pe->x);
+		spt->y = (int)(0.1 * pa->y + 0.2 * pb->y + 0.4 * pc->y + 0.2 * pd->y + 0.1 * pe->y);
 	}
-	
-	/* free temp array */
-	MEM_freeN(smoothArray);
 }
 
 /* simplify a stroke (in buffer) before storing it 
@@ -492,7 +496,7 @@ static void gp_stroke_simplify(tGPsdata *p)
 	/* don't simplify if less than 4 points in buffer */
 	if ((num_points <= 4) || (old_points == NULL))
 		return;
-		
+	
 	/* clear buffer (but don't free mem yet) so that we can write to it 
 	 *	- firstly set sbuffer to NULL, so a new one is allocated
 	 *	- secondly, reset flag after, as it gets cleared auto
@@ -509,17 +513,21 @@ static void gp_stroke_simplify(tGPsdata *p)
 		co[0] += (float)(old_points[offs].x * sfac); \
 		co[1] += (float)(old_points[offs].y * sfac); \
 		pressure += old_points[offs].pressure * sfac; \
+		time += old_points[offs].time * sfac; \
 	} (void)0
 	
+	/* XXX Here too, do not lose start and end points! */
+	gp_stroke_addpoint(p, &old_points->x, old_points->pressure, p->inittime + (double)old_points->time);
 	for (i = 0, j = 0; i < num_points; i++) {
 		if (i - j == 3) {
-			float co[2], pressure;
+			float co[2], pressure, time;
 			int mco[2];
 			
 			/* initialize values */
-			co[0] = 0;
-			co[1] = 0;
-			pressure = 0;
+			co[0] = 0.0f;
+			co[1] = 0.0f;
+			pressure = 0.0f;
+			time = 0.0f;
 			
 			/* using macro, calculate new point */
 			GP_SIMPLIFY_AVPOINT(j, -0.25f);
@@ -532,11 +540,13 @@ static void gp_stroke_simplify(tGPsdata *p)
 			mco[1] = (int)co[1];
 			
 			/* ignore return values on this... assume to be ok for now */
-			gp_stroke_addpoint(p, mco, pressure);
+			gp_stroke_addpoint(p, mco, pressure, p->inittime + (double)time);
 			
 			j += 2;
 		}
 	}
+	gp_stroke_addpoint(p, &old_points[num_points - 1].x, old_points[num_points - 1].pressure,
+	                   p->inittime + (double)old_points[num_points - 1].time);
 	
 	/* free old buffer */
 	MEM_freeN(old_points);
@@ -571,7 +581,8 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 	
 	/* special case for poly line -- for already added stroke during session
 	 * coordinates are getting added to stroke immediately to allow more
-	 * interactive behavior */
+	 * interactive behavior
+	 */
 	if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
 		if (gp_stroke_added_check(p)) {
 			return;
@@ -585,6 +596,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 	gps->totpoints = totelem;
 	gps->thickness = p->gpl->thickness;
 	gps->flag = gpd->sbuffer_sflag;
+	gps->inittime = p->inittime;
 	
 	/* allocate enough memory for a continuous array for storage points */
 	gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
@@ -602,8 +614,9 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 			/* convert screen-coordinates to appropriate coordinates (and store them) */
 			gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 			
-			/* copy pressure */
+			/* copy pressure and time */
 			pt->pressure = ptc->pressure;
+			pt->time = ptc->time;
 			
 			pt++;
 		}
@@ -615,8 +628,9 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 			/* convert screen-coordinates to appropriate coordinates (and store them) */
 			gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 			
-			/* copy pressure */
+			/* copy pressure and time */
 			pt->pressure = ptc->pressure;
+			pt->time = ptc->time;
 		}
 	}
 	else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
@@ -626,8 +640,9 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 		/* convert screen-coordinates to appropriate coordinates (and store them) */
 		gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL);
 		
-		/* copy pressure */
+		/* copy pressure and time */
 		pt->pressure = ptc->pressure;
+		pt->time = ptc->time;
 	}
 	else {
 		float *depth_arr = NULL;
@@ -699,8 +714,9 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
 			/* convert screen-coordinates to appropriate coordinates (and store them) */
 			gp_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr + i : NULL);
 			
-			/* copy pressure */
+			/* copy pressure and time */
 			pt->pressure = ptc->pressure;
+			pt->time = ptc->time;
 		}
 		
 		if (depth_arr)
@@ -750,6 +766,25 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
 		gps->totpoints--;
 		gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
 		memcpy(gps->points, pt_tmp + 1, sizeof(bGPDspoint) * gps->totpoints);
+
+		/* We must adjust timings!
+		 * Each point's timing data is a delta from stroke's inittime, so as we erase the first
+		 * point of the stroke, we have to offset this inittime and all remaing points' delta values.
+		 * This way we get a new stroke with exactly the same timing as if user had started drawing from
+		 * the second point...
+		 */
+		{
+			bGPDspoint *pts;
+			float delta = pt_tmp[1].time;
+			int j;
+
+			gps->inittime += delta;
+
+			pts = gps->points;
+			for (j = 0; j < gps->totpoints; j++, pts++) {
+				pts->time -= delta;
+			}
+		}
 		
 		/* free temp buffer */
 		MEM_freeN(pt_tmp);
@@ -769,6 +804,25 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
 		gsn->points = MEM_callocN(sizeof(bGPDspoint) * gsn->totpoints, "gp_stroke_points");
 		memcpy(gsn->points, pt_tmp + i, sizeof(bGPDspoint) * gsn->totpoints);
 		
+		/* We must adjust timings of this new stroke!
+		 * Each point's timing data is a delta from stroke's inittime, so as we erase the first
+		 * point of the stroke, we have to offset this inittime and all remaing points' delta values.
+		 * This way we get a new stroke with exactly the same timing as if user had started drawing from
+		 * the second point...
+		 */
+		{
+			bGPDspoint *pts;
+			float delta = pt_tmp[i].time;
+			int j;
+
+			gsn->inittime += delta;
+
+			pts = gsn->points;
+			for (j = 0; j < gsn->totpoints; j++, pts++) {
+				pts->time -= delta;
+			}
+		}
+
 		/* adjust existing stroke  */
 		gps->totpoints = i;
 		gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
@@ -831,7 +885,7 @@ static void gp_point_to_xy(ARegion *ar, View2D *v2d, rctf *subrect, bGPDstroke *
 
 
 /* eraser tool - evaluation per stroke */
-// TODO: this could really do with some optimization (KD-Tree/BVH?)
+/* TODO: this could really do with some optimization (KD-Tree/BVH?) */
 static void gp_stroke_eraser_dostroke(tGPsdata *p,
                                       const int mval[], const int mvalo[],
                                       short rad, const rcti *rect, bGPDframe *gpf, bGPDstroke *gps)
@@ -919,11 +973,11 @@ static void gp_session_validatebuffer(tGPsdata *p)
 	
 	/* clear memory of buffer (or allocate it if starting a new session) */
 	if (gpd->sbuffer) {
-		//printf("\t\tGP - reset sbuffer\n");
+		/* printf("\t\tGP - reset sbuffer\n"); */
 		memset(gpd->sbuffer, 0, sizeof(tGPspoint) * GP_STROKE_BUFFER_MAX);
 	}
 	else {
-		//printf("\t\tGP - allocate sbuffer\n");
+		/* printf("\t\tGP - allocate sbuffer\n"); */
 		gpd->sbuffer = MEM_callocN(sizeof(tGPspoint) * GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer");
 	}
 	
@@ -932,6 +986,9 @@ static void gp_session_validatebuffer(tGPsdata *p)
 	
 	/* reset flags */
 	gpd->sbuffer_sflag = 0;
+
+	/* reset inittime */
+	p->inittime = 0.0;
 }
 
 /* (re)init new painting data */
@@ -959,8 +1016,8 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
 		/* supported views first */
 		case SPACE_VIEW3D:
 		{
-			// View3D *v3d = curarea->spacedata.first;
-			// RegionView3D *rv3d = ar->regiondata;
+			/* View3D *v3d = curarea->spacedata.first; */
+			/* RegionView3D *rv3d = ar->regiondata; */
 			
 			/* set current area 
 			 *	- must verify that region data is 3D-view (and not something else)
@@ -979,7 +1036,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
 
 		case SPACE_NODE:
 		{
-			//SpaceNode *snode = curarea->spacedata.first;
+			/* SpaceNode *snode = curarea->spacedata.first; */
 			
 			/* set current area */
 			p->sa = curarea;
@@ -1007,7 +1064,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
 		break;
 		case SPACE_IMAGE:
 		{
-			//SpaceImage *sima = curarea->spacedata.first;
+			/* SpaceImage *sima = curarea->spacedata.first; */
 			
 			/* set the current area */
 			p->sa = curarea;
@@ -1072,7 +1129,8 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
 	
 	if (ED_gpencil_session_active() == 0) {
 		/* initialize undo stack,
-		 * also, existing undo stack would make buffer drawn */
+		 * also, existing undo stack would make buffer drawn
+		 */
 		gpencil_undo_init(p->gpd);
 	}
 	
@@ -1107,7 +1165,7 @@ static void gp_session_cleanup(tGPsdata *p)
 	
 	/* free stroke buffer */
 	if (gpd->sbuffer) {
-		//printf("\t\tGP - free sbuffer\n");
+		/* printf("\t\tGP - free sbuffer\n"); */
 		MEM_freeN(gpd->sbuffer);
 		gpd->sbuffer = NULL;
 	}
@@ -1115,6 +1173,7 @@ static void gp_session_cleanup(tGPsdata *p)
 	/* clear flags */
 	gpd->sbuffer_size = 0;
 	gpd->sbuffer_sflag = 0;
+	p->inittime = 0.0;
 }
 
 /* init new stroke */
@@ -1259,7 +1318,8 @@ static void gp_paint_strokeend(tGPsdata *p)
 static void gp_paint_cleanup(tGPsdata *p)
 {
 	/* p->gpd==NULL happens when stroke failed to initialize,
-	 * for example. when GP is hidden in current space (sergey) */
+	 * for example when GP is hidden in current space (sergey)
+	 */
 	if (p->gpd) {
 		/* finish off a stroke */
 		gp_paint_strokeend(p);
@@ -1307,7 +1367,7 @@ static void gpencil_draw_toggle_eraser_cursor(bContext *C, tGPsdata *p, short en
 	else if (enable) {
 		/* enable cursor */
 		p->erasercursor = WM_paint_cursor_activate(CTX_wm_manager(C), 
-		                                           NULL, // XXX
+		                                           NULL, /* XXX */
 		                                           gpencil_draw_eraser, p);
 	}
 }
@@ -1448,16 +1508,26 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p)
 	/* only add current point to buffer if mouse moved (even though we got an event, it might be just noise) */
 	else if (gp_stroke_filtermval(p, p->mval, p->mvalo)) {
 		/* try to add point */
-		short ok = gp_stroke_addpoint(p, p->mval, p->pressure);
+		short ok = gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
 		
 		/* handle errors while adding point */
 		if ((ok == GP_STROKEADD_FULL) || (ok == GP_STROKEADD_OVERFLOW)) {
 			/* finish off old stroke */
 			gp_paint_strokeend(p);
+			/* And start a new one!!! Else, projection errors! */
+			gp_paint_initstroke(p, p->paintmode);
 			
 			/* start a new stroke, starting from previous point */
-			gp_stroke_addpoint(p, p->mvalo, p->opressure);
-			gp_stroke_addpoint(p, p->mval, p->pressure);
+			/* XXX Must manually reset inittime... */
+			/* XXX We only need to reuse previous point if overflow! */
+			if (ok == GP_STROKEADD_OVERFLOW) {
+				p->inittime = p->ocurtime;
+				gp_stroke_addpoint(p, p->mvalo, p->opressure, p->ocurtime);
+			}
+			else {
+				p->inittime = p->curtime;
+			}
+			gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime);
 		}
 		else if (ok == GP_STROKEADD_INVALID) {
 			/* the painting operation cannot continue... */
@@ -1473,6 +1543,7 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p)
 		p->mvalo[0] = p->mval[0];
 		p->mvalo[1] = p->mval[1];
 		p->opressure = p->pressure;
+		p->ocurtime = p->curtime;
 	}
 }
 
@@ -1485,10 +1556,11 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
 	int tablet = 0;
 
 	/* convert from window-space to area-space mouse coordinates
-	 * NOTE: float to ints conversions, +1 factor is probably used to ensure a bit more accurate rounding... 
+	 * NOTE: float to ints conversions, +1 factor is probably used to ensure a bit more accurate rounding...
 	 */
 	p->mval[0] = event->mval[0] + 1;
 	p->mval[1] = event->mval[1] + 1;
+	p->curtime = PIL_check_seconds_timer();
 
 	/* handle pressure sensitivity (which is supplied by tablets) */
 	if (event->custom == EVT_DATA_TABLET) {
@@ -1497,8 +1569,8 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
 		tablet = (wmtab->Active != EVT_TABLET_NONE);
 		p->pressure = wmtab->Pressure;
 		
-		//if (wmtab->Active == EVT_TABLET_ERASER)
-		// TODO... this should get caught by the keymaps which call drawing in the first place
+		/* if (wmtab->Active == EVT_TABLET_ERASER) */
+		/* TODO... this should get caught by the keymaps which call drawing in the first place */
 	}
 	else
 		p->pressure = 1.0f;
@@ -1519,14 +1591,17 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
 		p->mvalo[0] = p->mval[0];
 		p->mvalo[1] = p->mval[1];
 		p->opressure = p->pressure;
-		
+		p->inittime = p->ocurtime = p->curtime;
+
 		/* special exception here for too high pressure values on first touch in
-		 *  windows for some tablets, then we just skip first touch ..  
+		 *  windows for some tablets, then we just skip first touch...
 		 */
 		if (tablet && (p->pressure >= 0.99f))
 			return;
 	}
 	
+	RNA_float_set(&itemptr, "time", p->curtime - p->inittime);
+
 	/* apply the current latest drawing point */
 	gpencil_draw_apply(op, p);
 	
@@ -1541,18 +1616,18 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
 {
 	tGPsdata *p = NULL;
 	
-	//printf("GPencil - Starting Re-Drawing\n");
+	/* printf("GPencil - Starting Re-Drawing\n"); */
 	
 	/* try to initialize context data needed while drawing */
 	if (!gpencil_draw_init(C, op)) {
 		if (op->customdata) MEM_freeN(op->customdata);
-		//printf("\tGP - no valid data\n");
+		/* printf("\tGP - no valid data\n"); */
 		return OPERATOR_CANCELLED;
 	}
 	else
 		p = op->customdata;
 	
-	//printf("\tGP - Start redrawing stroke\n");
+	/* printf("\tGP - Start redrawing stroke\n"); */
 	
 	/* loop over the stroke RNA elements recorded (i.e. progress of mouse movement),
 	 * setting the relevant values in context at each step, then applying
@@ -1561,20 +1636,21 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
 	{
 		float mousef[2];
 		
-		//printf("\t\tGP - stroke elem\n");
+		/* printf("\t\tGP - stroke elem\n"); */
 		
 		/* get relevant data for this point from stroke */
 		RNA_float_get_array(&itemptr, "mouse", mousef);
 		p->mval[0] = (int)mousef[0];
 		p->mval[1] = (int)mousef[1];
 		p->pressure = RNA_float_get(&itemptr, "pressure");
+		p->curtime = (double)RNA_float_get(&itemptr, "time") + p->inittime;
 		
 		if (RNA_boolean_get(&itemptr, "is_start")) {
 			/* if first-run flag isn't set already (i.e. not true first stroke),
 			 * then we must terminate the previous one first before continuing
 			 */
 			if ((p->flags & GP_PAINTFLAG_FIRSTRUN) == 0) {
-				// TODO: both of these ops can set error-status, but we probably don't need to worry
+				/* TODO: both of these ops can set error-status, but we probably don't need to worry */
 				gp_paint_strokeend(p);
 				gp_paint_initstroke(p, p->paintmode);
 			}
@@ -1587,6 +1663,7 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
 			p->mvalo[0] = p->mval[0];
 			p->mvalo[1] = p->mval[1];
 			p->opressure = p->pressure;
+			p->ocurtime = p->curtime;
 		}
 		
 		/* apply this data as necessary now (as per usual) */
@@ -1594,7 +1671,7 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op)
 	}
 	RNA_END;
 	
-	//printf("\tGP - done\n");
+	/* printf("\tGP - done\n"); */
 	
 	/* cleanup */
 	gpencil_draw_exit(C, op);
@@ -1640,7 +1717,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, wmEvent *event)
 	
 	/* set cursor */
 	if (p->paintmode == GP_PAINTMODE_ERASER)
-		WM_cursor_modal(win, BC_CROSSCURSOR);  // XXX need a better cursor
+		WM_cursor_modal(win, BC_CROSSCURSOR);  /* XXX need a better cursor */
 	else
 		WM_cursor_modal(win, BC_PAINTBRUSHCURSOR);
 	
@@ -1650,7 +1727,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, wmEvent *event)
 	 */
 	if (event->val == KM_PRESS) {
 		/* hotkey invoked - start drawing */
-		//printf("\tGP - set first spot\n");
+		/* printf("\tGP - set first spot\n"); */
 		p->status = GP_STATUS_PAINTING;
 		
 		/* handle the initial drawing - i.e. for just doing a simple dot */
@@ -1658,7 +1735,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, wmEvent *event)
 	}
 	else {
 		/* toolbar invoked - don't start drawing yet... */
-		//printf("\tGP - hotkey invoked... waiting for click-drag\n");
+		/* printf("\tGP - hotkey invoked... waiting for click-drag\n"); */
 	}
 	
 	WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
@@ -1686,7 +1763,7 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
 		p->status = GP_STATUS_ERROR;
 	}
 
-	//printf("\t\tGP - start stroke\n");
+	/* printf("\t\tGP - start stroke\n"); */
 
 	/* we may need to set up paint env again if we're resuming */
 	/* XXX: watch it with the paintmode! in future,
@@ -1735,16 +1812,17 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 	 * the stroke is converted to 3D only after
 	 * it is finished. This approach should work
 	 * better in tools that immediately apply
-	 * in 3D space. */
+	 * in 3D space.
+	 */
 
-	//printf("\tGP - handle modal event...\n");
+	/* printf("\tGP - handle modal event...\n"); */
 	
 	/* exit painting mode (and/or end current stroke) 
 	 * NOTE: cannot do RIGHTMOUSE (as is standard for cancelling) as that would break polyline [#32647] 
 	 */
 	if (ELEM4(event->type, RETKEY, PADENTER, ESCKEY, SPACEKEY)) {
 		/* exit() ends the current stroke before cleaning up */
-		//printf("\t\tGP - end of paint op + end of stroke\n");
+		/* printf("\t\tGP - end of paint op + end of stroke\n"); */
 		p->status = GP_STATUS_DONE;
 		estate = OPERATOR_FINISHED;
 	}
@@ -1768,7 +1846,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 			
 			if (sketch) {
 				/* end stroke only, and then wait to resume painting soon */
-				//printf("\t\tGP - end stroke only\n");
+				/* printf("\t\tGP - end stroke only\n"); */
 				gpencil_stroke_end(op);
 				
 				/* we've just entered idling state, so this event was processed (but no others yet) */
@@ -1778,7 +1856,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 				WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
 			}
 			else {
-				//printf("\t\tGP - end of stroke + op\n");
+				/* printf("\t\tGP - end of stroke + op\n"); */
 				p->status = GP_STATUS_DONE;
 				estate = OPERATOR_FINISHED;
 			}
@@ -1801,7 +1879,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 		/* handle painting mouse-movements? */
 		if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE) || (p->flags & GP_PAINTFLAG_FIRSTRUN)) {
 			/* handle drawing event */
-			//printf("\t\tGP - add point\n");
+			/* printf("\t\tGP - add point\n"); */
 			gpencil_draw_apply_event(op, event);
 			
 			/* finish painting operation if anything went wrong just now */
@@ -1811,7 +1889,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 			}
 			else {
 				/* event handled, so just tag as running modal */
-				//printf("\t\t\t\tGP - add point handled!\n");
+				/* printf("\t\t\t\tGP - add point handled!\n"); */
 				estate = OPERATOR_RUNNING_MODAL;
 			}
 		}
@@ -1822,7 +1900,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
 			/* just resize the brush (local version)
 			 * TODO: fix the hardcoded size jumps (set to make a visible difference) and hardcoded keys
 			 */
-			//printf("\t\tGP - resize eraser\n");
+			/* printf("\t\tGP - resize eraser\n"); */
 			switch (event->type) {
 				case WHEELUPMOUSE: /* larger */
 				case PADPLUSKEY: