GPencil: Picky whitespace cleanup

1 files changed, 159 insertions, 159 deletions

diff --git a/source/blender/editors/gpencil/drawgpencil.c b/source/blender/editors/gpencil/drawgpencil.c
index 4af41a56e8f..174e7b609ce 100644
--- a/source/blender/editors/gpencil/drawgpencil.c
+++ b/source/blender/editors/gpencil/drawgpencil.c
@@ -27,6 +27,7 @@
  *  \ingroup edgpencil
  */
 
+
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -92,15 +93,15 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
 {
 	tGPspoint *pt;
 	int i;
-	
+
 	/* error checking */
 	if ((points == NULL) || (totpoints <= 0))
 		return;
-	
+
 	/* check if buffer can be drawn */
 	if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D))
 		return;
-	
+
 	/* if drawing a single point, draw it larger */
 	if (totpoints == 1) {
 		/* draw point */
@@ -113,7 +114,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
 	}
 	else {
 		float oldpressure = points[0].pressure;
-		
+
 		/* draw stroke curve */
 		if (G.debug & G_DEBUG) setlinestyle(2);
 
@@ -128,13 +129,13 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
 				glEnd();
 				glLineWidth(pt->pressure * thickness);
 				glBegin(GL_LINE_STRIP);
-				
+
 				/* need to roll-back one point to ensure that there are no gaps in the stroke */
 				if (i != 0) glVertex2iv(&(pt - 1)->x);
 
 				/* now the point we want... */
 				glVertex2iv(&pt->x);
-				
+
 				oldpressure = pt->pressure;
 			}
 			else
@@ -144,7 +145,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn
 
 		/* reset for predictable OpenGL context */
 		glLineWidth(1.0f);
-		
+
 		if (G.debug & G_DEBUG) setlinestyle(0);
 	}
 }
@@ -161,14 +162,14 @@ static void gp_calc_2d_stroke_xy(bGPDspoint *pt, short sflag, int offsx, int off
 	else if (sflag & GP_STROKE_2DIMAGE) {
 		const float x = (float)((pt->x * winx) + offsx);
 		const float y = (float)((pt->y * winy) + offsy);
-		
+
 		r_co[0] = x;
 		r_co[1] = y;
 	}
 	else {
 		const float x = (float)(pt->x / 100 * winx) + offsx;
 		const float y = (float)(pt->y / 100 * winy) + offsy;
-		
+
 		r_co[0] = x;
 		r_co[1] = y;
 	}
@@ -184,39 +185,39 @@ static void gp_draw_stroke_volumetric_buffer(tGPspoint *points, int totpoints, s
 {
 	GLUquadricObj *qobj = gluNewQuadric();
 	float modelview[4][4];
-	
+
 	tGPspoint *pt;
 	int i;
-	
+
 	/* error checking */
 	if ((points == NULL) || (totpoints <= 0))
 		return;
-	
+
 	/* check if buffer can be drawn */
 	if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D))
 		return;
-	
+
 	/* get basic matrix - should be camera space (i.e "identity") */
 	glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview);
-	
+
 	/* draw points */
 	glPushMatrix();
-	
+
 	for (i = 0, pt = points; i < totpoints; i++, pt++) {
 		/* set the transformed position */
 		// TODO: scale should change based on zoom level, which requires proper translation mult too!
 		modelview[3][0] = pt->x;
 		modelview[3][1] = pt->y;
-		
+
 		glLoadMatrixf((float *)modelview);
-		
+
 		/* draw the disk using the current state... */
 		gluDisk(qobj, 0.0,  pt->pressure * thickness, 32, 1);
-		
-		
+
+
 		modelview[3][0] = modelview[3][1] = 0.0f;
 	}
-	
+
 	glPopMatrix();
 	gluDeleteQuadric(qobj);
 }
@@ -230,10 +231,10 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor
 	float modelview[4][4];
 	float baseloc[3];
 	float scalefac = 1.0f;
-	
+
 	bGPDspoint *pt;
 	int i;
-	
+
 	
 	/* HACK: We need a scale factor for the drawing in the image editor,
 	 * which seems to use 1 unit as it's maximum size, whereas everything
@@ -242,30 +243,30 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor
 	if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
 		scalefac = 0.001f;
 	}
-	
+
 	/* get basic matrix */
 	glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview);
 	copy_v3_v3(baseloc, modelview[3]);
-	
+
 	/* draw points */
 	glPushMatrix();
-	
+
 	for (i = 0, pt = points; i < totpoints; i++, pt++) {
 		/* set the transformed position */
 		float co[2];
-		
+
 		gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
 		translate_m4(modelview, co[0], co[1], 0.0f);
-		
+
 		glLoadMatrixf((float *)modelview);
-		
+
 		/* draw the disk using the current state... */
 		gluDisk(qobj, 0.0,  pt->pressure * thickness * scalefac, 32, 1);
-		
+
 		/* restore matrix */
 		copy_v3_v3(modelview[3], baseloc);
 	}
-	
+
 	glPopMatrix();
 	gluDeleteQuadric(qobj);
 }
@@ -275,48 +276,48 @@ static void gp_draw_stroke_volumetric_3d(bGPDspoint *points, int totpoints, shor
                                          short UNUSED(dflag), short UNUSED(sflag))
 {
 	GLUquadricObj *qobj = gluNewQuadric();
-	
+
 	float base_modelview[4][4], modelview[4][4];
 	float base_loc[3];
-	
+
 	bGPDspoint *pt;
 	int i;
-	
+
 	
 	/* Get the basic modelview matrix we use for performing calculations */
 	glGetFloatv(GL_MODELVIEW_MATRIX, (float *)base_modelview);
 	copy_v3_v3(base_loc, base_modelview[3]);
-	
+
 	/* Create the basic view-aligned billboard matrix we're going to actually draw qobj with:
-	 * - We need to knock out the rotation so that we are 
+	 * - We need to knock out the rotation so that we are
 	 *   simply left with a camera-facing billboard
 	 * - The scale factors here are chosen so that the thickness
 	 *   is relatively reasonable. Otherwise, it gets far too
 	 *   large!
 	 */
 	scale_m4_fl(modelview, 0.1f);
-	
+
 	/* draw each point as a disk... */
 	glPushMatrix();
-	
+
 	for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
 		/* apply translation to base_modelview, so that the translated point is put in the right place */
 		translate_m4(base_modelview, pt->x, pt->y, pt->z);
-		
+
 		/* copy the translation component to the billboard matrix we're going to use,
 		 * then reset the base matrix to the original values so that we can do the same
 		 * for the next point without accumulation/pollution effects
 		 */
 		copy_v3_v3(modelview[3], base_modelview[3]); /* copy offset value */
 		copy_v3_v3(base_modelview[3], base_loc);     /* restore */
-		
+
 		/* apply our billboard matrix for drawing... */
 		glLoadMatrixf((float *)modelview);
-		
+
 		/* draw the disk using the current state... */
 		gluDisk(qobj, 0.0,  pt->pressure * thickness, 32, 1);
 	}
-	
+
 	glPopMatrix();
 	gluDeleteQuadric(qobj);
 }
@@ -331,28 +332,28 @@ static void gp_draw_stroke_fill(bGPDspoint *points, int totpoints, short UNUSED(
 {
 	bGPDspoint *pt;
 	int i;
-	
+
 	BLI_assert(totpoints >= 3);
-	
-	/* As an initial implementation, we use the OpenGL filled polygon drawing 
+
+	/* As an initial implementation, we use the OpenGL filled polygon drawing
 	 * here since it's the easiest option to implement for this case. It does
 	 * come with limitations (notably for concave shapes), though it shouldn't
 	 * be much of an issue in most cases.
 	 */
 	glBegin(GL_POLYGON);
-	
+
 	for (i = 0, pt = points; i < totpoints; i++, pt++) {
 		if (sflag & GP_STROKE_3DSPACE) {
 			glVertex3fv(&pt->x);
 		}
 		else {
 			float co[2];
-			
+
 			gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
 			glVertex2fv(co);
 		}
 	}
-	
+
 	glEnd();
 }
 
@@ -370,10 +371,10 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla
 	}
 	else {
 		float co[2];
-		
+
 		/* get coordinates of point */
 		gp_calc_2d_stroke_xy(points, sflag, offsx, offsy, winx, winy, co);
-		
+
 		/* if thickness is less than GP_DRAWTHICKNESS_SPECIAL, simple dot looks ok
 		 *  - also mandatory in if Image Editor 'image-based' dot
 		 */
@@ -386,15 +387,15 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla
 		}
 		else {
 			/* draw filled circle as is done in circf (but without the matrix push/pops which screwed things up) */
-			GLUquadricObj *qobj = gluNewQuadric(); 
-			
-			gluQuadricDrawStyle(qobj, GLU_FILL); 
-			
+			GLUquadricObj *qobj = gluNewQuadric();
+
+			gluQuadricDrawStyle(qobj, GLU_FILL);
+
 			/* need to translate drawing position, but must reset after too! */
 			glTranslatef(co[0], co[1], 0.0);
-			gluDisk(qobj, 0.0,  thickness, 32, 1); 
+			gluDisk(qobj, 0.0,  thickness, 32, 1);
 			glTranslatef(-co[0], -co[1], 0.0);
-			
+
 			gluDeleteQuadric(qobj);
 		}
 	}
@@ -406,7 +407,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
 	bGPDspoint *pt;
 	float curpressure = points[0].pressure;
 	int i;
-	
+
 	/* draw stroke curve */
 	glLineWidth(curpressure * thickness);
 	glBegin(GL_LINE_STRIP);
@@ -420,10 +421,10 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
 			curpressure = pt->pressure;
 			glLineWidth(curpressure * thickness);
 			glBegin(GL_LINE_STRIP);
-			
+
 			/* need to roll-back one point to ensure that there are no gaps in the stroke */
 			if (i != 0) glVertex3fv(&(pt - 1)->x);
-			
+
 			/* now the point we want... */
 			glVertex3fv(&pt->x);
 		}
@@ -432,7 +433,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness
 		}
 	}
 	glEnd();
-	
+
 	/* draw debug points of curve on top? */
 	/* XXX: for now, we represent "selected" strokes in the same way as debug, which isn't used anymore */
 	if (debug) {
@@ -451,14 +452,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
 {
 	/* otherwise thickness is twice that of the 3D view */
 	float thickness = (float)thickness_s * 0.5f;
-	
+
 	/* strokes in Image Editor need a scale factor, since units there are not pixels! */
 	float scalefac  = 1.0f;
 	if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) {
 		scalefac = 0.001f;
 	}
-	
-	
+
 	/* tessellation code - draw stroke as series of connected quads with connection
 	 * edges rotated to minimize shrinking artifacts, and rounded endcaps
 	 */
@@ -466,58 +466,58 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
 		bGPDspoint *pt1, *pt2;
 		float pm[2];
 		int i;
-		
+
 		glShadeModel(GL_FLAT);
 		glBegin(GL_QUADS);
-		
+
 		for (i = 0, pt1 = points, pt2 = points + 1; i < (totpoints - 1); i++, pt1++, pt2++) {
 			float s0[2], s1[2];     /* segment 'center' points */
 			float t0[2], t1[2];     /* tessellated coordinates */
 			float m1[2], m2[2];     /* gradient and normal */
 			float mt[2], sc[2];     /* gradient for thickness, point for end-cap */
 			float pthick;           /* thickness at segment point */
-			
+
 			/* get x and y coordinates from points */
 			gp_calc_2d_stroke_xy(pt1, sflag, offsx, offsy, winx, winy, s0);
 			gp_calc_2d_stroke_xy(pt2, sflag, offsx, offsy, winx, winy, s1);
-			
+
 			/* calculate gradient and normal - 'angle'=(ny/nx) */
 			m1[1] = s1[1] - s0[1];
 			m1[0] = s1[0] - s0[0];
 			normalize_v2(m1);
 			m2[1] = -m1[0];
 			m2[0] = m1[1];
-			
+
 			/* always use pressure from first point here */
 			pthick = (pt1->pressure * thickness * scalefac);
-			
+
 			/* if the first segment, start of segment is segment's normal */
 			if (i == 0) {
-				/* draw start cap first 
-				 *	- make points slightly closer to center (about halfway across) 
+				/* draw start cap first
+				 *	- make points slightly closer to center (about halfway across)
 				 */
 				mt[0] = m2[0] * pthick * 0.5f;
 				mt[1] = m2[1] * pthick * 0.5f;
 				sc[0] = s0[0] - (m1[0] * pthick * 0.75f);
 				sc[1] = s0[1] - (m1[1] * pthick * 0.75f);
-				
+
 				t0[0] = sc[0] - mt[0];
 				t0[1] = sc[1] - mt[1];
 				t1[0] = sc[0] + mt[0];
 				t1[1] = sc[1] + mt[1];
-				
+
 				glVertex2fv(t0);
 				glVertex2fv(t1);
-				
+
 				/* calculate points for start of segment */
 				mt[0] = m2[0] * pthick;
 				mt[1] = m2[1] * pthick;
-				
+
 				t0[0] = s0[0] - mt[0];
 				t0[1] = s0[1] - mt[1];
 				t1[0] = s0[0] + mt[0];
 				t1[1] = s0[1] + mt[1];
-				
+
 				/* draw this line twice (first to finish off start cap, then for stroke) */
 				glVertex2fv(t1);
 				glVertex2fv(t0);
@@ -528,13 +528,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
 			else {
 				float mb[2];         /* bisector normal */
 				float athick, dfac;  /* actual thickness, difference between thicknesses */
-				
+
 				/* calculate gradient of bisector (as average of normals) */
 				mb[0] = (pm[0] + m2[0]) / 2;
 				mb[1] = (pm[1] + m2[1]) / 2;
 				normalize_v2(mb);
-				
-				/* calculate gradient to apply 
+
+				/* calculate gradient to apply
 				 *  - as basis, use just pthick * bisector gradient
 				 *	- if cross-section not as thick as it should be, add extra padding to fix it
 				 */
@@ -542,79 +542,79 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
 				mt[1] = mb[1] * pthick;
 				athick = len_v2(mt);
 				dfac = pthick - (athick * 2);
-				
+
 				if (((athick * 2.0f) < pthick) && (IS_EQF(athick, pthick) == 0)) {
 					mt[0] += (mb[0] * dfac);
 					mt[1] += (mb[1] * dfac);
 				}
-				
+
 				/* calculate points for start of segment */
 				t0[0] = s0[0] - mt[0];
 				t0[1] = s0[1] - mt[1];
 				t1[0] = s0[0] + mt[0];
 				t1[1] = s0[1] + mt[1];
-				
+
 				/* draw this line twice (once for end of current segment, and once for start of next) */
 				glVertex2fv(t1);
 				glVertex2fv(t0);
 				glVertex2fv(t0);
 				glVertex2fv(t1);
 			}
-			
+
 			/* if last segment, also draw end of segment (defined as segment's normal) */
 			if (i == totpoints - 2) {
 				/* for once, we use second point's pressure (otherwise it won't be drawn) */
 				pthick = (pt2->pressure * thickness * scalefac);
-				
+
 				/* calculate points for end of segment */
 				mt[0] = m2[0] * pthick;
 				mt[1] = m2[1] * pthick;
-				
+
 				t0[0] = s1[0] - mt[0];
 				t0[1] = s1[1] - mt[1];
 				t1[0] = s1[0] + mt[0];
 				t1[1] = s1[1] + mt[1];
-				
+
 				/* draw this line twice (once for end of stroke, and once for endcap)*/
 				glVertex2fv(t1);
 				glVertex2fv(t0);
 				glVertex2fv(t0);
 				glVertex2fv(t1);
-				
-				
-				/* draw end cap as last step 
-				 *	- make points slightly closer to center (about halfway across) 
+
+
+				/* draw end cap as last step
+				 *	- make points slightly closer to center (about halfway across)
 				 */
 				mt[0] = m2[0] * pthick * 0.5f;
 				mt[1] = m2[1] * pthick * 0.5f;
 				sc[0] = s1[0] + (m1[0] * pthick * 0.75f);
 				sc[1] = s1[1] + (m1[1] * pthick * 0.75f);
-				
+
 				t0[0] = sc[0] - mt[0];
 				t0[1] = sc[1] - mt[1];
 				t1[0] = sc[0] + mt[0];
 				t1[1] = sc[1] + mt[1];
-				
+
 				glVertex2fv(t1);
 				glVertex2fv(t0);
 			}
-			
+
 			/* store stroke's 'natural' normal for next stroke to use */
 			copy_v2_v2(pm, m2);
 		}
-		
+
 		glEnd();
 	}
-	
+
 	/* draw debug points of curve on top? (original stroke points) */
 	if (debug) {
 		bGPDspoint *pt;
 		int i;
-		
+
 		glBegin(GL_POINTS);
 		for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
 			float co[2];
-			
+
 			gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co);
 			glVertex2fv(co);
 		}
@@ -633,24 +633,24 @@ static bool gp_can_draw_stroke(const bGPDstroke *gps, const int dflag)
 		return false;
 	if (!(dflag & GP_DRAWDATA_ONLY3D) && (gps->flag & GP_STROKE_3DSPACE))
 		return false;
-		
+
 	/* 2) Screen Space 2D Strokes */
 	if ((dflag & GP_DRAWDATA_ONLYV2D) && !(gps->flag & GP_STROKE_2DSPACE))
 		return false;
 	if (!(dflag & GP_DRAWDATA_ONLYV2D) && (gps->flag & GP_STROKE_2DSPACE))
 		return false;
-		
+
 	/* 3) Image Space (2D) */
 	if ((dflag & GP_DRAWDATA_ONLYI2D) && !(gps->flag & GP_STROKE_2DIMAGE))
 		return false;
 	if (!(dflag & GP_DRAWDATA_ONLYI2D) && (gps->flag & GP_STROKE_2DIMAGE))
 		return false;
-		
-		
+
+
 	/* skip stroke if it doesn't have any valid data */
 	if ((gps->points == NULL) || (gps->totpoints < 1))
 		return false;
-		
+
 	/* stroke can be drawn */
 	return true;
 }
@@ -660,22 +660,22 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
                             bool debug, short lthick, const float color[4], const float fill_color[4])
 {
 	bGPDstroke *gps;
-	
+
 	for (gps = gpf->strokes.first; gps; gps = gps->next) {
 		/* check if stroke can be drawn */
 		if (gp_can_draw_stroke(gps, dflag) == false)
 			continue;
-		
+
 		/* check which stroke-drawer to use */
 		if (dflag & GP_DRAWDATA_ONLY3D) {
 			const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
 			int mask_orig = 0;
-			
+
 			if (no_xray) {
 				glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
 				glDepthMask(0);
 				glEnable(GL_DEPTH_TEST);
-				
+
 				/* first arg is normally rv3d->dist, but this isn't
 				 * available here and seems to work quite well without */
 				bglPolygonOffset(1.0f, 1.0f);
@@ -684,16 +684,16 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
 				glPolygonOffset(-1.0f, -1.0f);
 #endif
 			}
-			
+
 			/* 3D Fill */
 			if ((dflag & GP_DRAWDATA_FILL) && (gps->totpoints >= 3)) {
 				glColor4fv(fill_color);
 				gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
 			}
-			
+
 			/* 3D Stroke */
 			glColor4fv(color);
-			
+
 			if (dflag & GP_DRAWDATA_VOLUMETRIC) {
 				/* volumetric stroke drawing */
 				gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, lthick, dflag, gps->flag);
@@ -707,11 +707,11 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
 					gp_draw_stroke_3d(gps->points, gps->totpoints, lthick, debug, gps->flag);
 				}
 			}
-			
+
 			if (no_xray) {
 				glDepthMask(mask_orig);
 				glDisable(GL_DEPTH_TEST);
-				
+
 				bglPolygonOffset(0.0, 0.0);
 #if 0
 				glDisable(GL_POLYGON_OFFSET_LINE);
@@ -725,10 +725,10 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
 				glColor4fv(fill_color);
 				gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
 			}
-			
+
 			/* 2D Strokes... */
 			glColor4fv(color);
-			
+
 			if (dflag & GP_DRAWDATA_VOLUMETRIC) {
 				/* blob/disk-based "volumetric" drawing */
 				gp_draw_stroke_volumetric_2d(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy);
@@ -750,17 +750,17 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int
 static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, int winy, short dflag, const float tcolor[3])
 {
 	bGPDstroke *gps;
-	
+
 	const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
 	int mask_orig = 0;
-	
+
 	/* set up depth masks... */
 	if (dflag & GP_DRAWDATA_ONLY3D) {
 		if (no_xray) {
 			glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig);
 			glDepthMask(0);
 			glEnable(GL_DEPTH_TEST);
-			
+
 			/* first arg is normally rv3d->dist, but this isn't
 			 * available here and seems to work quite well without */
 			bglPolygonOffset(1.0f, 1.0f);
@@ -770,25 +770,25 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 #endif
 		}
 	}
-	
-	
+
+
 	/* draw stroke verts */
 	for (gps = gpf->strokes.first; gps; gps = gps->next) {
 		bGPDspoint *pt;
 		float vsize, bsize;
 		int i;
-		
+
 		/* check if stroke can be drawn */
 		if (gp_can_draw_stroke(gps, dflag) == false)
 			continue;
-		
+
 		/* Optimisation: only draw points for selected strokes
 		 * We assume that selected points can only occur in
 		 * strokes that are selected too.
 		 */
 		if ((gps->flag & GP_STROKE_SELECT) == 0)
 			continue;
-			
+
 		/* Get size of verts:
 		 * - The selected state needs to be larger than the unselected state so that
 		 *   they stand out more.
@@ -802,7 +802,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 		else {
 			vsize = bsize + 2;
 		}
-		
+
 		/* First Pass: Draw all the verts (i.e. these become the unselected state) */
 		if (tcolor != NULL) {
 			/* for now, we assume that the base color of the points is not too close to the real color */
@@ -813,7 +813,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 			UI_ThemeColor(TH_VERTEX);
 		}
 		glPointSize(bsize);
-		
+
 		glBegin(GL_POINTS);
 		for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
 			if (gps->flag & GP_STROKE_3DSPACE) {
@@ -821,18 +821,18 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 			}
 			else {
 				float co[2];
-				
+
 				gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co);
 				glVertex2fv(co);
 			}
 		}
 		glEnd();
-		
-		
+
+
 		/* Second Pass: Draw only verts which are selected */
 		UI_ThemeColor(TH_VERTEX_SELECT);
 		glPointSize(vsize);
-		
+
 		glBegin(GL_POINTS);
 		for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
 			if (pt->flag & GP_SPOINT_SELECT) {
@@ -841,7 +841,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 				}
 				else {
 					float co[2];
-					
+
 					gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co);
 					glVertex2fv(co);
 				}
@@ -849,14 +849,14 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 		}
 		glEnd();
 	}
-	
-	
+
+
 	/* clear depth mask */
 	if (dflag & GP_DRAWDATA_ONLY3D) {
 		if (no_xray) {
 			glDepthMask(mask_orig);
 			glDisable(GL_DEPTH_TEST);
-			
+
 			bglPolygonOffset(0.0, 0.0);
 #if 0
 			glDisable(GL_POLYGON_OFFSET_LINE);
@@ -869,12 +869,12 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx,
 /* ----- General Drawing ------ */
 
 /* draw onion-skinning for a layer */
-static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy, 
+static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy,
                                int UNUSED(cfra), int dflag, short debug, short lthick)
 {
 	const float alpha = gpl->color[3];
 	float color[4];
-	
+
 	/* 1) Draw Previous Frames First */
 	if (gpl->flag & GP_LAYER_GHOST_PREVCOL) {
 		copy_v3_v3(color, gpl->gcolor_prev);
@@ -882,11 +882,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 	else {
 		copy_v3_v3(color, gpl->color);
 	}
-	
+
 	if (gpl->gstep) {
 		bGPDframe *gf;
 		float fac;
-		
+
 		/* draw previous frames first */
 		for (gf = gpf->prev; gf; gf = gf->prev) {
 			/* check if frame is drawable */
@@ -896,7 +896,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 				color[3] = alpha * fac * 0.66f;
 				gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
 			}
-			else 
+			else
 				break;
 		}
 	}
@@ -907,8 +907,8 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 			gp_draw_strokes(gpf->prev, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
 		}
 	}
-	
-	
+
+
 	/* 2) Now draw next frames */
 	if (gpl->flag & GP_LAYER_GHOST_NEXTCOL) {
 		copy_v3_v3(color, gpl->gcolor_next);
@@ -916,11 +916,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 	else {
 		copy_v3_v3(color, gpl->color);
 	}
-	
+
 	if (gpl->gstep_next) {
 		bGPDframe *gf;
 		float fac;
-		
+
 		/* now draw next frames */
 		for (gf = gpf->next; gf; gf = gf->next) {
 			/* check if frame is drawable */
@@ -930,7 +930,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 				color[3] = alpha * fac * 0.66f;
 				gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
 			}
-			else 
+			else
 				break;
 		}
 	}
@@ -941,7 +941,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of
 			gp_draw_strokes(gpf->next, offsx, offsy, winx, winy, dflag, debug, lthick, color, color);
 		}
 	}
-	
+
 	/* 3) restore alpha */
 	glColor4fv(gpl->color);
 }
@@ -1075,7 +1075,7 @@ static void gp_draw_data(bGPdata *gpd, int offsx, int offsy, int winx, int winy,
 /* if we have strokes for scenes (3d view)/clips (movie clip editor)
  * and objects/tracks, multiple data blocks have to be drawn */
 static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, int winx, int winy,
-                         int cfra, int dflag, const char spacetype)
+                             int cfra, int dflag, const char spacetype)
 {
 	bGPdata *gpd_source = NULL;
 
@@ -1117,25 +1117,25 @@ void ED_gpencil_draw_2dimage(const bContext *C)
 	bGPdata *gpd;
 	int offsx, offsy, sizex, sizey;
 	int dflag = GP_DRAWDATA_NOSTATUS;
-	
+
 	gpd = ED_gpencil_data_get_active(C); // XXX
 	if (gpd == NULL) return;
-	
+
 	/* calculate rect */
 	switch (sa->spacetype) {
 		case SPACE_IMAGE: /* image */
 		case SPACE_CLIP: /* clip */
 		{
-			
+
 			/* just draw using standard scaling (settings here are currently ignored anyways) */
 			/* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */
 			offsx = 0;
 			offsy = 0;
 			sizex = ar->winx;
 			sizey = ar->winy;
-			
+
 			wmOrtho2(ar->v2d.cur.xmin, ar->v2d.cur.xmax, ar->v2d.cur.ymin, ar->v2d.cur.ymax);
-			
+
 			dflag |= GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_IEDITHACK;
 			break;
 		}
@@ -1146,9 +1146,9 @@ void ED_gpencil_draw_2dimage(const bContext *C)
 			offsy = 0;
 			sizex = ar->winx;
 			sizey = ar->winy;
-			
-			/* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated 
-			 * and everything moved to standard View2d 
+
+			/* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated
+			 * and everything moved to standard View2d
 			 */
 			dflag |= GP_DRAWDATA_ONLYV2D;
 			break;
@@ -1158,17 +1158,17 @@ void ED_gpencil_draw_2dimage(const bContext *C)
 			offsy = 0;
 			sizex = ar->winx;
 			sizey = ar->winy;
-			
+
 			dflag |= GP_DRAWDATA_ONLYI2D;
 			break;
 	}
-	
-	
+
+
 	/* draw it! */
 	gp_draw_data_all(scene, gpd, offsx, offsy, sizex, sizey, CFRA, dflag, sa->spacetype);
 }
 
-/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly 
+/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly
  * Note: this gets called twice - first time with onlyv2d=1 to draw 'canvas' strokes,
  * second time with onlyv2d=0 for screen-aligned strokes */
 void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d)
@@ -1178,23 +1178,23 @@ void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d)
 	Scene *scene = CTX_data_scene(C);
 	bGPdata *gpd;
 	int dflag = 0;
-	
+
 	/* check that we have grease-pencil stuff to draw */
 	if (sa == NULL) return;
 	gpd = ED_gpencil_data_get_active(C); // XXX
 	if (gpd == NULL) return;
-	
+
 	/* special hack for Image Editor */
 	/* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */
 	if (ELEM(sa->spacetype, SPACE_IMAGE, SPACE_CLIP))
 		dflag |= GP_DRAWDATA_IEDITHACK;
-	
+
 	/* draw it! */
 	if (onlyv2d) dflag |= (GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_NOSTATUS);
 	gp_draw_data_all(scene, gpd, 0, 0, ar->winx, ar->winy, CFRA, dflag, sa->spacetype);
 }
 
-/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly 
+/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly
  * Note: this gets called twice - first time with only3d=1 to draw 3d-strokes,
  * second time with only3d=0 for screen-aligned strokes */
 void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d)
@@ -1225,7 +1225,7 @@ void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d)
 		winx  = ar->winx;
 		winy  = ar->winy;
 	}
-	
+
 	/* draw it! */
 	if (only3d) dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);