== Grease Pencil - Eraser (First Draft) ==

This commit introduces the ability to erase strokes. Admittedly, the code for this is not totally stable yet, and doesn't always produce optimum results. I'm committing now for backup purposes.

It currently uses the lasso code to check whether segments of the strokes (a segment occurs between two recorded points) occur inside a region defined by the 'eraser' stroke, or any intersections it makes with the 'eraser' stroke.

There are multiple ways to erase strokes:
* With 'Draw Mode' on, use RMB-drag to erase
* With a tablet, use the 'eraser' end of the stylus
* Hold the Alt Key, and use the 'selection' mouse-button (i.e. LMB if mouse-button swapping is on, RMB otherwise) to erase. For this one, this is necessary to avoid overriding the view-rotation hotkey combo for 2-button mice!

Todo:
* 3d-strokes are not correctly mapped back to screen-space for sampling yet
* Drawing of eraser strokes is still not distinctive enough
* After running a few times, may cause stack corruption/segfaults, so be careful!


== Bugfixes ==
* Grease-Pencil Onion-Skinning works again. Onionskining was being supplied the wrong frames, and the alpha factor was still the old one used for 0-255 ranged colour values

6 files changed, 369 insertions, 95 deletions

diff --git a/source/blender/include/BDR_gpencil.h b/source/blender/include/BDR_gpencil.h
index d2fc7be29ea..eb749cf28ec 100644
--- a/source/blender/include/BDR_gpencil.h
+++ b/source/blender/include/BDR_gpencil.h
@@ -38,6 +38,15 @@ struct bGPdata;
 struct bGPDlayer;
 struct bGPDframe;
 
+/* ------------- Grease-Pencil Helpers -------------- */
+
+/* Temporary 'Stroke Point' data */
+typedef struct tGPspoint {
+	short x, y;				/* x and y coordinates of cursor (in relative to area) */
+	float xf, yf;			/* same as x and y, but as floats */
+	float pressure;			/* pressure of tablet at this point */
+} tGPspoint;
+
 /* ------------ Grease-Pencil API ------------------ */
 
 void free_gpencil_strokes(struct bGPDframe *gpf);
diff --git a/source/blender/include/BIF_editview.h b/source/blender/include/BIF_editview.h
index 4ed3d0df367..4c407d43672 100644
--- a/source/blender/include/BIF_editview.h
+++ b/source/blender/include/BIF_editview.h
@@ -37,6 +37,7 @@ struct View3D;
 
 void	arrows_move_cursor(unsigned short event);
 int		lasso_inside(short mcords[][2], short moves, short sx, short sy);
+int 	lasso_inside_edge(short mcords[][2], short moves, int x0, int y0, int x1, int y1);
 void	borderselect(void);
 void	circle_select(void);
 void	deselectall(void);
diff --git a/source/blender/makesdna/DNA_gpencil_types.h b/source/blender/makesdna/DNA_gpencil_types.h
index b88dd698c3f..dca4e28688d 100644
--- a/source/blender/makesdna/DNA_gpencil_types.h
+++ b/source/blender/makesdna/DNA_gpencil_types.h
@@ -125,7 +125,7 @@ typedef struct bGPdata {
 	 */
 	short sbuffer_size;			/* number of elements currently in cache */
 	short sbuffer_sflag;		/* flags for stroke that cache represents */
-	bGPDspoint *sbuffer;		/* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
+	void *sbuffer;				/* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
 } bGPdata;
 
 /* bGPdata->flag */
diff --git a/source/blender/src/drawgpencil.c b/source/blender/src/drawgpencil.c
index e07dec90629..733310bfda7 100644
--- a/source/blender/src/drawgpencil.c
+++ b/source/blender/src/drawgpencil.c
@@ -280,11 +280,15 @@ short draw_gpencil_panel (uiBlock *block, bGPdata *gpd, ScrArea *sa)
 		
 		/* show override lmb-clicks button + painting lock */
 		uiBlockBeginAlign(block);
-			uiDefButBitI(block, TOG, GP_DATA_EDITPAINT, B_REDR, "Draw Mode", 170, 225, 130, 20, &gpd->flag, 0, 0, 0, 0, "Interpret LMB-click as new strokes (same as holding Shift-Key per stroke)");
-			
-			uiBlockSetCol(block, TH_BUT_SETTING);
-				uiDefIconButBitI(block, ICONTOG, GP_DATA_LMBPLOCK, B_REDR, ICON_UNLOCKED,	300, 225, 20, 20, &gpd->flag, 0.0, 0.0, 0, 0, "Painting cannot occur with Shift-LMB (when making selections)");
-			uiBlockSetCol(block, TH_AUTO);
+			if ((gpd->flag & GP_DATA_EDITPAINT)==0) {
+				uiDefButBitI(block, TOG, GP_DATA_EDITPAINT, B_REDR, "Draw Mode", 170, 225, 130, 20, &gpd->flag, 0, 0, 0, 0, "Interpret click-drag as new strokes");
+				
+				uiBlockSetCol(block, TH_BUT_SETTING);
+					uiDefIconButBitI(block, ICONTOG, GP_DATA_LMBPLOCK, B_REDR, ICON_UNLOCKED,	300, 225, 20, 20, &gpd->flag, 0.0, 0.0, 0, 0, "Painting cannot occur with Shift-LMB (when making selections)");
+				uiBlockSetCol(block, TH_AUTO);
+			}
+			else
+				uiDefButBitI(block, TOG, GP_DATA_EDITPAINT, B_REDR, "Draw Mode", 170, 225, 150, 20, &gpd->flag, 0, 0, 0, 0, "Interpret click-drag as new strokes");
 		uiBlockEndAlign(block);
 		
 		/* 'view align' button (naming depends on context) */
@@ -313,6 +317,66 @@ enum {
 	GP_DRAWDATA_ONLYV2D		= (1<<2),	/* only draw 'canvas' strokes */
 };
 
+/* draw stroke in buffer */
+static void gp_draw_stroke_buffer (tGPspoint *points, int totpoints, short thickness, short dflag, short sflag)
+{
+	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 */
+		glBegin(GL_POINTS);
+			glVertex2f(points->x, points->y);
+		glEnd();
+	}
+	else if (sflag & GP_STROKE_ERASER) {
+		/* draw stroke curve - just standard thickness */
+		setlinestyle(4);
+		glLineWidth(1.0f);
+		
+		glBegin(GL_LINE_STRIP);
+		for (i=0, pt=points; i < totpoints && pt; i++, pt++) {
+			glVertex2f(pt->x, pt->y);
+		}
+		glEnd();
+		
+		setlinestyle(0);
+	}
+	else {
+		float oldpressure = 0.0f;
+		
+		/* draw stroke curve */
+		setlinestyle(2);
+		
+		glBegin(GL_LINE_STRIP);
+		for (i=0, pt=points; i < totpoints && pt; i++, pt++) {
+			if (fabs(pt->pressure - oldpressure) > 0.2f) {
+				glEnd();
+				glLineWidth(pt->pressure * thickness);
+				glBegin(GL_LINE_STRIP);
+				
+				glVertex2f(pt->x, pt->y);
+				
+				oldpressure = pt->pressure;
+			}
+			else
+				glVertex2f(pt->x, pt->y);
+		}
+		glEnd();
+		
+		setlinestyle(0);
+	}
+}
+
 /* draw a given stroke */
 static void gp_draw_stroke (bGPDspoint *points, int totpoints, short thickness, short dflag, short sflag, short debug, int winx, int winy)
 {
@@ -489,8 +553,8 @@ static void gp_draw_data (bGPdata *gpd, int winx, int winy, int dflag)
 					/* check if frame is drawable */
 					if ((gpf->framenum - gf->framenum) <= gpl->gstep) {
 						/* alpha decreases with distance from curframe index */
-						tcolor[3] = color[3] - (i * 0.7);
-						gp_draw_strokes(gpf, winx, winy, dflag, debug, lthick, tcolor);
+						tcolor[3] = color[3] - (i/gpl->gstep);
+						gp_draw_strokes(gf, winx, winy, dflag, debug, lthick, tcolor);
 					}
 					else 
 						break;
@@ -501,8 +565,8 @@ static void gp_draw_data (bGPdata *gpd, int winx, int winy, int dflag)
 					/* check if frame is drawable */
 					if ((gf->framenum - gpf->framenum) <= gpl->gstep) {
 						/* alpha decreases with distance from curframe index */
-						tcolor[3] = color[3] - (i * 0.7);
-						gp_draw_strokes(gpf, winx, winy, dflag, debug, lthick, tcolor);
+						tcolor[3] = color[3] - (i/gpl->gstep);
+						gp_draw_strokes(gf, winx, winy, dflag, debug, lthick, tcolor);
 					}
 					else 
 						break;
@@ -515,12 +579,12 @@ static void gp_draw_data (bGPdata *gpd, int winx, int winy, int dflag)
 				/* draw the strokes for the ghost frames (at half of the alpha set by user) */
 				if (gpf->prev) {
 					tcolor[3] = (color[3] / 7);
-					gp_draw_strokes(gpf, winx, winy, dflag, debug, lthick, tcolor);
+					gp_draw_strokes(gpf->prev, winx, winy, dflag, debug, lthick, tcolor);
 				}
 				
 				if (gpf->next) {
 					tcolor[3] = (color[3] / 4);
-					gp_draw_strokes(gpf, winx, winy, dflag, debug, lthick, tcolor);
+					gp_draw_strokes(gpf->next, winx, winy, dflag, debug, lthick, tcolor);
 				}
 				
 				/* restore alpha */
@@ -533,15 +597,13 @@ static void gp_draw_data (bGPdata *gpd, int winx, int winy, int dflag)
 		gp_draw_strokes(gpf, winx, winy, dflag, debug, lthick, tcolor);
 		
 		/* Check if may need to draw the active stroke cache, only if this layer is the active layer
-		 * that is being edited. (Stroke cache is currently stored in gp-data)
+		 * that is being edited. (Stroke buffer is currently stored in gp-data)
 		 */
 		if ((G.f & G_GREASEPENCIL) && (gpl->flag & GP_LAYER_ACTIVE) &&
 			(gpf->flag & GP_FRAME_PAINT)) 
 		{
 			/* Buffer stroke needs to be drawn with a different linestyle to help differentiate them from normal strokes. */
-			setlinestyle(2);
-			gp_draw_stroke(gpd->sbuffer, gpd->sbuffer_size, lthick, dflag, gpd->sbuffer_sflag, debug, winx, winy);
-			setlinestyle(0);
+			gp_draw_stroke_buffer(gpd->sbuffer, gpd->sbuffer_size, lthick, dflag, gpd->sbuffer_sflag);
 		}
 	}
 	
diff --git a/source/blender/src/editview.c b/source/blender/src/editview.c
index e3ec69975de..f58248be161 100644
--- a/source/blender/src/editview.c
+++ b/source/blender/src/editview.c
@@ -298,7 +298,7 @@ int lasso_inside(short mcords[][2], short moves, short sx, short sy)
 }
 
 /* edge version for lasso select. we assume boundbox check was done */
-static int lasso_inside_edge(short mcords[][2], short moves, int x0, int y0, int x1, int y1)
+int lasso_inside_edge(short mcords[][2], short moves, int x0, int y0, int x1, int y1)
 {
 	short v1[2], v2[2];
 	int a;
diff --git a/source/blender/src/gpencil.c b/source/blender/src/gpencil.c
index 24ed6a7b0ba..fe01106919f 100644
--- a/source/blender/src/gpencil.c
+++ b/source/blender/src/gpencil.c
@@ -57,6 +57,7 @@
 #include "BIF_gl.h"
 #include "BIF_glutil.h"
 #include "BIF_butspace.h"
+#include "BIF_editview.h"
 #include "BIF_graphics.h"
 #include "BIF_interface.h"
 #include "BIF_mywindow.h"
@@ -683,7 +684,7 @@ typedef struct tGPsdata {
 	bGPDframe *gpf;		/* frame we're working on */
 	
 	short status;		/* current status of painting */
-	short paintmode;	/* mode for painting (L_MOUSE or R_MOUSE for now) */
+	short paintmode;	/* mode for painting */
 } tGPsdata;
 
 /* values for tGPsdata->status */
@@ -693,6 +694,12 @@ enum {
 	GP_STATUS_DONE			/* painting done */
 };
 
+/* values for tGPsdata->paintmode */
+enum {
+	GP_PAINTMODE_DRAW = 0,
+	GP_PAINTMODE_ERASER
+};
+
 /* Return flags for adding points to stroke buffer */
 enum {
 	GP_STROKEADD_INVALID	= -2,		/* error occurred - insufficient info to do so */
@@ -710,9 +717,9 @@ static void gp_session_validatebuffer (tGPsdata *p)
 	
 	/* clear memory of buffer (or allocate it if starting a new session) */
 	if (gpd->sbuffer)
-		memset(gpd->sbuffer, 0, sizeof(bGPDspoint)*GP_STROKE_BUFFER_MAX);
+		memset(gpd->sbuffer, 0, sizeof(tGPspoint)*GP_STROKE_BUFFER_MAX);
 	else
-		gpd->sbuffer= MEM_callocN(sizeof(bGPDspoint)*GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer");
+		gpd->sbuffer= MEM_callocN(sizeof(tGPspoint)*GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer");
 	
 	/* reset indices */
 	gpd->sbuffer_size = 0;
@@ -850,6 +857,25 @@ static void gp_session_cleanup (tGPsdata *p)
 	gpd->sbuffer_sflag= 0;
 }
 
+/* check if the current mouse position is suitable for adding a new point */
+static short gp_stroke_filtermval (tGPsdata *p, short mval[2], short pmval[2])
+{
+	short dx= abs(mval[0] - pmval[0]);
+	short dy= abs(mval[1] - pmval[1]);
+	
+	/* check if mouse moved at least certain distance on both axes (best case) */
+	if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX))
+		return 1;
+	
+	/* check if the distance since the last point is significant enough */
+	else if (sqrt(dx*dx + dy*dy) > MIN_EUCLIDEAN_PX)
+		return 1;
+	
+	/* mouse 'didn't move' */
+	else
+		return 0;
+}
+
 /* convert screen-coordinates to buffer-coordinates */
 static void gp_stroke_convertcoords (tGPsdata *p, short mval[], float out[])
 {
@@ -884,30 +910,11 @@ static void gp_stroke_convertcoords (tGPsdata *p, short mval[], float out[])
 	}
 }
 
-/* check if the current mouse position is suitable for adding a new point */
-static short gp_stroke_filtermval (tGPsdata *p, short mval[2], short pmval[2])
-{
-	short dx= abs(mval[0] - pmval[0]);
-	short dy= abs(mval[1] - pmval[1]);
-	
-	/* check if mouse moved at least certain distance on both axes (best case) */
-	if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX))
-		return 1;
-	
-	/* check if the distance since the last point is significant enough */
-	else if (sqrt(dx*dx + dy*dy) > MIN_EUCLIDEAN_PX)
-		return 1;
-	
-	/* mouse 'didn't move' */
-	else
-		return 0;
-}
-
 /* add current stroke-point to buffer (returns whether point was successfully added) */
 static short gp_stroke_addpoint (tGPsdata *p, short mval[2], float pressure)
 {
 	bGPdata *gpd= p->gpd;
-	bGPDspoint *pt;
+	tGPspoint *pt;
 	
 	/* check if still room in buffer */
 	if (gpd->sbuffer_size >= GP_STROKE_BUFFER_MAX)
@@ -915,12 +922,13 @@ static short gp_stroke_addpoint (tGPsdata *p, short mval[2], float pressure)
 	
 	
 	/* get pointer to destination point */
-	pt= gpd->sbuffer + gpd->sbuffer_size;
+	pt= ((tGPspoint *)(gpd->sbuffer) + gpd->sbuffer_size);
 	
-	/* convert screen-coordinates to appropriate coordinates (and store them) */
-	gp_stroke_convertcoords(p, mval, &pt->x);
-	
-	/* store other settings */
+	/* store settings */
+	pt->x= mval[0];
+	pt->y= mval[1];
+	pt->xf= (float)mval[0];
+	pt->yf= (float)mval[0];
 	pt->pressure= pressure;
 	
 	/* increment counters */
@@ -933,38 +941,13 @@ static short gp_stroke_addpoint (tGPsdata *p, short mval[2], float pressure)
 		return GP_STROKEADD_NORMAL;
 }
 
-/* smooth a stroke (in buffer) before storing it */
-static void gp_stroke_smooth (tGPsdata *p)
-{
-	bGPdata *gpd= p->gpd;
-	int i=0, cmx=gpd->sbuffer_size;
-	
-	// fixme: currently disabled as it damages too much sometimes
-	return;
-	
-	/* don't try if less than 2 points in buffer */
-	if ((cmx <= 2) || (gpd->sbuffer == NULL))
-		return;
-	
-	/* apply weighting-average (note doing this along path sequentially does introduce slight error) */
-	for (i=0; i < gpd->sbuffer_size; i++) {
-		bGPDspoint *pc= (gpd->sbuffer + i);
-		bGPDspoint *pb= (i-1 > 0)?(pc-1):(pc);
-		bGPDspoint *pa= (i-2 > 0)?(pc-2):(pb);
-		bGPDspoint *pd= (i+1 < cmx)?(pc+1):(pc);
-		bGPDspoint *pe= (i+2 < cmx)?(pc+2):(pd);
-		
-		pc->x= (0.1*pa->x + 0.2*pb->x + 0.4*pc->x + 0.2*pd->x + 0.1*pe->x);
-		pc->y= (0.1*pa->y + 0.2*pb->y + 0.4*pc->y + 0.2*pd->y + 0.1*pe->y);
-	}
-}
-
 /* make a new stroke from the buffer data */
 static void gp_stroke_newfrombuffer (tGPsdata *p)
 {
 	bGPdata *gpd= p->gpd;
 	bGPDstroke *gps;
-	bGPDspoint *pt, *ptc;
+	bGPDspoint *pt;
+	tGPspoint *ptc;
 	int i, totelem;
 	
 	/* get total number of points to allocate space for */
@@ -990,7 +973,12 @@ static void gp_stroke_newfrombuffer (tGPsdata *p)
 	
 	/* copy points from the buffer to the stroke */
 	for (i=0, ptc=gpd->sbuffer; i < gpd->sbuffer_size && ptc; i++, ptc++) {
-		memcpy(pt, ptc, sizeof(bGPDspoint));
+		/* convert screen-coordinates to appropriate coordinates (and store them) */
+		gp_stroke_convertcoords(p, &ptc->x, &pt->x);
+		
+		/* copy pressure */
+		pt->pressure= ptc->pressure;
+		
 		pt++;
 	}
 	
@@ -998,10 +986,202 @@ static void gp_stroke_newfrombuffer (tGPsdata *p)
 	BLI_addtail(&p->gpf->strokes, gps);
 }
 
+/* --- 'Eraser' for 'Paint' Tool ------ */
+/* User should draw 'circles' around the parts of the sketches they wish to 
+ * delete instead of drawing squiggles over existing lines. This should be 
+ * easier to manage than if it was done otherwise.
+ */
+
+/* convert gp-buffer stroke into mouse-coordinates array */
+static short (*gp_stroke_eraser_2mco (bGPdata *gpd))[2]
+{
+	tGPspoint *pt;
+	short (*mcoords)[2]; 
+	int i;
+	
+	/* allocate memory for coordinates array */
+	mcoords= MEM_mallocN(sizeof(*mcoords)*gpd->sbuffer_size,"gp_buf_mcords");
+	
+	/* copy coordinates */
+	for (pt=gpd->sbuffer, i=0; i < gpd->sbuffer_size; i++, pt++) {
+		mcoords[i][0]= pt->x;
+		mcoords[i][1]= pt->y;
+	}
+	
+	/* return */
+	return mcoords;
+}
+
+/* eraser tool evaluation per curve */
+static void gp_stroke_eraser_dostroke (tGPsdata *p, short mcoords[][2], short moves, bGPDframe *gpf, bGPDstroke *gps)
+{
+	bGPDspoint *pt1, *pt2;
+	short x0=0, y0=0, x1=0, y1=0;
+	short xyval[2];
+	int i;
+	
+	if (gps->totpoints == 0) {
+		/* just free stroke */
+		if (gps->points) 
+			MEM_freeN(gps->points);
+		BLI_freelinkN(&gpf->strokes, gps);
+	}
+	else if (gps->totpoints == 1) {
+		/* get coordinates */
+		if (gps->flag & GP_STROKE_3DSPACE) {
+			// FIXME: this may not be the correct correction
+			project_short(&gps->points->x, xyval);
+			x0= xyval[0];
+			x1= xyval[1];
+		}
+		else if (gps->flag & GP_STROKE_2DSPACE) {			
+			ipoco_to_areaco_noclip(p->v2d, &gps->points->x, xyval);
+			x0= xyval[0];
+			y0= xyval[1];
+		}
+		else {
+			x0= (gps->points->x / 1000 * p->sa->winx);
+			y0= (gps->points->y / 1000 * p->sa->winy);
+		}
+		
+		/* only check if point is inside */
+		if (lasso_inside(mcoords, moves, x0, y0)) {
+			/* free stroke */
+			MEM_freeN(gps->points);
+			BLI_freelinkN(&gpf->strokes, gps);
+		}
+	}
+	else {	
+		/* loop over the points in the stroke, checking for intersections 
+		 * 	- an intersection will require the stroke to be split
+		 */
+		for (i=0; (i+1) < gps->totpoints; i++) {
+			/* get points to work with */
+			pt1= gps->points + i;
+			pt2= gps->points + i + 1;
+			
+			/* get coordinates */
+			if (gps->flag & GP_STROKE_3DSPACE) {
+				// FIXME: may not be correct correction
+				project_short(&gps->points->x, xyval);
+				x0= xyval[0];
+				x1= xyval[1];
+			}
+			else if (gps->flag & GP_STROKE_2DSPACE) {
+				ipoco_to_areaco_noclip(p->v2d, &pt1->x, xyval);
+				x0= xyval[0];
+				y0= xyval[1];
+				
+				ipoco_to_areaco_noclip(p->v2d, &pt2->x, xyval);
+				x1= xyval[0];
+				y1= xyval[1];
+			}
+			else {
+				x0= (pt1->x / 1000 * p->sa->winx);
+				y0= (pt1->y / 1000 * p->sa->winy);
+				x1= (pt2->x / 1000 * p->sa->winx);
+				y1= (pt2->y / 1000 * p->sa->winy);
+			}
+			
+			/* check if point segment of stroke had anything to do with
+			 * eraser region  (either within stroke painted, or on its lines)
+			 * 	- this assumes that linewidth is irrelevant
+			 *	- handled using the lasso-select checking code
+			 */
+			if (lasso_inside_edge(mcoords, moves, x0, y0, x1, x1)) {
+				bGPDspoint *pt_tmp= gps->points;
+				bGPDstroke *gsn = NULL;
+				
+				/* if stroke only had two points, get rid of stroke */
+				if (gps->totpoints == 2) {
+					/* free stroke points, then stroke */
+					MEM_freeN(pt_tmp);
+					BLI_freelinkN(&gpf->strokes, gps);
+					
+					/* nothing left in stroke, so stop */
+					break;
+				}
+				
+				/* if last segment, just remove segment from the stroke */
+				else if (i == gps->totpoints - 2) {
+					/* allocate new points array, and assign most of the old stroke there */
+					gps->totpoints--;
+					gps->points= MEM_callocN(sizeof(bGPDspoint)*gps->totpoints, "gp_stroke_points");
+					memcpy(gps->points, pt_tmp, sizeof(bGPDspoint)*gps->totpoints);
+					
+					/* free temp buffer */
+					MEM_freeN(pt_tmp);
+					
+					/* nothing left in stroke, so stop */
+					break;
+				}
+				
+				/* if first segment, just remove segment from the stroke */
+				else if (i == 0) {
+					/* allocate new points array, and assign most of the old stroke there */
+					gps->totpoints--;
+					gps->points= MEM_callocN(sizeof(bGPDspoint)*gps->totpoints, "gp_stroke_points");
+					memcpy(gps->points, pt_tmp + 1, sizeof(bGPDspoint)*gps->totpoints);
+					
+					/* free temp buffer */
+					MEM_freeN(pt_tmp);
+					
+					/* no break here, as there might still be stuff to remove in this stroke */
+				}
+				
+				/* segment occurs in 'middle' of stroke, so split */
+				else {
+					/* duplicate stroke, and assign 'later' data to that stroke */
+					gsn= MEM_dupallocN(gps);
+					gsn->prev= gsn->next= NULL;
+					BLI_insertlinkafter(&gpf->strokes, gps, gsn);
+					
+					gsn->totpoints= gps->totpoints - i;
+					gsn->points= MEM_callocN(sizeof(bGPDspoint)*gsn->totpoints, "gp_stroke_points");
+					memcpy(gsn->points, pt_tmp + i, sizeof(bGPDspoint)*gsn->totpoints);
+					
+					/* adjust existing stroke  */
+					gps->totpoints= i;
+					gps->points= MEM_callocN(sizeof(bGPDspoint)*gps->totpoints, "gp_stroke_points");
+					memcpy(gps->points, pt_tmp, sizeof(bGPDspoint)*i);
+					
+					/* free temp buffer */
+					MEM_freeN(pt_tmp);
+					
+					/* nothing left in stroke, so stop */
+					break;
+				}
+			}
+		}
+	}
+}
+
+/* -------- */
+
+/* erase strokes which fall under the eraser strokes */
+static void gp_stroke_doeraser (tGPsdata *p)
+{
+	bGPdata *gpd= p->gpd;
+	bGPDframe *gpf= p->gpf;
+	bGPDstroke *gps;
+	short (*mcoords)[2];
+	
+	/* get buffer-stroke coordinates as shorts array */
+	mcoords= gp_stroke_eraser_2mco(gpd);
+	
+	/* loop over strokes, checking segments for intersections */
+	for (gps= gpf->strokes.first; gps; gps= gps->next) {
+		gp_stroke_eraser_dostroke(p, mcoords, gpd->sbuffer_size, gpf, gps);
+	}
+	
+	/* free mcoords array */
+	MEM_freeN(mcoords);
+}
+
 /* ---------- 'Paint' Tool ------------ */
 
 /* init new stroke */
-static void gp_paint_initstroke (tGPsdata *p, short mousebutton)
+static void gp_paint_initstroke (tGPsdata *p, short paintmode)
 {	
 	/* get active layer (or add a new one if non-existent) */
 	p->gpl= gpencil_layer_getactive(p->gpd);
@@ -1025,14 +1205,10 @@ static void gp_paint_initstroke (tGPsdata *p, short mousebutton)
 	else
 		p->gpf->flag |= GP_FRAME_PAINT;
 	
-	/* set 'eraser' for this stroke if using eraser or right-mouse in action */
-	if ( get_activedevice() == 2 || (mousebutton & R_MOUSE) ) {
+	/* set 'eraser' for this stroke if using eraser */
+	p->paintmode= paintmode;
+	if (p->paintmode == GP_PAINTMODE_ERASER)
 		p->gpd->sbuffer_sflag |= GP_STROKE_ERASER;
-		
-		// for now: eraser isn't ready for prime-time yet, so no painting available here yet
-		p->status= GP_STATUS_ERROR;
-		return;
-	}
 	
 	/* check if points will need to be made in view-aligned space */
 	if (p->gpd->flag & GP_DATA_VIEWALIGN) {
@@ -1062,12 +1238,10 @@ static void gp_paint_initstroke (tGPsdata *p, short mousebutton)
 /* finish off a stroke (clears buffer, but doesn't finish the paint operation) */
 static void gp_paint_strokeend (tGPsdata *p)
 {
-	/* sanitize stroke-points in buffer (remove jitter) */
-	gp_stroke_smooth(p);
-	
 	/* check if doing eraser or not */
 	if (p->gpd->sbuffer_sflag & GP_STROKE_ERASER) {
 		/* get rid of relevant sections of strokes */
+		gp_stroke_doeraser(p);
 	}
 	else {
 		/* transfer stroke to frame */
@@ -1100,7 +1274,7 @@ static void gp_paint_cleanup (tGPsdata *p)
 /* -------- */
 
 /* main call to paint a new stroke */
-short gpencil_paint (short mousebutton)
+short gpencil_paint (short mousebutton, short paintmode)
 {
 	tGPsdata p;
 	short prevmval[2], mval[2];
@@ -1113,7 +1287,7 @@ short gpencil_paint (short mousebutton)
 		gp_session_cleanup(&p);
 		return 0;
 	}
-	gp_paint_initstroke(&p, mousebutton);
+	gp_paint_initstroke(&p, paintmode);
 	if (p.status == GP_STATUS_ERROR) {
 		gp_session_cleanup(&p);
 		return 0;
@@ -1188,7 +1362,10 @@ short gpencil_paint (short mousebutton)
 	setcursor_space(p.sa->spacetype, CURSOR_STD);
 	
 	/* check size of buffer before cleanup, to determine if anything happened here */
-	ok= p.gpd->sbuffer_size;
+	if (paintmode == GP_PAINTMODE_ERASER)
+		ok= (p.gpd->sbuffer_size > 1);
+	else
+		ok= p.gpd->sbuffer_size;
 	
 	/* cleanup */
 	gp_paint_cleanup(&p);
@@ -1202,7 +1379,7 @@ short gpencil_paint (short mousebutton)
 /* All event (loops) handling checking if stroke drawing should be initiated
  * should call this function.
  */
-short gpencil_do_paint (ScrArea *sa, short mousebutton)
+short gpencil_do_paint (ScrArea *sa, short mbut)
 {
 	bGPdata *gpd = gpencil_data_getactive(sa);
 	short retval= 0;
@@ -1211,18 +1388,43 @@ short gpencil_do_paint (ScrArea *sa, short mousebutton)
 	if (gpd == NULL) 
 		return 0;
 	
-	/* currently, we will only paint if:
+	/* currently, we will only 'paint' if:
 	 * 	1. draw-mode on gpd is set (for accessibility reasons)
 	 *		(single 'dots' are only available via this method)
 	 *	2. if shift-modifier is held + lmb -> 'quick paint'
+	 *
+	 *	OR
+	 * 
+	 * draw eraser stroke if:
+	 *	1. using the eraser on a tablet
+	 *	2. draw-mode on gpd is set (for accessiblity reasons)
+	 *		(eraser is mapped to right-mouse)
+	 *	3. Alt + 'select' mouse-button
+	 *		i.e.  if LMB = select: Alt-LMB
+	 *			  if RMB = select: Alt-RMB
 	 */
-	if (gpd->flag & GP_DATA_EDITPAINT) {
-		/* try to paint */
-		retval = gpencil_paint(mousebutton);
+	if (get_activedevice() == 2) {
+		/* eraser on a tablet - always try to erase strokes */
+		retval = gpencil_paint(mbut, GP_PAINTMODE_ERASER);
 	}
-	else if (!(gpd->flag & GP_DATA_LMBPLOCK) && (G.qual == LR_SHIFTKEY)) {
-		/* try to paint */
-		retval = gpencil_paint(mousebutton);
+	else if (gpd->flag & GP_DATA_EDITPAINT) {
+		/* try to paint/erase */
+		if (mbut == L_MOUSE)
+			retval = gpencil_paint(mbut, GP_PAINTMODE_DRAW);
+		else if (mbut == R_MOUSE)
+			retval = gpencil_paint(mbut, GP_PAINTMODE_ERASER);
+	}
+	else if (!(gpd->flag & GP_DATA_LMBPLOCK)) {
+		/* try to paint/erase as not locked */
+		if ((G.qual == LR_SHIFTKEY) && (mbut == L_MOUSE)) {
+			retval = gpencil_paint(mbut, GP_PAINTMODE_DRAW);
+		}
+		else if (G.qual == LR_ALTKEY) {
+			if ((U.flag & USER_LMOUSESELECT) && (mbut == L_MOUSE))
+				retval = gpencil_paint(mbut, GP_PAINTMODE_ERASER);
+			else if (!(U.flag & USER_LMOUSESELECT) && (mbut == R_MOUSE))
+				retval = gpencil_paint(mbut, GP_PAINTMODE_ERASER);
+		}
 	}
 	
 	/* return result of trying to paint */