Update upstream source from tag 'upstream/5.2.0Beta2.1'

Update to upstream version '5.2.0Beta2.1'
with Debian dir 1576f25f4c1496abfed44af31ead67d32c7be650

1 files changed, 1996 insertions, 351 deletions

diff --git a/app/bin/drawgeom.c b/app/bin/drawgeom.c
index 2342599..d23031f 100644
--- a/app/bin/drawgeom.c
+++ b/app/bin/drawgeom.c
@@ -37,46 +37,42 @@ static long drawGeomCurveMode;
 
 #define contextSegs(N) DYNARR_N( trkSeg_t, context->Segs_da, N )
 
-
-
 static dynArr_t points_da;
-#define points(N) DYNARR_N( coOrd, points_da, N )
+static dynArr_t anchors_da;
+static dynArr_t select_da;
+
+#define points(N) DYNARR_N( pts_t, points_da, N )
+#define point_selected(N) DYNARR_N( wBool_t, select_da, N)
+#define anchors(N) DYNARR_N( trkSeg_t, anchors_da, N)
 
-static void EndPoly( drawContext_t * context, int cnt )
+static void EndPoly( drawContext_t * context, int cnt, wBool_t open)
 {
 	trkSeg_p segPtr;
 	track_p trk;
-	long oldOptions;
-	coOrd * pts;
+	pts_t * pts;
 	int inx;
 
 	if (context->State==0 || cnt == 0)
 		return;
 	
-	oldOptions = context->D->funcs->options;
-	context->D->funcs->options |= wDrawOptTemp;
-	DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-	context->D->funcs->options = oldOptions;
-
-	if (IsClose(FindDistance(tempSegs(0).u.l.pos[0], tempSegs(cnt-1).u.l.pos[1] )))
-		cnt--;
-	if ( cnt < 2 ) {
+	if ( cnt < 3 ) {
 		tempSegs_da.cnt = 0;
 		ErrorMessage( MSG_POLY_SHAPES_3_SIDES );
 		return;
 	}
-	pts = (coOrd*)MyMalloc( (cnt+1) * sizeof (coOrd) );
-	for ( inx=0; inx<cnt; inx++ )
-		pts[inx] = tempSegs(inx).u.l.pos[0];
-	pts[cnt] = tempSegs(cnt-1).u.l.pos[1];
+	pts = (pts_t*)MyMalloc( (cnt) * sizeof (pts_t) );
+	for ( inx=0; inx<cnt; inx++ ) {
+		pts[inx].pt = tempSegs(inx).u.l.pos[0];
+		pts[inx].pt_type = wPolyLineStraight;
+	}
 	DYNARR_SET( trkSeg_t, tempSegs_da, 1 );
 	segPtr = &tempSegs(0);
-	segPtr->type = ( context->Op == OP_POLY ? SEG_POLY: SEG_FILPOLY );
-	segPtr->u.p.cnt = cnt+1;
+	segPtr->type = ( (context->Op == OP_POLY || context->Op == OP_POLYLINE )? SEG_POLY:SEG_FILPOLY );
+	segPtr->u.p.cnt = cnt;
 	segPtr->u.p.pts = pts;
 	segPtr->u.p.angle = 0.0;
 	segPtr->u.p.orig = zero;
-	segPtr->u.p.polyType = FREEFORM;
+	segPtr->u.p.polyType = open?POLYLINE:FREEFORM;
 	UndoStart( _("Create Lines"), "newDraw" );
 	trk = MakeDrawFromSeg( zero, 0.0, segPtr );
 	DrawNewTrack( trk );
@@ -100,6 +96,80 @@ static void DrawGeomOk( void )
 	tempSegs_da.cnt = 0;
 }
 
+static void CreateEndAnchor(coOrd p, wBool_t lock) {
+	DIST_T d = tempD.scale*0.15;
+
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	int i = anchors_da.cnt-1;
+	anchors(i).type = lock?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(i).color = wDrawColorBlue;
+	anchors(i).u.c.center = p;
+	anchors(i).u.c.radius = d/2;
+	anchors(i).u.c.a0 = 0.0;
+	anchors(i).u.c.a1 = 360.0;
+	anchors(i).width = 0;
+}
+
+static void CreateLineAnchor(coOrd p, coOrd p0) {
+	DIST_T d = tempD.scale*0.15;
+	coOrd p1;
+	ANGLE_T a = FindAngle(p0,p);
+	Translate(&p1,p,a,d*5);
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	int i = anchors_da.cnt-1;
+	anchors(i).type = SEG_STRLIN;
+	anchors(i).color = wDrawColorBlue;
+	anchors(i).u.l.pos[0] = p;
+	anchors(i).u.l.pos[1] = p0;
+	anchors(i).width = 0;
+}
+
+static void CreateSquareAnchor(coOrd p) {
+	DIST_T d = tempD.scale*0.15;
+	int i = anchors_da.cnt;
+	DYNARR_SET(trkSeg_t,anchors_da,i+4);
+	for (int j =0; j<4;j++) {
+		anchors(i+j).type = SEG_STRLIN;
+		anchors(i+j).color = wDrawColorBlue;
+		anchors(i+j).width = 0;
+	}
+	anchors(i).u.l.pos[0].x = anchors(i+2).u.l.pos[1].x =
+	anchors(i+3).u.l.pos[0].x = anchors(i+3).u.l.pos[1].x = p.x-d/2;
+
+	anchors(i).u.l.pos[0].y = anchors(i).u.l.pos[1].y =
+	anchors(i+1).u.l.pos[0].y =	anchors(i+3).u.l.pos[1].y = p.y-d/2;
+
+	anchors(i).u.l.pos[1].x =
+	anchors(i+1).u.l.pos[0].x = anchors(i+1).u.l.pos[1].x =
+	anchors(i+2).u.l.pos[0].x = p.x+d/2;
+
+	anchors(i+1).u.l.pos[1].y =
+	anchors(i+2).u.l.pos[0].y = anchors(i+2).u.l.pos[1].y =
+	anchors(i+3).u.l.pos[0].y = p.y+d/2;
+}
+
+BOOL_T FindTempNear(drawContext_t *context, coOrd *p) {
+	if (context->State == 2) {
+		if (context->Op >= OP_CURVE1 && context->Op <= OP_CURVE4) {
+			if (context->ArcData.type == curveTypeCurve) {
+				ANGLE_T a = FindAngle(context->ArcData.curvePos,*p);
+				if (IsClose(FindDistance(context->ArcData.curvePos,*p)-context->ArcData.curveRadius) &&
+						(a>=context->ArcData.a0) && (a<=context->ArcData.a0+context->ArcData.a1)) {
+					Translate(p,context->ArcData.curvePos,a,context->ArcData.curveRadius);
+					return TRUE;
+				}
+			} else {
+				if (IsClose(LineDistance(p,tempSegs(0).u.l.pos[0],tempSegs(0).u.l.pos[1])))
+					return TRUE;
+			}
+		} else if ( context->Op >=OP_LINE && context->Op <= OP_BENCH) {
+			if (IsClose(LineDistance(p,tempSegs(0).u.l.pos[0],tempSegs(0).u.l.pos[1])))
+				return TRUE;
+		}
+	}
+	return FALSE;
+}
+
 /**
  * Create and draw a graphics primitive (lines, arc, circle). The complete handling of mouse 
  * movements and clicks during the editing process is done here. 
@@ -108,63 +178,195 @@ static void DrawGeomOk( void )
  * \param pos IN position of mouse pointer
  * \param context IN/OUT parameters for drawing op 
  * \return next command state
+ *
+ * Note - Poly supports both clicking points and/or dragging sides. Close is space or enter.
+ * Note - This routine will be recalled to C_UPDATE the last action if the State is 2 and the user updates the dialog
+ *
  */
 
 STATUS_T DrawGeomMouse(
 		wAction_t action,
 		coOrd pos,
-		drawContext_t *context )
+		drawContext_t *context)
 {
 	static int lastValid = FALSE;
+	static wBool_t lock;
 	static coOrd pos0, pos0x, pos1, lastPos;
 	trkSeg_p segPtr;
-	coOrd *pts;
+	pts_t *pts;
 	int inx;
 	DIST_T width;
 	static int segCnt;
 	DIST_T d;
+	ANGLE_T a1,a2;
+	static ANGLE_T line_angle;
 	BOOL_T createTrack;
-	long oldOptions;
 
-	width = context->Width/context->D->dpi;
+	width = context->line_Width/context->D->dpi;
 
 	switch (action&0xFF) {
 
+	case C_UPDATE:
+		if (context->State == 0 ) return C_TERMINATE;
+		if (context->Op != OP_POLY && context->Op != OP_FILLPOLY && context->Op != OP_POLYLINE && context->State == 1) return C_TERMINATE;
+		switch (context->Op) {
+		case OP_CIRCLE1:
+		case OP_CIRCLE2:
+		case OP_CIRCLE3:
+		case OP_FILLCIRCLE1:
+		case OP_FILLCIRCLE2:
+		case OP_FILLCIRCLE3:
+			tempSegs(0).u.c.radius = context->radius;
+		break;
+		case OP_CURVE1:
+		case OP_CURVE2:
+		case OP_CURVE3:
+		case OP_CURVE4:
+			if (context->ArcData.type == curveTypeCurve) {
+				if (tempSegs(0).u.c.radius != context->radius) {
+					coOrd end;
+					Translate(&end,context->ArcData.curvePos,context->ArcData.a0,context->ArcData.curveRadius);
+					tempSegs(0).u.c.radius = context->radius;
+					Translate(&tempSegs(0).u.c.center,end,context->ArcData.a0+180,context->radius);
+					context->ArcData.curvePos = tempSegs(0).u.c.center;
+					context->ArcData.curveRadius = tempSegs(0).u.c.radius;
+				}
+				tempSegs(0).u.c.a1 = context->angle;
+				context->ArcData.a1 = tempSegs(0).u.c.a1;
+				Translate(&context->ArcData.pos1,context->ArcData.curvePos,context->ArcData.a0,context->ArcData.curveRadius);
+				Translate(&context->ArcData.pos2,context->ArcData.curvePos,context->ArcData.a0+context->ArcData.a1,context->ArcData.curveRadius);
+			} else
+				Translate(&tempSegs(0).u.l.pos[1],tempSegs(0).u.l.pos[0],context->angle,context->length);
+		break;
+		case OP_LINE:
+		case OP_BENCH:
+		case OP_TBLEDGE:
+			a1 = FindAngle(pos0,pos1);
+			Translate(&tempSegs(0).u.l.pos[1],tempSegs(0).u.l.pos[0],context->angle,context->length);
+			lastPos = pos1 = tempSegs(0).u.l.pos[1];
+			tempSegs_da.cnt = 1;
+			context->angle = NormalizeAngle(context->angle);
+		break;
+		case OP_BOX:
+		case OP_FILLBOX:
+			pts = tempSegs(0).u.p.pts;
+			a1 = FindAngle(pts[0].pt,pts[1].pt);
+			Translate(&pts[1].pt,pts[0].pt,a1,context->length);
+			a2 = FindAngle(pts[0].pt,pts[3].pt);
+			Translate(&pts[2].pt,pts[1].pt,a2,context->width);
+			Translate(&pts[3].pt,pts[0].pt,a2,context->width);
+			tempSegs_da.cnt = 1;
+		break;
+		case OP_POLY:
+		case OP_FILLPOLY:
+		case OP_POLYLINE:
+			tempSegs_da.cnt = segCnt;
+			if (segCnt>1) {
+				ANGLE_T an = FindAngle(tempSegs(segCnt-2).u.l.pos[0],tempSegs(segCnt-2).u.l.pos[1]);
+				an = an+context->angle;
+				Translate(&tempSegs(segCnt-1).u.l.pos[1],tempSegs(segCnt-1).u.l.pos[0],an,context->length);
+			} else {
+				Translate(&tempSegs(0).u.l.pos[1],tempSegs(0).u.l.pos[0],context->angle,context->length);
+			}
+			pos1 = lastPos = tempSegs(segCnt-1).u.l.pos[1];
+			context->angle = fabs(context->angle);
+			if (context->angle >180) context->angle = context->angle - 180.0;
+		break;
+		default:
+		break;
+		}
+		MainRedraw();
+		anchors_da.cnt = 0;
+		return C_CONTINUE;
+
 	case C_START:
 		context->State = 0;
 		context->Changed = FALSE;
 		segCnt = 0;
+		CleanSegs(&tempSegs_da);
 		DYNARR_RESET( trkSeg_t, tempSegs_da );
+		DYNARR_RESET( trkSeg_t, anchors_da );
+		lock = FALSE;
+		if (!magneticSnap)
+			InfoMessage(_("+Shift to lock to nearby objects"));
+		else
+			InfoMessage(_("+Shift to not lock to nearby objects"));
 		return C_CONTINUE;
 
 	case wActionMove:
-		return C_CONTINUE;
-
-	case wActionLDown:
-		context->Started = TRUE;
-		if (context->State == 0) {		//First Down only
-			switch (context->Op) {  	//Snap pos to nearest line end point if this is end and just shift is depressed for lines and some curves
-				case OP_LINE:
+		if (context->State == 0 || context->State ==2 ) {
+			DYNARR_RESET( trkSeg_t, anchors_da );
+			switch (context->Op) {  	//Snap pos to nearest line if this is end and just shift is depressed for lines and some curves
 				case OP_CURVE1:
-					if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_SHIFT ) {
+				case OP_CURVE2:
+				case OP_CURVE3:
+				case OP_CURVE4:
+				case OP_LINE:
+				case OP_DIMLINE:
+				case OP_BENCH:
+				case OP_POLY:
+				case OP_FILLPOLY:
+				case OP_POLYLINE:
+					if (((MyGetKeyState() & WKEY_ALT) == 0) == magneticSnap ) {
 						coOrd p = pos;
 						track_p t;
-						if ((t=OnTrack(&p,FALSE,FALSE))) {
-							if (GetClosestEndPt(t,&p)) {
-								pos = p;
+						if ((t=OnTrack(&p,FALSE,FALSE))!=NULL) {
+							if (context->Op == OP_DIMLINE ) {
+								CreateEndAnchor(p,FALSE);
+							} else if (!IsTrack(t)) CreateEndAnchor(p,FALSE);
+						} else {
+							p = pos;
+							if (FindTempNear(context,&p)) {
+								CreateEndAnchor(p,FALSE);
 							}
 						}
-					};
+					}
 					break;
 				default:
 					;
 			}
 		}
+		return C_CONTINUE;
+
+	case wActionLDown:
+		DYNARR_RESET( trkSeg_t, anchors_da );
+		if (context->State == 2) {
+			tempSegs_da.cnt = segCnt;
+			if ((context->Op == OP_POLY || context->Op == OP_FILLPOLY || context->Op == OP_POLYLINE)) {
+				EndPoly(context, segCnt, context->Op==OP_POLYLINE);
+			} else {
+				DrawGeomOk();
+			}
+			segCnt = 0;
+			anchors_da.cnt = 0;
+			context->State = 0;
+		}
+		context->Started = TRUE;
+		line_angle = 90.0;
+		if ((context->Op == OP_CURVE1 && context->State != 2) ||
+			(context->Op == OP_CURVE2 && context->State == 0) ||
+			(context->Op == OP_CURVE3 && context->State != 0) ||
+			(context->Op == OP_CURVE4 && context->State != 2) ||
+			(context->Op == OP_LINE) || (context->Op == OP_DIMLINE) ||
+			(context->Op == OP_BENCH) ) {
+			BOOL_T found = FALSE;
+			if (((MyGetKeyState() & WKEY_ALT) ==0) == magneticSnap ) {
+				coOrd p = pos;
+				track_p t;
+				if ((t=OnTrack(&p,FALSE,FALSE))!=NULL) {
+					if (!IsTrack(t)) {
+						EPINX_T ep1,ep2;
+						line_angle = GetAngleAtPoint(t,pos,&ep1,&ep2);
+						pos = p;
+						found = TRUE;
+					}
+				}
+			}
+			if (!found) SnapPos( &pos );
+		}
 		if ((context->Op == OP_CURVE1 || context->Op == OP_CURVE2 || context->Op == OP_CURVE3 || context->Op == OP_CURVE4) && context->State == 1) {
-			;
+		;
 		} else {
-			if ( (MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_CTRL )   // Control snaps to nearest track (not necessarily the end)
-				OnTrack( &pos, FALSE, FALSE );
 			pos0 = pos;
 			pos1 = pos;
 		}
@@ -173,9 +375,6 @@ STATUS_T DrawGeomMouse(
 		case OP_LINE:
 		case OP_DIMLINE:
 		case OP_BENCH:
-			if ( lastValid && ( MyGetKeyState() & WKEY_CTRL ) ) {
-				pos = pos0 = lastPos;
-			}
 			DYNARR_SET( trkSeg_t, tempSegs_da, 1 );
 			switch (context->Op) {
 			case OP_LINE: tempSegs(0).type = SEG_STRLIN; break;
@@ -191,12 +390,9 @@ STATUS_T DrawGeomMouse(
 				tempSegs(0).u.l.option = 0;
 			}
 			tempSegs_da.cnt = 0;
-			context->message( _("Drag to place next end point") );
+			context->message( _("Drag to next point, +Shift to lock to object, +Ctrl to lock to 90deg") );
 			break;
 		case OP_TBLEDGE:
-			if ( lastValid && ( MyGetKeyState() & WKEY_CTRL ) ) {
-				pos = pos0 = lastPos;
-			}
 			OnTableEdgeEndPt( NULL, &pos );
 			DYNARR_SET( trkSeg_t, tempSegs_da, 1 );
 			tempSegs(0).type = SEG_TBLEDGE;
@@ -214,9 +410,8 @@ STATUS_T DrawGeomMouse(
 				case OP_CURVE3: drawGeomCurveMode = crvCmdFromCenter; break;
 				case OP_CURVE4: drawGeomCurveMode = crvCmdFromChord; break;
 				}
-				CreateCurve( C_DOWN, pos, FALSE, context->Color, width, drawGeomCurveMode, context->message );
-			} else {
-				tempSegs_da.cnt = segCnt;
+				CreateCurve( C_START, pos, FALSE, context->Color, width, drawGeomCurveMode, &anchors_da, context->message );
+				CreateCurve( C_DOWN, pos, FALSE, context->Color, width, drawGeomCurveMode, &anchors_da, context->message );
 			}
 			break;
 		case OP_CIRCLE1:
@@ -240,6 +435,7 @@ STATUS_T DrawGeomMouse(
 			break;
 		case OP_FILLBOX:
 			width = 0;
+			/* no break */
 		case OP_BOX:
 			DYNARR_SET( trkSeg_t, tempSegs_da, 4 );
 			for ( inx=0; inx<4; inx++ ) {
@@ -248,75 +444,172 @@ STATUS_T DrawGeomMouse(
 				tempSegs(inx).width = width;
 				tempSegs(inx).u.l.pos[0] = tempSegs(inx).u.l.pos[1] = pos;
 			}
-			tempSegs_da.cnt = 0;
 			context->message( _("Drag set box size") );
 			break;
 		case OP_POLY:
 		case OP_FILLPOLY:
+		case OP_POLYLINE:
 			tempSegs_da.cnt = segCnt;
-			DYNARR_APPEND( trkSeg_t, tempSegs_da, 10 );
+			wBool_t first_spot = FALSE;
+			if (segCnt == 1 && tempSegs(0).type == SEG_CRVLIN) {
+				coOrd start;
+				start = tempSegs(0).u.c.center;
+				tempSegs(0).type = SEG_STRLIN;
+				tempSegs(0).u.l.pos[0] = start;
+				first_spot=TRUE;
+			} else {
+				DYNARR_APPEND( trkSeg_t, tempSegs_da, 10 );
+			}
 			segPtr = &tempSegs(tempSegs_da.cnt-1);
 			segPtr->type = SEG_STRLIN;
 			segPtr->color = context->Color;
 			segPtr->width = (context->Op==OP_POLY?width:0);
-			if ( tempSegs_da.cnt == 1 ) {
-				segPtr->u.l.pos[0] = pos;
-			} else {
-				segPtr->u.l.pos[0] = segPtr[-1].u.l.pos[1];
+			//End if over start
+			if ( segCnt>2 && IsClose(FindDistance(tempSegs(0).u.l.pos[0], pos ))) {
+				segPtr->u.l.pos[0] = tempSegs(segCnt-1).u.l.pos[1];
+				segPtr->u.l.pos[1] = tempSegs(0).u.l.pos[0];
+				EndPoly(context, tempSegs_da.cnt, context->Op==OP_POLYLINE);
+				DYNARR_RESET(pts_t, points_da);
+				DYNARR_RESET(trkSeg_t,tempSegs_da);
+				context->State = 0;
+				segCnt = 0;
+				return C_TERMINATE;
+			}
+			if (!first_spot) {
+				if ( tempSegs_da.cnt == 1) {
+					segPtr->u.l.pos[0] = pos;
+				} else {
+					segPtr->u.l.pos[0] = segPtr[-1].u.l.pos[1];
+				}
 			}
 			segPtr->u.l.pos[1] = pos;
 			context->State = 1;
-			oldOptions = context->D->funcs->options;
-			context->D->funcs->options |= wDrawOptTemp;
-			DrawSegs( context->D, zero, 0.0, &tempSegs(tempSegs_da.cnt-1), 1, trackGauge, wDrawColorBlack );
-			context->D->funcs->options = oldOptions;
+			segCnt = tempSegs_da.cnt;
+			context->message(_("+Shift - lock to close object, +Ctrl - lock to 90 deg"));
 			break;
 		}
 		return C_CONTINUE;
 
 	case wActionLDrag:
-		oldOptions = context->D->funcs->options;
-		context->D->funcs->options |= wDrawOptTemp;
-		if (context->Op == OP_POLY || context->Op == OP_FILLPOLY)
-			DrawSegs( context->D, zero, 0.0, &tempSegs(tempSegs_da.cnt-1), 1, trackGauge, wDrawColorBlack );
-		else
-			DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-		if ( (MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_CTRL )
-			OnTrack( &pos, FALSE, FALSE );
+		DYNARR_RESET(trkSeg_t, anchors_da );
+		if ((context->Op == OP_CURVE1 && context->State == 1) ||
+			(context->Op == OP_CURVE2 && context->State == 0) ||
+			(context->Op == OP_CURVE4 && context->State != 2) ||
+			(context->Op == OP_LINE) ||
+			(context->Op == OP_BENCH) ) {
+			if (( (MyGetKeyState() & WKEY_ALT)==0) == magneticSnap) {
+				if (OnTrack( &pos, FALSE, FALSE )!=NULL)
+					CreateEndAnchor(pos,TRUE);
+			}
+		} else if (context->Op == OP_DIMLINE) {
+			if (OnTrack( &pos, FALSE, FALSE )!=NULL) CreateEndAnchor(pos,TRUE);
+		}
+
 		pos1 = pos;
+
 		switch (context->Op) {
 		case OP_TBLEDGE:
 			OnTableEdgeEndPt( NULL, &pos1 );
+			/* no break */
 		case OP_LINE:
 		case OP_DIMLINE:
 		case OP_BENCH:
+			if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_CTRL ) {
+				//Snap to Right-Angle from previous or from 0
+				DIST_T l = FindDistance(pos0, pos);
+				ANGLE_T angle2 = NormalizeAngle(FindAngle(pos0, pos)-line_angle);
+				int quad = (int)((angle2 + 45.0) / 90.0);
+				if (tempSegs_da.cnt != 1 && (quad == 2)) {
+					pos1 = pos0;
+				} else if (quad == 1 || quad == 3) {
+					if (tempSegs_da.cnt != 1)
+						l = fabs(l*cos(D2R(((quad==1)?line_angle+90.0:line_angle-90.0)-FindAngle(pos,pos0))));
+					Translate( &pos1, pos0, NormalizeAngle(quad==1?line_angle+90.0:line_angle-90.0), l );
+				} else {
+					if (tempSegs_da.cnt != 1)
+						l = fabs(l*cos(D2R(((quad==0||quad==4)?line_angle:line_angle+180.0)-FindAngle(pos,pos0))));
+					Translate( &pos1, pos0, NormalizeAngle((quad==0||quad==4)?line_angle:line_angle+180.0), l );
+				}
+				CreateLineAnchor(pos1,pos0);
+			}
 			tempSegs(0).u.l.pos[1] = pos1;
 			context->message( _("Length = %s, Angle = %0.2f"),
 						FormatDistance(FindDistance( pos0, pos1 )),
 						PutAngle(FindAngle( pos0, pos1 )) );
 			tempSegs_da.cnt = 1;
+			if (anchors_da.cnt == 0) CreateEndAnchor(pos, FALSE);
 			break;
 		case OP_POLY:
 		case OP_FILLPOLY:
+		case OP_POLYLINE:
+			if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_CTRL ) {
+				coOrd last_point = zero;
+				ANGLE_T last_angle, initial_angle;
+				if (tempSegs_da.cnt == 1) {
+					last_angle = 90.0;
+					last_point = tempSegs(0).u.l.pos[0];
+					initial_angle = 90.0;
+				} else {
+					last_point = tempSegs(tempSegs_da.cnt-2).u.l.pos[1];
+					last_angle = FindAngle(tempSegs(tempSegs_da.cnt-2).u.l.pos[0],tempSegs(tempSegs_da.cnt-2).u.l.pos[1]);
+					initial_angle = FindAngle(tempSegs(0).u.l.pos[0],tempSegs(0).u.l.pos[1]);
+				}
+				//Snap to Right-Angle from previous or from 0
+				DIST_T l = FindDistance(tempSegs(tempSegs_da.cnt-1).u.l.pos[0], pos);
+				ANGLE_T angle2 = NormalizeAngle(FindAngle(tempSegs(tempSegs_da.cnt-1).u.l.pos[0], pos)-last_angle);
+				int quad = (int)((angle2+45.0)/90.0);
+				if (tempSegs_da.cnt != 1 && (quad == 2)) {
+					pos = tempSegs(tempSegs_da.cnt-1).u.l.pos[0];
+				} else if (quad == 1 || quad == 3) {
+					if (tempSegs_da.cnt != 1)
+						l = fabs(l*cos(D2R(((quad==1)?last_angle+90.0:last_angle-90.0)-FindAngle(pos,last_point))));
+					Translate( &pos, tempSegs(tempSegs_da.cnt-1).u.l.pos[0], NormalizeAngle(quad==1?last_angle+90.0:last_angle-90.0), l );
+				} else {
+					if (tempSegs_da.cnt != 1)
+						l = fabs(l*cos(D2R(((quad==0||quad==4)?last_angle:last_angle+180.0)-FindAngle(pos,last_point))));
+					Translate( &pos, tempSegs(tempSegs_da.cnt-1).u.l.pos[0], NormalizeAngle((quad==0||quad==4)?last_angle:last_angle+180.0), l );
+				}
+				CreateEndAnchor(pos,TRUE);
+				if (FindDistance(pos,last_point)>0.0) CreateLineAnchor(pos,last_point);
+			}
+			//If there is any point on this line that will give a 90 degree return to the first point, show it
+			if (tempSegs_da.cnt > 1) {
+				coOrd intersect;
+				ANGLE_T an_this = FindAngle(tempSegs(tempSegs_da.cnt-2).u.l.pos[1],pos);
+				if (FindIntersection(&intersect,tempSegs(0).u.l.pos[0],an_this+90.0,tempSegs(tempSegs_da.cnt-2).u.l.pos[1],an_this)) {
+					ANGLE_T an_inter = FindAngle(tempSegs(tempSegs_da.cnt-2).u.l.pos[1],intersect);
+					if (fabs(DifferenceBetweenAngles(an_inter,an_this))<90.0) {
+						CreateSquareAnchor(intersect);
+						d = FindDistance(intersect,pos);
+						if (IsClose(d)) {
+							pos = intersect;
+						}
+					}
+				}
+			}
 			tempSegs(tempSegs_da.cnt-1).type = SEG_STRLIN;
 			tempSegs(tempSegs_da.cnt-1).u.l.pos[1] = pos;
 			context->message( _("Length = %s, Angle = %0.2f"),
 						FormatDistance(FindDistance( tempSegs(tempSegs_da.cnt-1).u.l.pos[0], pos )),
 						PutAngle(FindAngle( tempSegs(tempSegs_da.cnt-1).u.l.pos[0], pos )) );
+			segCnt = tempSegs_da.cnt;
 			break;
 		case OP_CURVE1: case OP_CURVE2: case OP_CURVE3: case OP_CURVE4:
 			if (context->State == 0) {
-				CreateCurve( C_MOVE, pos, FALSE, context->Color, width, drawGeomCurveMode, context->message );
 				pos0x = pos;
+				CreateCurve( C_MOVE, pos, FALSE, context->Color, width, drawGeomCurveMode, &anchors_da, context->message );
 			} else {
 				PlotCurve( drawGeomCurveMode, pos0, pos0x, pos1, &context->ArcData, FALSE );
 				tempSegs(0).color = context->Color;
 				tempSegs(0).width = width;
+				DYNARR_SET(trkSeg_t,tempSegs_da,1);
 				if (context->ArcData.type == curveTypeStraight) {
 					tempSegs(0).type = SEG_STRLIN;
 					tempSegs(0).u.l.pos[0] = pos0;
 					tempSegs(0).u.l.pos[1] = context->ArcData.pos1;
 					tempSegs_da.cnt = 1;
+					CreateEndAnchor(pos0, FALSE);
+					CreateEndAnchor(context->ArcData.pos1, FALSE);
 					context->message( _("Straight Line: Length=%s Angle=%0.3f"),
 							FormatDistance(FindDistance( pos0, context->ArcData.pos1 )),
 							PutAngle(FindAngle( pos0, context->ArcData.pos1 )) );
@@ -337,14 +630,21 @@ STATUS_T DrawGeomMouse(
 						ErrorMessage( MSG_CURVE_TOO_LARGE );
 						tempSegs_da.cnt = 0;
 						context->ArcData.type = curveTypeNone;
-						context->D->funcs->options = oldOptions;
 						return C_CONTINUE;
 					}
 					context->message( _("Curved Line: Radius=%s Angle=%0.3f Length=%s"),
 							FormatDistance(context->ArcData.curveRadius), context->ArcData.a1,
 							FormatDistance(context->ArcData.curveRadius*d) );
+					if (context->Op == OP_CURVE1 || context->Op == OP_CURVE4 )
+						DrawArrowHeadsArray(&anchors_da,pos,FindAngle(context->ArcData.curvePos,pos),TRUE,wDrawColorRed);
+					else if (context->Op == OP_CURVE2 || context->Op == OP_CURVE3 ) {
+						CreateEndAnchor(context->ArcData.pos2,FALSE);
+						DrawArrowHeadsArray(&anchors_da,context->ArcData.pos2,FindAngle(context->ArcData.curvePos,context->ArcData.pos2)+90,TRUE,wDrawColorRed);
+					}
+					CreateEndAnchor(context->ArcData.curvePos,TRUE);
 				}
 			}
+			if (anchors_da.cnt == 0) CreateEndAnchor(pos, FALSE);
 			break;
 		case OP_CIRCLE1:
 		case OP_FILLCIRCLE1:
@@ -352,6 +652,7 @@ STATUS_T DrawGeomMouse(
 		case OP_CIRCLE2:
 		case OP_FILLCIRCLE2:
 			tempSegs(0).u.c.center = pos1;
+			/* no break */
 		case OP_CIRCLE3:
 		case OP_FILLCIRCLE3:
 			tempSegs(0).u.c.radius = FindDistance( pos0, pos1 );
@@ -369,58 +670,48 @@ STATUS_T DrawGeomMouse(
 						FormatDistance(fabs(pos1.x - pos0.x)), FormatDistance(fabs(pos1.y - pos0.y)) );
 			break;
 		}
-		if (context->Op == OP_POLY || context->Op == OP_FILLPOLY)
-			DrawSegs( context->D, zero, 0.0, &tempSegs(tempSegs_da.cnt-1), 1, trackGauge, wDrawColorBlack );
-		else
-			DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-		context->D->funcs->options = oldOptions;
-		if (context->Op == OP_DIMLINE) MainRedraw();   //Wipe Out Text
 		return C_CONTINUE;
 
 	case wActionLUp:
-		oldOptions = context->D->funcs->options;
-		context->D->funcs->options |= wDrawOptTemp;
-		if (context->Op != OP_POLY && context->Op != OP_FILLPOLY)
-			DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
 		lastValid = FALSE;
 		createTrack = FALSE;
-		if ((context->State == 0 && (context->Op == OP_LINE )) ||  //first point release for line,
-			(context->State == 1 && context->Op == OP_CURVE1)) {   //second point for curve from end
-			switch (context->Op) {  	//Snap pos to nearest line end point if this is on a line and just shift is depressed for lines and some curves
-				case OP_CURVE1:
-				case OP_LINE:
-					if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_SHIFT ) {
-						coOrd p = pos1;
-						track_p t;
-						if ((t=OnTrack(&p,FALSE,FALSE))) {
-							if (GetClosestEndPt(t,&p)) {
-								pos1 = p;
-								if (context->Op == OP_LINE) {
-									tempSegs(0).u.l.pos[1] = p;
-								} else {
-									PlotCurve( drawGeomCurveMode, pos0, pos0x, pos1, &context->ArcData, FALSE );
-									if (context->ArcData.type == curveTypeStraight) {
-										tempSegs(0).type = SEG_STRLIN;
-										tempSegs(0).u.l.pos[0] = pos0;
-										tempSegs(0).u.l.pos[1] = context->ArcData.pos1;
-										tempSegs_da.cnt = 1;
-									} else if (context->ArcData.type == curveTypeNone) {
-										tempSegs_da.cnt = 0;
-									} else if (context->ArcData.type == curveTypeCurve) {
-										tempSegs(0).type = SEG_CRVLIN;
-										tempSegs(0).u.c.center = context->ArcData.curvePos;
-										tempSegs(0).u.c.radius = context->ArcData.curveRadius;
-										tempSegs(0).u.c.a0 = context->ArcData.a0;
-										tempSegs(0).u.c.a1 = context->ArcData.a1;
-										tempSegs_da.cnt = 1;
-									}
-								}
-							}
+		if ((context->Op == OP_CURVE1 && context->State == 1) ||
+			(context->Op == OP_CURVE2 && context->State == 0) ||
+			(context->Op == OP_CURVE3 && context->State != 0) ||
+			(context->Op == OP_CURVE4 && context->State != 2) ||
+			(context->Op == OP_LINE) || (context->Op == OP_DIMLINE) ||
+			(context->Op == OP_BENCH) ) {
+			if (((MyGetKeyState() & WKEY_ALT)==0) == magneticSnap ) {
+				coOrd p = pos1;
+				track_p t;
+				if ((t=OnTrack(&p,FALSE,FALSE))) {
+					pos1 = p;
+					if (context->Op == OP_LINE || context->Op == OP_DIMLINE ||  context->Op == OP_BENCH) {
+						tempSegs(0).u.l.pos[1] = p;
+					} else {
+						PlotCurve( drawGeomCurveMode, pos0, pos0x, pos1, &context->ArcData, FALSE );
+						if (context->ArcData.type == curveTypeStraight) {
+							DYNARR_RESET(trkSeg_t,tempSegs_da);
+							DYNARR_APPEND(trkSeg_t,tempSegs_da,1);
+							tempSegs(0).type = SEG_STRLIN;
+							tempSegs(0).u.l.pos[0] = pos0;
+							tempSegs(0).u.l.pos[1] = context->ArcData.pos1;
+							tempSegs_da.cnt = 1;
+						} else if (context->ArcData.type == curveTypeNone) {
+							DYNARR_RESET(trkSeg_t,tempSegs_da);
+						} else if (context->ArcData.type == curveTypeCurve) {
+							DYNARR_RESET(trkSeg_t,tempSegs_da);
+							DYNARR_APPEND(trkSeg_t,tempSegs_da,1);
+							tempSegs(0).type = SEG_CRVLIN;
+							tempSegs(0).u.c.center = context->ArcData.curvePos;
+							tempSegs(0).u.c.radius = context->ArcData.curveRadius;
+							tempSegs(0).u.c.a0 = context->ArcData.a0;
+							tempSegs(0).u.c.a1 = context->ArcData.a1;
+							tempSegs_da.cnt = 1;
 						}
-					};
-					break;
-				default:
-				;
+					}
+
+				}
 			}
 		}
 		switch ( context->Op ) {
@@ -430,22 +721,22 @@ STATUS_T DrawGeomMouse(
 		case OP_TBLEDGE:
 			lastValid = TRUE;
 			lastPos = pos1;
+			context->length = FindDistance(pos1,pos0);
+			context->angle = FindAngle(pos0,pos1);
+			context->State = 2;
+			segCnt = tempSegs_da.cnt;
 			break;
 		case OP_CURVE1: case OP_CURVE2: case OP_CURVE3: case OP_CURVE4:
 			if (context->State == 0) {
 				context->State = 1;
 				context->ArcAngle = FindAngle( pos0, pos1 );
 				pos0x = pos1;
-				CreateCurve( C_UP, pos, FALSE, context->Color, width, drawGeomCurveMode, context->message );
-				DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-				segCnt = tempSegs_da.cnt;
+				CreateCurve( C_UP, pos, FALSE, context->Color, width, drawGeomCurveMode, &anchors_da, context->message );
 				context->message( _("Drag on Red arrows to adjust curve") );
-				context->D->funcs->options = oldOptions;
 				return C_CONTINUE;
 			} else {
-				tempSegs_da.cnt = 0;
+				DYNARR_SET(trkSeg_t,tempSegs_da,1);
 				if (context->ArcData.type == curveTypeCurve) {
-					tempSegs_da.cnt = 1;
 					segPtr = &tempSegs(0);
 					segPtr->type = SEG_CRVLIN;
 					segPtr->color = context->Color;
@@ -454,20 +745,22 @@ STATUS_T DrawGeomMouse(
 					segPtr->u.c.radius = context->ArcData.curveRadius;
 					segPtr->u.c.a0 = context->ArcData.a0;
 					segPtr->u.c.a1 = context->ArcData.a1;
+					context->radius = context->ArcData.curveRadius;
+					context->angle = context->ArcData.a1;
 				} else if (context->ArcData.type == curveTypeStraight) {
-					tempSegs_da.cnt = 1;
 					segPtr = &tempSegs(0);
 					segPtr->type = SEG_STRLIN;
 					segPtr->color = context->Color;
 					segPtr->width = width;
 					segPtr->u.l.pos[0] = pos0;
 					segPtr->u.l.pos[1] = pos1;
-				} else {
-					tempSegs_da.cnt = 0;
+					context->radius = 0;
+					context->length = FindDistance(pos0,pos1);
+					context->angle = FindAngle(pos0,pos1);
 				}
-				context->State = 0;
 				lastValid = TRUE;
 				lastPos = pos1;
+				context->State = 2;
 				/*drawContext = context;
 				DrawGeomOp( (void*)context->Op );*/
 			}
@@ -480,14 +773,17 @@ STATUS_T DrawGeomMouse(
 		case OP_FILLCIRCLE3:
 			if ( context->Op>=OP_FILLCIRCLE1 && context->Op<=OP_FILLCIRCLE3 )
 				tempSegs(0).type = SEG_FILCRCL;
-			/*drawContext = context;
-			DrawGeomOp( (void*)context->Op );*/
+			tempSegs_da.cnt = 1;
+			context->State = 2;
+			context->radius = tempSegs(0).u.c.radius;
 			break;
 		case OP_BOX:
 		case OP_FILLBOX:
-			pts = (coOrd*)MyMalloc( 4 * sizeof (coOrd) );
-			for ( inx=0; inx<4; inx++ )
-				pts[inx] = tempSegs(inx).u.l.pos[0];
+			pts = (pts_t*)MyMalloc( 4 * sizeof (pts_t) );
+			for ( inx=0; inx<4; inx++ ) {
+				pts[inx].pt = tempSegs(inx).u.l.pos[0];
+				pts[inx].pt_type = wPolyLineStraight;
+			}
 			tempSegs(0).type = (context->Op == OP_FILLBOX)?SEG_FILPOLY:SEG_POLY;
 			tempSegs(0).u.p.cnt = 4;
 			tempSegs(0).u.p.pts = pts;
@@ -497,188 +793,1259 @@ STATUS_T DrawGeomMouse(
 			tempSegs_da.cnt = 1;
 			/*drawContext = context;
 			DrawGeomOp( (void*)context->Op );*/
+			context->length = FindDistance(pts[0].pt,pts[1].pt);
+			context->width = FindDistance(pts[3].pt,pts[0].pt);
+			context->State = 2;
+			segCnt = tempSegs_da.cnt;
 			break;
 		case OP_POLY:
 		case OP_FILLPOLY:
+		case OP_POLYLINE:
+			tempSegs_da.cnt = segCnt;
+			anchors_da.cnt=0;
+			//End if close to start
+			if ( segCnt>2 && IsClose(FindDistance(tempSegs(0).u.l.pos[0], pos))) {
+				EndPoly(context, tempSegs_da.cnt, context->Op==OP_POLYLINE);
+				DYNARR_RESET(pts_t, points_da);
+				CleanSegs(&tempSegs_da);
+				context->State = 0;
+				segCnt = 0;
+				return C_TERMINATE;
+			}
+			//If too short, remove last segment
+			if (IsClose(FindDistance(tempSegs(segCnt-1).u.l.pos[0],pos))) {
+				if (tempSegs_da.cnt>1) {
+					--tempSegs_da.cnt;
+					segCnt = tempSegs_da.cnt;
+					wBeep();
+				} else {   //First spot only
+					tempSegs(0).color = wDrawColorRed;
+					tempSegs(0).type = SEG_CRVLIN;
+					tempSegs(0).u.c.a1 = 360;
+					tempSegs(0).u.c.radius = tempD.scale*0.15/2;
+					tempSegs(0).u.c.center = pos;
+					segCnt = tempSegs_da.cnt;
+				}
+				return C_CONTINUE;
+			}
+			int text_inx = tempSegs_da.cnt-1;
+			//tempSegs(tempSegs_da.cnt-1).u.l.pos[1] = pos;
+			context->length = FindDistance(tempSegs(text_inx).u.l.pos[0],tempSegs(text_inx).u.l.pos[1]);
+			if (text_inx>1) {
+				ANGLE_T an = FindAngle(tempSegs(text_inx-1).u.l.pos[0],tempSegs(text_inx-1).u.l.pos[1]);
+				context->angle = NormalizeAngle(FindAngle(tempSegs(text_inx).u.l.pos[0],tempSegs(text_inx).u.l.pos[1])-an);
+			} else
+				context->angle = FindAngle(tempSegs(1).u.l.pos[0],tempSegs(1).u.l.pos[1]);
+			context->State = 1;
+			context->index = text_inx;
 			segCnt = tempSegs_da.cnt;
-			context->D->funcs->options = oldOptions;
 			return C_CONTINUE;
 		}
 		context->Started = FALSE;
-		context->Changed = TRUE;
+		context->Changed = TRUE;					//Update screen shown
 		/*CheckOk();*/
-		context->D->funcs->options = oldOptions;
+		if (context->State == 2 && IsCurCommandSticky()) {
+			segCnt = tempSegs_da.cnt;
+			return C_CONTINUE;
+		}
 		DrawGeomOk();
+		context->State = 0;
+		context->Changed = FALSE;
+		context->message("");
 		return C_TERMINATE;
 
 	case wActionText:
-
+		DYNARR_RESET(trkSeg_t, anchors_da );
 		if ( ((action>>8)&0xFF) == 0x0D ||
 			 ((action>>8)&0xFF) == ' ' ) {
-			EndPoly(context, segCnt);
-			context->State = 0;
+			if ((context->Op == OP_POLY) || (context->Op == OP_FILLPOLY) || (context->Op == OP_POLYLINE)) {
+				tempSegs_da.cnt = segCnt;
+				//If last segment wasn't just a point, add another starting on its end
+				if (!IsClose(FindDistance(tempSegs(segCnt-1).u.l.pos[0],tempSegs(segCnt-1).u.l.pos[1]))) {
+					DYNARR_APPEND(trkSeg_t,tempSegs_da,1);
+					segPtr = &tempSegs(tempSegs_da.cnt-1);
+					segPtr->type = SEG_STRLIN;
+					segPtr->u.l.pos[0] = segPtr[-1].u.l.pos[1];
+					segPtr->u.l.pos[1] = tempSegs(0).u.l.pos[0];
+				}
+                EndPoly(context, tempSegs_da.cnt, context->Op == OP_POLYLINE);
+                DYNARR_RESET(pts_t, points_da);
+				DYNARR_RESET(trkSeg_t,tempSegs_da);
+			} else {
+				if (context->State == 2)
+					tempSegs_da.cnt = segCnt;
+				DrawGeomOk();
+			}
 		}
+		context->State = 0;
+		segCnt = 0;
 		return C_TERMINATE;
 
 	case C_CANCEL:
-
-		oldOptions = context->D->funcs->options;
-		context->D->funcs->options |= wDrawOptTemp;
-		DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-		context->D->funcs->options = oldOptions;
+		if (context->Changed) {				//If the update values were shown
+			if (context->State == 2) {
+				tempSegs_da.cnt = segCnt;
+				DrawGeomOk();
+			}
+		}
+		DYNARR_RESET(trkSeg_t, anchors_da );
 		tempSegs_da.cnt = 0;
 		context->message( "" );
 		context->Changed = FALSE;
+		context->State = 0;
+		segCnt = 0;
 		lastValid = FALSE;
 		return C_TERMINATE;
 
 	case C_REDRAW:
-		oldOptions = context->D->funcs->options;
-		context->D->funcs->options |= wDrawOptTemp;
-		DrawSegs( context->D, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
-		context->D->funcs->options = oldOptions;
+		DrawSegs( &tempD, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack );
+		if (anchors_da.cnt > 0) {
+			DrawSegs( &tempD, zero, 0.0, &anchors(0), anchors_da.cnt, 0.0, wDrawColorBlack );
+		}
 		return C_CONTINUE;
 		
+	case C_CMDMENU:
+
+		return C_CONTINUE;
+
 	default:
 		return C_CONTINUE;
 	}
 }
+static int polyInx;
+static int lineInx;
+static int curveInx;
+
+typedef enum {POLY_NONE, POLY_SELECTED, POLYPOINT_SELECTED} PolyState_e;
+static PolyState_e polyState = POLY_NONE;
+static coOrd rotate_origin;
+static ANGLE_T rotate_angle;
+static dynArr_t origin_da;
+
+
+void static CreateCircleAnchor(wBool_t selected,coOrd center, DIST_T rad, ANGLE_T angle) {
+	DYNARR_RESET(trkSeg_t,anchors_da);
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,2);
+	anchors(0).type = (selected)?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(0).u.c.a1 = 360.0;
+	anchors(0).color = wDrawColorBlue;
+	anchors(0).u.c.radius = d/2;
+	PointOnCircle(&anchors(0).u.c.center,center,rad,angle);
+}
 
+void static CreateLineAnchors(int index, coOrd p0, coOrd p1) {
+	DYNARR_RESET(trkSeg_t,anchors_da);
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,2);
+	anchors(0).type = (index ==0)?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(0).u.c.a1 = 360.0;
+	anchors(0).color = wDrawColorBlue;
+	anchors(0).u.c.radius = d/2;
+	anchors(0).u.c.center = p0;
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	anchors(1).type = (index ==1)?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(1).u.c.a1 = 360.0;
+	anchors(1).color = wDrawColorBlue;
+	anchors(1).u.c.radius = d/2;
+	anchors(1).u.c.center = p1;
+}
+void static CreateBoxAnchors(int index, pts_t pt[4]) {
+	DYNARR_RESET(trkSeg_t,anchors_da);
+	double d = tempD.scale*0.15;
+	ANGLE_T a = FindAngle(pt[0].pt,pt[1].pt);
+	ANGLE_T diag = FindAngle(pt[0].pt,pt[2].pt);
+	for (int i=0;i<4;i++) {
+		DYNARR_SET(trkSeg_t,anchors_da,anchors_da.cnt+5);
+		DrawArrowHeads(&DYNARR_N(trkSeg_t,anchors_da,anchors_da.cnt-5),pt[i].pt,(diag>a?45.0:-45.0)+a+(90.0*(i)),TRUE,i==index?wDrawColorRed:wDrawColorBlue);
+	}
+	coOrd pp;
+	for (int i=0;i<4;i++) {
+		pp.x = (i==3?((((pt[0].pt.x - pt[i].pt.x)/2))+pt[i].pt.x):((pt[i+1].pt.x - pt[i].pt.x)/2)+pt[i].pt.x);
+		pp.y = (i==3?((((pt[0].pt.y - pt[i].pt.y)/2))+pt[i].pt.y):((pt[i+1].pt.y - pt[i].pt.y)/2)+pt[i].pt.y);
 
+		DYNARR_SET(trkSeg_t,anchors_da,anchors_da.cnt+5);
+		DrawArrowHeads(&DYNARR_N(trkSeg_t,anchors_da,anchors_da.cnt-5),pp,90.0*(i-1)+a,TRUE,i==index+5?wDrawColorRed:wDrawColorBlue);
+	}
+}
+
+void static CreateOriginAnchor(coOrd origin, wBool_t trans_selected) {
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,2);
+	int i = anchors_da.cnt-1;
+	coOrd p0,p1;
+	Translate(&p0,origin,0,d*4);
+	Translate(&p1,origin,0,-d*4);
+	anchors(i).type = SEG_STRLIN;
+	anchors(i).u.l.pos[0] = p0;
+	anchors(i).u.l.pos[1] = p1;
+	anchors(i).color = wDrawColorBlue;
+	anchors(i).width = 0;
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	Translate(&p0,origin,90,d*4);
+	Translate(&p1,origin,90,-d*4);
+	i = anchors_da.cnt-1;
+	anchors(i).type = SEG_STRLIN;
+	anchors(i).u.l.pos[0] = p0;
+	anchors(i).u.l.pos[1] = p1;
+	anchors(i).color = wDrawColorBlue;
+	anchors(i).width = 0;
+}
+
+void static CreateCurveAnchors(int index, coOrd pm, coOrd pc, coOrd p0, coOrd p1) {
+	DYNARR_RESET(trkSeg_t,anchors_da);
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,9);
+	anchors(0).type = (index ==0)?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(0).u.c.a1 = 360.0;
+	anchors(0).color = wDrawColorBlue;
+	anchors(0).u.c.radius = d/2;
+	anchors(0).u.c.center = p0;
+	anchors(0).width = 0;
+	DYNARR_APPEND(trkSeg_t,anchors_da,8);
+	anchors(1).type = (index ==1)?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(1).u.c.a1 = 360.0;
+	anchors(1).color = wDrawColorBlue;
+	anchors(1).u.c.radius = d/2;
+	anchors(1).u.c.center = p1;
+	anchors(1).width = 0;
+	DYNARR_SET(trkSeg_t,anchors_da,anchors_da.cnt+5);
+	DrawArrowHeads(&DYNARR_N(trkSeg_t,anchors_da,anchors_da.cnt-5),pm,FindAngle(pm,pc),TRUE,index==2?wDrawColorAqua:wDrawColorBlue);
+}
+
+void static CreatePolyAnchors(int index) {
+		DYNARR_RESET(trkSeg_t,anchors_da);
+		double d = tempD.scale*0.15;
+		for ( int inx=0; inx<points_da.cnt; inx++ ) {
+			DYNARR_APPEND(trkSeg_t,anchors_da,3);
+
+			anchors(inx).type = point_selected(inx)?SEG_FILCRCL:SEG_CRVLIN;
+			anchors(inx).u.c.a0 = 0.0;
+			anchors(inx).u.c.a1 = 360.0;
+			anchors(inx).width = 0;
+			anchors(inx).color = wDrawColorBlue;
+			anchors(inx).u.c.radius = d/2;
+			anchors(inx).u.c.center = points(inx).pt;
+		}
+		if (index>=0) {
+			DYNARR_APPEND(trkSeg_t,anchors_da,1);
+			int inx = anchors_da.cnt-1;
+			anchors(inx).type = SEG_STRLIN;
+			anchors(inx).u.l.pos[0] = points(index==0?points_da.cnt-1:index-1).pt;
+			anchors(inx).u.l.pos[1] = points(index).pt;
+			anchors(inx).color = wDrawColorBlue;
+			anchors(inx).width = 0;
+			DYNARR_APPEND(trkSeg_t,anchors_da,1);
+			inx = anchors_da.cnt-1;
+			int index0 = index==0?points_da.cnt-1:index-1;
+			ANGLE_T an0 = FindAngle(points(index0).pt, points(index).pt);
+			ANGLE_T an1 = FindAngle(points(index0==0?points_da.cnt-1:index0-1).pt, points(index0).pt);
+			anchors(inx).type = SEG_CRVLIN;
+			if (DifferenceBetweenAngles(an0,an1)<=0) {
+				anchors(inx).u.c.a1 = DifferenceBetweenAngles(an0,an1)-180;
+				anchors(inx).u.c.a0 = an0;
+			} else {
+				anchors(inx).u.c.a1 = 180-DifferenceBetweenAngles(an0,an1);
+				anchors(inx).u.c.a0 = NormalizeAngle(180+an1);
+			}
+			anchors(inx).color = wDrawColorBlue;
+			anchors(inx).u.c.radius = d;
+			anchors(inx).u.c.center = points(index0).pt;
+		}
+}
+
+void CreateMovingAnchor(coOrd pos,BOOL_T fill) {
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	int inx = anchors_da.cnt-1;
+	anchors(inx).type = fill?SEG_FILCRCL:SEG_CRVLIN;
+	anchors(inx).u.c.a0 = 0.0;
+	anchors(inx).u.c.a1 = 360.0;
+	anchors(inx).width = 0;
+	anchors(inx).color = wDrawColorBlue;
+	anchors(inx).u.c.radius = d/4;
+	anchors(inx).u.c.center = pos;
+}
+
+/*
+ * Modify Polygons. Polygons have a variable number of nodes.
+ *
+ * Each point has an anchor and selecting the node allows it to be moved
+ * Selecting a point between nodes adds a node ready for dragging
+ * The last selected node can be deleted
+ *
+ */
+STATUS_T DrawGeomPolyModify(
+				wAction_t action,
+				coOrd pos,
+				drawModContext_t *context) {
+	double d;
+	static int selected_count;
+	static int segInx;
+	static int prev_inx;
+	static wDrawColor save_color;
+	static wBool_t drawnAngle;
+	static double currentAngle;
+	static double baseAngle;
+	static BOOL_T lock;
+
+	switch ( action&0xFF ) {
+		case C_START:
+			lock = FALSE;
+			DistanceSegs( context->orig, context->angle, context->segCnt, context->segPtr, &pos, &segInx );
+			if (segInx == -1)
+				return C_ERROR;
+			if (context->type != SEG_POLY && context->type != SEG_FILPOLY)
+				return C_ERROR;
+			prev_inx = -1;
+			polyState = POLY_SELECTED;
+			polyInx = -1;
+			//Copy points
+			DYNARR_RESET( pts_t, points_da);
+			DYNARR_RESET( wBool_t, select_da);
+			for (int inx=0;inx<context->segPtr->u.p.cnt;inx++) {
+				DYNARR_APPEND(pts_t, points_da,3);
+				DYNARR_APPEND(wBool_t,select_da,3);
+				REORIGIN( points(inx).pt, context->segPtr[segInx].u.p.pts[inx].pt, context->angle, context->orig );
+				points(inx).pt_type = context->segPtr[segInx].u.p.pts[inx].pt_type;
+				point_selected(inx) = FALSE;
+			}
+			context->prev_inx = -1;
+			context->max_inx = points_da.cnt-1;
+			selected_count=0;
+			rotate_origin = context->orig;
+			rotate_angle = context->angle;
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
+			//Show points
+			tempSegs_da.cnt = 1;
+			tempSegs(0).width = context->segPtr->width;
+			save_color = context->segPtr->color;
+			tempSegs(0).color = wDrawColorRed;
+			tempSegs(0).type = context->type;
+			tempSegs(0).u.p.cnt = context->segPtr[segInx].u.p.cnt;
+			tempSegs(0).u.p.angle = 0.0;
+			tempSegs(0).u.p.orig = zero;
+			tempSegs(0).u.p.polyType = context->segPtr[segInx].u.p.polyType;
+			tempSegs(0).u.p.pts = &points(0);
+			CreatePolyAnchors( -1);
+			InfoMessage(_("Select points or use context menu"));
+			ClrAllTrkBitsRedraw( TB_UNDRAWN, TRUE );
+			UndrawNewTrack( context->trk );
+			return C_CONTINUE;
+		case wActionMove:
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			CreatePolyAnchors(context->prev_inx);
+			for (int i = 0; i<points_da.cnt; i++) {
+				if (IsClose(FindDistance(pos,points(i).pt))) {
+					CreateMovingAnchor(points(i).pt,TRUE);
+					return C_CONTINUE;
+				}
+			}
+			int pInx=0;
+			coOrd pm0,pm1;
+			DIST_T dm = 10000.0;
+			for ( int inx=0; inx<points_da.cnt; inx++ ) {
+				pm0 = pos;
+				DIST_T ddm = LineDistance( &pm0, points( inx==0?points_da.cnt-1:inx-1).pt, points(inx).pt );
+				if ( dm > ddm ) {
+					dm = ddm;
+					pm1 = pm0;
+					pInx = inx;
+				}
+			}
+			if (!IsClose(dm)) return C_CONTINUE;
+			int inxm = pInx==0?points_da.cnt-1:pInx-1;
+			dm = FindDistance( points(inxm).pt, pm1 );
+			DIST_T ddm = FindDistance( points(inxm).pt, points(pInx).pt );
+			if ( (dm > 0.25*ddm) && (dm < 0.75*ddm)) {
+				CreateMovingAnchor(pm1,FALSE);
+			} else {
+				if (dm < FindDistance( points(pInx).pt, pm1 ))
+					CreateMovingAnchor(points(inxm).pt,TRUE);
+				else
+					CreateMovingAnchor(points(pInx).pt,TRUE);
+			}
+			return C_CONTINUE;
+			break;
+		case C_DOWN:
+			d = 10000.0;
+			polyInx = -1;
+			coOrd p0;
+			double dd;
+			int inx;
+			if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) != WKEY_SHIFT) {
+				if (selected_count <2 ) {
+					//Wipe out selection(s) if we don't have multiple already (i,e. move with >1 selected)
+					for (int i=0;i<points_da.cnt;i++) {
+						point_selected(i) = FALSE;
+					}
+					selected_count = 0;
+				} else {
+					for (int i=0;i<points_da.cnt;i++) {
+						if (IsClose(FindDistance(pos,points(i).pt)) && point_selected(i)==TRUE) {
+							point_selected(i) = FALSE;
+							selected_count--;
+						}
+					}
+				}
+			}
+			//Select Point (polyInx)
+			for ( int inx=0; inx<points_da.cnt; inx++ ) {
+				p0 = pos;
+				dd = LineDistance( &p0, points( inx==0?points_da.cnt-1:inx-1).pt, points(inx).pt );
+				if ( d > dd ) {
+					d = dd;
+					polyInx = inx;
+				}
+			}
+			if (!IsClose(d)) {	//Not on/near object - de-select all points
+				for (int i=0;i<points_da.cnt;i++) {
+					point_selected(i) = FALSE;
+				}
+				polyInx = -1;
+				selected_count = 0;
+				CreatePolyAnchors( -1);
+				context->prev_inx = -1;
+				return C_CONTINUE; //Not close to any line
+			}
+			polyState = POLYPOINT_SELECTED;
+			inx = polyInx==0?points_da.cnt-1:polyInx-1;
+			//Find if the point is to be added
+			d = FindDistance( points(inx).pt, pos );
+			dd = FindDistance( points(inx).pt, points(polyInx).pt );
+			if ( d < 0.25*dd ) {
+				polyInx = inx;
+			} else if ( d > 0.75*dd ) {
+				;
+			} else {
+				if (selected_count == 0) {					//Only add a new point if no points are already selected!
+					DYNARR_APPEND(wBool_t,select_da,1);
+					for (int i=0;i<select_da.cnt;i++) {
+						if (i == polyInx) point_selected(i) = TRUE;
+						else point_selected(i) = FALSE;
+					}
+					selected_count=1;
+					DYNARR_APPEND(pts_t,points_da,1);
+					tempSegs(0).u.p.pts = &points(0);
+					for (inx=points_da.cnt-1; inx>polyInx; inx-- ) {
+						points(inx) = points(inx-1);
+					}
+					points(polyInx).pt_type = wPolyLineStraight;
+					tempSegs(0).u.p.cnt = points_da.cnt;
+					context->max_inx = points_da.cnt-1;
+				}
+			}
+			//If already selected (multiple points), not using shift (to add) select, and on object move to first point
+			if (selected_count>0 && ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) != WKEY_SHIFT)) {
+				for (int i=0; i<points_da.cnt;i++) {
+					if (IsClose(FindDistance(pos,points(i).pt))) {
+
+						point_selected(i) = FALSE;
+
+					}
+					if (point_selected(i) == TRUE) {
+						polyInx = i;
+					}
+				}
+			}
+			pos = points(polyInx).pt;  		//Move to point
+			if (point_selected(polyInx)) {					//Already selected
+			} else {
+				point_selected(polyInx) = TRUE;
+				++selected_count;
+			}
+			//Work out before and after point
+			int first_inx = -1;
+			if (selected_count >0 && selected_count < points_da.cnt-2) {
+				for (int i=0; i<points_da.cnt;i++) {
+					if (point_selected(i)) {
+						first_inx = i;
+						break;
+					}
+				}
+			}
+			int last_inx = -1, next_inx = -1;
+			ANGLE_T an1, an0;
+			if (first_inx >=0) {
+				if (first_inx == 0) {
+					last_inx = points_da.cnt-1;
+				} else {
+					last_inx = first_inx-1;
+				}
+				if (first_inx == points_da.cnt-1) {
+					next_inx = 0;
+				} else {
+					next_inx = first_inx+1;
+				}
+				context->length = FindDistance(points(last_inx).pt,points(first_inx).pt);
+				an1 = FindAngle(points(last_inx).pt,points(first_inx).pt);
+				an0 = FindAngle(points(last_inx==0?(points_da.cnt-1):(last_inx-1)).pt,points(last_inx).pt);
+				if (DifferenceBetweenAngles(an0,an1)<=0) {
+					context->rel_angle = 180+DifferenceBetweenAngles(an0,an1);
+				} else {
+					context->rel_angle = 180-DifferenceBetweenAngles(an0,an1);
+				}
+			} else {
+
+			}
+			context->prev_inx = first_inx;
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
+			//Show three anchors only
+			CreatePolyAnchors(first_inx);
+			return C_CONTINUE;
+		case C_LDOUBLE:
+			return C_CONTINUE;
+		case C_MOVE:
+			tempSegs_da.cnt = 1;
+			if (polyState != POLYPOINT_SELECTED) {
+				return C_CONTINUE;
+			}
+			//Moving with Point Selected
+			if (polyInx<0) return C_ERROR;
+			first_inx = -1;
+			if (selected_count >0 && selected_count < points_da.cnt-2) {
+				for (int i=0; i<points_da.cnt;i++) {
+					if (point_selected(i)) {
+						first_inx = i;
+						break;
+					}
+				}
+			}
+			last_inx = -1;
+			next_inx = -1;
+			coOrd intersect;
+			wBool_t show_intersect = FALSE;
+			if (first_inx >=0) {
+				if (first_inx == 0) {
+					last_inx = points_da.cnt-1;
+				} else {
+					last_inx = first_inx-1;
+				}
+				if (first_inx == points_da.cnt-1) {
+					next_inx = 0;
+				} else {
+					next_inx = first_inx+1;
+				}
+				//Lock to 90 degrees first/last point
+				if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_SHIFT ) {
+					ANGLE_T last_angle,next_angle;
+					coOrd last_point,next_point;
+					if (first_inx == 0) {
+						last_point = points(points_da.cnt-1).pt;
+						last_angle = FindAngle(points(points_da.cnt-2).pt,last_point);
+					} else if (first_inx == 1) {
+						last_point = points(0).pt;
+						last_angle = FindAngle(points(points_da.cnt-1).pt,last_point);
+					} else {
+						last_point = points(first_inx-1).pt;
+						last_angle = FindAngle(points(first_inx-2).pt,last_point);
+					}
+					if (first_inx == points_da.cnt-1) {
+						next_point = points(0).pt;
+						next_angle = FindAngle(next_point,points(1).pt);
+					} else if (first_inx == points_da.cnt-2){
+						next_point = points(points_da.cnt-1).pt;
+						next_angle = FindAngle(next_point,points(0).pt);
+					} else {
+						next_point = points(first_inx+1).pt;
+						next_angle = FindAngle(next_point,points(first_inx+2).pt);
+					}
+					coOrd diff;
+					diff.x = pos.x - points(polyInx).pt.x;
+					diff.y = pos.y - points(polyInx).pt.y;
+					coOrd pos_lock = points(first_inx).pt;
+					pos_lock.x += diff.x;
+					pos_lock.y += diff.y;
+					//Snap to Right-Angle from previous or from 0
+					DIST_T l = FindDistance(last_point, pos_lock);
+					ANGLE_T angle2 = NormalizeAngle(FindAngle(last_point, pos_lock)-last_angle);
+					int quad = (int)((angle2+45.0)/90.0);
+					if (tempSegs_da.cnt != 1 && (quad == 2)) {
+						pos_lock = last_point;
+					} else if (quad == 1 || quad == 3) {
+						l = fabs(l*cos(D2R(((quad==1)?last_angle+90.0:last_angle-90.0)-FindAngle(pos_lock,last_point))));
+						Translate( &pos_lock, last_point, NormalizeAngle((quad==1)?last_angle+90.0:last_angle-90.0), l );
+					} else {
+						l = fabs(l*cos(D2R(((quad==0||quad==4)?last_angle:last_angle+180.0)-FindAngle(pos_lock,last_point))));
+						Translate( &pos_lock, last_point, NormalizeAngle((quad==0||quad==4)?last_angle:last_angle+180.0), l );
+					}
+					diff.x = pos_lock.x - points(first_inx).pt.x;
+					diff.y = pos_lock.y - points(first_inx).pt.y;
+					pos.x 	= points(polyInx).pt.x+diff.x;
+					pos.y 	= points(polyInx).pt.y+diff.y;
+					if (selected_count<2) {
+						if (FindIntersection(&intersect,last_point,last_angle+90.0,next_point,last_angle+180.0)) {
+							show_intersect = TRUE;
+						}
+					}
+					d = FindDistance(intersect,pos_lock);
+					if (IsClose(d)) {
+						pos = intersect;
+					}
+					InfoMessage( _("Length = %s, Last angle = %0.2f"),
+							FormatDistance(FindDistance(pos_lock,last_point)),
+							PutAngle(FindAngle(pos_lock,last_point)));
+
+				}
+			}
+			context->prev_inx = first_inx;
+			coOrd diff;
+			diff.x = pos.x - points(polyInx).pt.x;
+			diff.y = pos.y - points(polyInx).pt.y;
+			//points(polyInx) = pos;
+			for (int i=0;i<points_da.cnt;i++) {
+				if (point_selected(i)) {
+					points(i).pt.x = points(i).pt.x + diff.x;
+					points(i).pt.y = points(i).pt.y + diff.y;
+				}
+			}
+			if (first_inx>=0) {
+				context->length = FindDistance(points(first_inx).pt,points(last_inx).pt);
+				an1 = FindAngle(points(last_inx).pt,points(first_inx).pt);
+				an0 = FindAngle(points(first_inx==0?(points_da.cnt-1):(first_inx-1)).pt,points(first_inx).pt);
+				context->rel_angle = NormalizeAngle(180-(an1-an0));
+			}
+			CreatePolyAnchors(first_inx);
+			if (show_intersect)
+				CreateSquareAnchor(intersect);
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
+			return C_CONTINUE;
+		case C_UP:
+			context->prev_inx = -1;
+			if (segInx == -1 || polyState != POLYPOINT_SELECTED)
+				return C_CONTINUE;   //Didn't get a point selected/added
+			polyState = POLY_SELECTED;  //Return to base state
+			anchors_da.cnt = 0;
+			CreatePolyAnchors(polyInx);  //Show last selection
+			prev_inx = polyInx;
+			for (int i=0;i<points_da.cnt;i++) {
+				if (point_selected(i)) {
+					first_inx = i;
+					break;
+				}
+			}
+			last_inx = first_inx==0?(points_da.cnt-1):(first_inx-1);
+			if (first_inx>=0) {
+				context->length = FindDistance(points(first_inx).pt,points(last_inx).pt);
+				an1 = FindAngle(points(last_inx).pt,points(first_inx).pt);
+				an0 = FindAngle(points(last_inx==0?(points_da.cnt-1):(last_inx-1)).pt,points(last_inx).pt);
+				if (DifferenceBetweenAngles(an0,an1)<=0) {
+					context->rel_angle = 180+DifferenceBetweenAngles(an0,an1);
+				} else {
+					context->rel_angle = 180-DifferenceBetweenAngles(an0,an1);
+				}
+			}
+			context->prev_inx = first_inx;
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
+			polyInx = -1;
+			return C_CONTINUE;
+		case C_UPDATE:
+			if (context->prev_inx>=0) {
+				int last_index = context->prev_inx==0?(points_da.cnt-1):(context->prev_inx-1);
+				an0 = FindAngle(points(last_index==0?(points_da.cnt-1):(last_index-1)).pt,points(last_index).pt);
+				an1 = FindAngle(points(last_index).pt,points(context->prev_inx).pt);
+				if (DifferenceBetweenAngles(an0,an1)<=0) {
+					an1 = NormalizeAngle(an0-(180-context->rel_angle));
+				} else {
+					an1 = NormalizeAngle((180-context->rel_angle)+an0);
+				}
+				Translate(&points(prev_inx).pt,points(last_index).pt,an1,context->length);
+			}
+			context->rel_angle = fabs(context->rel_angle);
+			if (context->rel_angle >180) context->rel_angle = context->rel_angle - 180.0;
+			CreatePolyAnchors(prev_inx);
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
+			break;
+		case C_TEXT:
+			if (action>>8 == 'o') {  //"o" -> origin mode
+				MenuMode(1);
+				InfoMessage("Move Origin Mode: Place Origin, p for Points, Enter or Esc");
+				return C_CONTINUE;
+			}
+			if (((prev_inx>=0 && tempSegs(0).u.p.polyType != POLYLINE) || (prev_inx>=1 && prev_inx<=points_da.cnt-2)) &&
+					((action>>8 == 's') || (action>>8 == 'v') || (action>>8 == 'r')))  {
+				switch(action>>8) {
+				case 's':
+					points(context->prev_inx).pt_type = wPolyLineSmooth;
+					break;
+				case 'v':
+					points(context->prev_inx).pt_type = wPolyLineStraight;
+					break;
+				case 'r':
+					points(context->prev_inx).pt_type = wPolyLineRound;
+					break;
+				default:
+					return C_CONTINUE;
+				}
+			}
+			if ((action>>8 == 'g') && (tempSegs(0).type == SEG_POLY) && (tempSegs(0).u.p.polyType == POLYLINE) ) {
+				tempSegs(0).u.p.polyType = FREEFORM;
+				context->subtype=FREEFORM;
+				context->open = FALSE;
+				CreatePolyAnchors( -1);
+				return C_CONTINUE;
+			}
+			if ((action>>8 == 'l') && (tempSegs(0).type == SEG_POLY) && (tempSegs(0).u.p.polyType == FREEFORM)) {
+				tempSegs(0).u.p.polyType = POLYLINE;
+				context->subtype=POLYLINE;
+				context->open = TRUE;
+				CreatePolyAnchors( -1);
+				return C_CONTINUE;
+			}
+			if ((action>>8 == 'f') && (tempSegs(0).type == SEG_POLY) && (tempSegs(0).u.p.polyType != POLYLINE )) {
+				tempSegs(0).type = SEG_FILPOLY;
+				context->type =  SEG_FILPOLY;
+				context->filled = TRUE;
+				CreatePolyAnchors( -1);
+				return C_CONTINUE;
+			}
+			if ((action>>8 == 'u') && (tempSegs(0).type == SEG_FILPOLY) ) {
+				tempSegs(0).type = SEG_POLY;
+				context->type =  SEG_POLY;
+				context->filled = FALSE;
+				CreatePolyAnchors( -1);
+				return C_CONTINUE;
+			}
+			//Delete or backspace deletes last selected index
+			if (action>>8 == 127 || action>>8 == 8) {
+				if (polyState == POLY_SELECTED && prev_inx >=0) {
+					if (selected_count >1) {
+						ErrorMessage( MSG_POLY_MULTIPLE_SELECTED );
+						return C_CONTINUE;
+					}
+					if (points_da.cnt <= 3) {
+						ErrorMessage( MSG_POLY_SHAPES_3_SIDES );
+						return C_CONTINUE;
+					}
+					for (int i=0;i<points_da.cnt;i++) {
+						point_selected(i) = FALSE;
+						if (i>=prev_inx && i<points_da.cnt-1)
+							points(i) = points(i+1);
+					}
+					points_da.cnt--;
+					select_da.cnt--;
+					selected_count=0;
+					tempSegs(0).u.p.cnt = points_da.cnt;
+					context->max_inx = points_da.cnt-1;
+				}
+				prev_inx = -1;
+				context->prev_inx = -1;
+				polyInx = -1;
+				polyState = POLY_SELECTED;
+				CreatePolyAnchors( -1);
+				InfoMessage(_("Point Deleted"));
+				return C_CONTINUE;
+			}
+			if (action>>8 != 32 && action>>8 != 13) return C_CONTINUE;
+			/* no break */
+		case C_FINISH:
+			//copy changes back into track
+			if (polyState != POLY_SELECTED) return C_TERMINATE;
+			pts_t * oldPts = context->segPtr[segInx].u.p.pts;
+			void * newPts = (pts_t*)MyMalloc( points_da.cnt * sizeof (pts_t) );
+			context->segPtr[segInx].u.p.pts = newPts;
+			context->segPtr->u.p.cnt = points_da.cnt;
+			context->orig = rotate_origin;
+			context->angle = rotate_angle;
+			for (int i=0; i<points_da.cnt; i++) {
+				pos = points(i).pt;
+				pos.x -= context->orig.x;
+				pos.y -= context->orig.y;
+				Rotate( &pos, zero, -context->angle );
+				context->segPtr[segInx].u.p.pts[i].pt = pos;
+				context->segPtr[segInx].u.p.pts[i].pt_type = points(i).pt_type;
+			}
+			MyFree(oldPts);
+			oldPts = NULL;
+			polyState = POLY_NONE;
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			DYNARR_RESET(trkSeg_t,tempSegs_da);
+			DrawNewTrack( context->trk );
+			return C_TERMINATE;
+		case C_REDRAW:
+			if (polyState == POLY_NONE) return C_CONTINUE;
+			DrawSegs( &tempD, zero, 0.0, &tempSegs(0), tempSegs_da.cnt,trackGauge, wDrawColorBlack);
+			DrawSegs( &tempD, zero, 0.0, &anchors(0), anchors_da.cnt, trackGauge, wDrawColorBlack );
+			break;
+		default:
+			;
+		}
+		return C_CONTINUE;
+}
+
+void BuildCircleContext(drawModContext_t * context,int segInx) {
+	context->radius = fabs(context->segPtr[segInx].u.c.radius);
+	REORIGIN( context->pc, context->segPtr[segInx].u.c.center, context->angle, context->orig );
+	PointOnCircle( &context->p0, context->segPtr[segInx].u.c.center, fabs(context->segPtr[segInx].u.c.radius), context->segPtr[segInx].u.c.a0 );
+	REORIGIN( context->p0, context->p0, context->angle, context->orig );
+	PointOnCircle( &context->p1, context->segPtr[segInx].u.c.center, fabs(context->segPtr[segInx].u.c.radius), context->segPtr[segInx].u.c.a0 + context->segPtr[segInx].u.c.a1);
+	REORIGIN( context->p1, context->p1, context->angle, context->orig );
+	if (context->segPtr[segInx].u.c.a1<360) {
+		context->arc_angle = context->segPtr[segInx].u.c.a1;
+		PointOnCircle( &context->pm, context->segPtr[segInx].u.c.center, fabs(context->segPtr[segInx].u.c.radius), context->segPtr[segInx].u.c.a0 + (context->segPtr[segInx].u.c.a1/2));
+		REORIGIN( context->pm, context->pm, context->angle, context->orig );
+		coOrd cm;
+		cm = context->pm;
+		ANGLE_T a = FindAngle(context->p1,context->p0);
+		Rotate(&cm,context->p1,-a );
+		context->disp = cm.x-context->p1.x;
+	} else {
+		context->pm = context->p0;
+		context->disp = 0;
+		context->arc_angle = 360.0;
+	}
+}
+
+void CreateSelectedAnchor(coOrd pos) {
+	double d = tempD.scale*0.15;
+	DYNARR_APPEND(trkSeg_t,anchors_da,1);
+	int inx = anchors_da.cnt-1;
+	anchors(inx).type = SEG_FILCRCL;
+	anchors(inx).u.c.a0 = 0.0;
+	anchors(inx).u.c.a1 = 360.0;
+	anchors(inx).color = wDrawColorBlue;
+	anchors(inx).u.c.radius = d/2;
+	anchors(inx).u.c.center = pos;
+}
+
+/*
+ * Rotate Object Dialogs.
+ *
+ *  Each Draw object has a rotation origin which all the points are offset from.
+ *  Formerly this has been set to the origin, but it doesn't have to be. By setting
+ *  to a point on the shape this allows assembly by aligning parts to a common point on a base object.
+ *  The angle is always set to zero when the Modify finishes but can be altered via Describe.
+ *
+ *  First locate the origin, and then place a rotation arm which is (optionally) rotated about the origin.
+ *  Also supports whole object translate using translate anchor.
+ **/
+
+STATUS_T DrawGeomOriginMove(
+		wAction_t action,
+		coOrd pos,
+		drawModContext_t * context) {
+
+	switch ( action&0xFF ) {
+		case C_START:
+			context->state = MOD_ORIGIN;
+			context->rotate_state = TRUE;
+			context->rot_moved = TRUE;
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			CreateOriginAnchor(context->rot_center,FALSE);
+			if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+				CreateSelectedAnchor(points(context->prev_inx).pt);
+			}
+			InfoMessage("Move Origin Mode: Place Origin, 0-4, c or l, Enter or Esc");
+			return C_CONTINUE;
+			break;
+		case wActionMove:
+			CreateOriginAnchor(context->rot_center, TRUE);
+			if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+				CreateSelectedAnchor(points(context->prev_inx).pt);
+			}
+			return C_CONTINUE;
+			break;
+		case C_DOWN:
+			if (context->state == MOD_ORIGIN || context->state == MOD_AFTER_ORIG) {
+				context->state = MOD_ORIGIN;
+				DYNARR_RESET(trkSeg_t,anchors_da);
+				if (IsClose(FindDistance(pos,context->rot_center))) {
+					pos = context->rot_center;
+				} else {
+					context->rot_center = pos;
+				}
+				CreateOriginAnchor(context->rot_center, TRUE);
+				if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+					CreateSelectedAnchor(points(context->prev_inx).pt);
+				}
+			}
+			return C_CONTINUE;
+			break;
+		case C_MOVE:
+			if (context->state == MOD_ORIGIN || context->state == MOD_AFTER_ORIG){
+				context->rot_center = pos;
+				DYNARR_RESET(trkSeg_t,anchors_da);
+				CreateOriginAnchor(context->rot_center, TRUE);
+				if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+					CreateSelectedAnchor(points(context->prev_inx).pt);
+				}
+			}
+			return C_CONTINUE;
+			break;
+		case C_UP:
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			if (context->state == MOD_ORIGIN) {
+				context->state = MOD_AFTER_ORIG;
+			}
+			CreateOriginAnchor(context->rot_center,FALSE);
+			if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+				CreateSelectedAnchor(points(context->prev_inx).pt);
+			}
+			return C_CONTINUE;
+			break;
+		case C_UPDATE:
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			if (context->state == MOD_AFTER_ORIG) {
+				if (context->rot_center.x != context->rel_center.x &&
+					context->rot_center.y != context->rel_center.y ) {
+					context->rel_center = context->rot_center;
+					CreateOriginAnchor(context->rot_center, FALSE);
+					if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+						CreateSelectedAnchor(points(context->prev_inx).pt);
+					}
+				}
+			}
+			return C_CONTINUE;
+			break;
+		case C_TEXT:
+			if ((context->state == MOD_ORIGIN || context->state == MOD_AFTER_ORIG) &&
+				((action>>8 >= '0' && action>>8 <= '1') || action>>8 == 'l' || action>>8 == 'm' || action>>8 == 'p')) {
+				// 0,1,2,3,4 -> reset rot center
+				if (action>>8 == '0') {
+					context->rot_center = zero;
+				} else if (action>>8 == '1') {
+					context->rot_center = context->p0;
+				} else if (action>>8 == '2') {
+					context->rot_center = context->p1;
+				} else if (tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) {
+					if (action>>8 == '3' || action>>8 == '4') {
+						context->rot_center = action>>8 == '3'?points(2).pt:points(3).pt;
+					} else if (action>>8 == 'l') {   //"l" - last selected
+						if (context->prev_inx !=-1) {
+							context->rot_center = points(context->prev_inx).pt;
+						}
+					} else if (action>>8 == 'm') {
+						context->rot_center = FindCentroid(points_da.cnt,&points(0));
+					}
+				}
+				if (action>>8 == 'p') {     //"p" - points mode
+					MenuMode(0);
+					return C_CONTINUE;
+				}
+				context->rel_center = context->rot_center;
+				context->rot_angle = 0;
+				DYNARR_RESET(trkSeg_t,anchors_da);
+				context->state = MOD_AFTER_ORIG;
+				CreateOriginAnchor(context->rot_center, FALSE);
+				if ((tempSegs(0).type == SEG_POLY || tempSegs(0).type == SEG_FILPOLY) && (context->prev_inx>=0)) {
+					CreateSelectedAnchor(points(context->prev_inx).pt);
+				}
+				return C_CONTINUE;
+			}
+			break;
+		case C_FINISH:
+			context->rotate_state = FALSE;
+			context->state = MOD_STARTED;
+			return C_CONTINUE;
+			break;
+		default:
+			break;
+	}
+	return C_CONTINUE;
+
+
+}
+
+/*
+ * Base Modify function for Draw objects.
+ */
 STATUS_T DrawGeomModify(
-		coOrd orig,
-		ANGLE_T angle,
-		wIndex_t segCnt,
-		trkSeg_p segPtr,
 		wAction_t action,
 		coOrd pos,
-		wBool_t selected)
+		drawModContext_t * context)
 {
 	ANGLE_T a;
-	coOrd p0, p1, pc;
+	coOrd p0, p1, pc, pm;
 	static coOrd start_pos;
 	static wIndex_t segInx;
 	static EPINX_T segEp;
 	static ANGLE_T segA1;
-	static int polyInx, inx_other, inx_line, inx_origin;
+	static int inx_other, inx_line, inx_origin;
 	static BOOL_T corner_mode;
+	static BOOL_T polyMode;
+	static ANGLE_T original_angle;
 	int inx, inx1, inx2;
 	DIST_T d, d1, d2, dd;
 	coOrd * newPts = NULL;
-	int mergePoints;
 	tempSegs_da.cnt = 1;
-	switch ( action ) {
-	case C_DOWN:
+	switch ( action&0xFF ) {
+	case C_START:
+		if (!context->rotate_state && !context->rot_moved) {
+			context->rot_center.x = context->orig.x;
+			context->rot_center.y = context->orig.y;
+		}
+		context->state = MOD_STARTED;
+		context->rotate_state = FALSE;
+		context->last_inx=-1;
+		lineInx = -1;
+		curveInx = -1;
 		segInx = -1;
-		corner_mode = FALSE;
-		DistanceSegs( orig, angle, segCnt, segPtr, &pos, &segInx );
+		polyMode = FALSE;
+		DistanceSegs( context->orig, context->angle, context->segCnt, context->segPtr, &pos, &segInx );
 		if (segInx == -1)
 			return C_ERROR;
-		tempSegs(0).width = segPtr[segInx].width;
-		tempSegs(0).color = segPtr[segInx].color;
-		switch ( segPtr[segInx].type ) {
+		context->type = context->segPtr[segInx].type;
+		switch(context->type) {
+			case SEG_TBLEDGE:
+			case SEG_STRLIN:
+			case SEG_DIMLIN:
+			case SEG_BENCH:
+				REORIGIN( p0, context->segPtr[segInx].u.l.pos[0], context->angle, context->orig );
+				REORIGIN( p1, context->segPtr[segInx].u.l.pos[1], context->angle, context->orig );
+				tempSegs(0).type = SEG_STRLIN;
+				tempSegs(0).color = wDrawColorRed;
+				tempSegs(0).u.l.pos[0] = p0;
+				tempSegs(0).u.l.pos[1] = p1;
+				tempSegs(0).width = 0;
+				tempSegs_da.cnt = 1;
+				context->p0 = p0;
+				context->p1 = p1;
+				CreateLineAnchors(-1,p0,p1);
+				break;
+			case SEG_CRVLIN:
+			case SEG_FILCRCL:
+				BuildCircleContext(context,segInx);
+				tempSegs(0).type = SEG_CRVLIN;
+				tempSegs(0).color = wDrawColorRed;
+				tempSegs(0).u.c.center = context->pc;
+				tempSegs(0).u.c.radius = context->radius;
+				tempSegs(0).u.c.a0 = context->segPtr[segInx].u.c.a0;
+				tempSegs(0).u.c.a1 = context->segPtr[segInx].u.c.a1;
+				tempSegs(0).width = 0;
+				tempSegs_da.cnt = 1;
+				if (tempSegs(0).u.c.a1<360.0) {
+					CreateCurveAnchors(-1,context->pm,context->pc,context->p0,context->p1);
+				} else
+					CreateCircleAnchor(FALSE,tempSegs(0).u.c.center,tempSegs(0).u.c.radius,FindAngle(tempSegs(0).u.c.center,pos));
+				context->last_inx = 2;
+				break;
+			case SEG_POLY:
+			case SEG_FILPOLY:
+				if (context->segPtr[segInx].u.p.polyType !=RECTANGLE) {
+					polyMode = TRUE;
+					return DrawGeomPolyModify(action,pos,context);
+				} else {
+					tempSegs(0).type = SEG_POLY;
+					tempSegs(0).color = wDrawColorRed;
+					DYNARR_RESET( pts_t, points_da);
+					for (int inx=0;inx<context->segPtr->u.p.cnt;inx++) {
+						DYNARR_APPEND(pts_t, points_da,3);
+						REORIGIN( points(inx).pt, context->segPtr[segInx].u.p.pts[inx].pt, context->angle, context->orig );
+					}
+					tempSegs(0).u.p.pts = &points(0);
+					tempSegs(0).u.p.cnt = points_da.cnt;
+					tempSegs(0).width = 0;
+					tempSegs_da.cnt = 1;
+					context->p0 = points(0).pt;
+					CreateBoxAnchors(-1,&context->segPtr[segInx].u.p.pts[0]);
+					context->p0 = points(0).pt;
+					context->p1 = points(1).pt;
+				}
+				break;
+			case SEG_TEXT:
+				InfoMessage("Text can only be modified with Describe");
+				wBeep();
+				return C_ERROR;
+			default:
+				;
+		}
+		InfoMessage("Points Mode - Select and drag Anchor Point");
+		return C_CONTINUE;
+		break;
+	case wActionMove:
+		if (context->rotate_state) return DrawGeomOriginMove(action,pos,context);
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
+		DYNARR_RESET(trkSeg_t,anchors_da);
+		switch( context->type) {
 		case SEG_TBLEDGE:
-
 		case SEG_STRLIN:
 		case SEG_DIMLIN:
 		case SEG_BENCH:
-			REORIGIN( p0, segPtr[segInx].u.l.pos[0], angle, orig );
-			REORIGIN( p1, segPtr[segInx].u.l.pos[1], angle, orig );
-			tempSegs(0).type = segPtr[segInx].type;
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			CreateLineAnchors(lineInx,context->p0,context->p1);
+			dd = FindDistance( context->p0, pos );
+			if ( IsClose(dd)) {
+				CreateMovingAnchor(context->p0,TRUE);
+			} else {
+				dd = FindDistance( context->p1, pos );
+				if ( IsClose(dd)) {
+					CreateMovingAnchor(context->p1,TRUE);
+				}
+			}
+		break;
+		case SEG_CRVLIN:
+		case SEG_FILCRCL:
+			DYNARR_RESET(trkSeg_t,anchors_da);
+			if (tempSegs(0).u.c.a1 < 360.0)
+					CreateCurveAnchors(curveInx,context->pm,context->pc,context->p0,context->p1);
+			dd = FindDistance( context->p0, pos );
+			if ( IsClose(dd)) {
+				CreateMovingAnchor(context->p0,TRUE);
+			} else {
+				dd = FindDistance( context->p1, pos );
+				if ( IsClose(dd)) {
+					CreateMovingAnchor(context->p1,TRUE);
+				} else {
+					dd = FindDistance( context->pm, pos );
+					if ( IsClose(dd)) {
+						CreateMovingAnchor(context->pm,TRUE);
+					}
+				}
+			}
+		break;
+		case SEG_POLY:
+		case SEG_FILPOLY:;
+			CreateBoxAnchors(-1,&points(0));
+			break;
+		default:;
+		}
+		return C_CONTINUE;
+		break;
+	case C_DOWN:
+		if (context->rotate_state) return DrawGeomOriginMove(action,pos,context);
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
+		corner_mode = FALSE;
+		segInx = 0;
+		context->state = MOD_STARTED;
+		tempSegs(0).width = context->segPtr[segInx].width;
+		tempSegs(0).color = context->segPtr[segInx].color;
+		switch ( context->type ) {
+		case SEG_TBLEDGE:
+			if ( MyGetKeyState() & WKEY_CTRL )
+				OnTableEdgeEndPt( NULL, &pos );
+		case SEG_STRLIN:
+		case SEG_DIMLIN:
+		case SEG_BENCH:
+			p0 = context->p0;
+			p1 = context->p1;
+			lineInx = -1;
+			dd = FindDistance( p0, pos );
+			if ( IsClose(dd)) {
+				lineInx = 0;
+			} else {
+				dd = FindDistance( p1, pos );
+				if ( IsClose(dd)) {
+					lineInx = 1;
+				}
+			}
+			if (lineInx < 0 ) {
+				InfoMessage( _("Not close to end of line"));
+			} else {
+				InfoMessage("End selected, drag to reposition");
+				context->state = MOD_SELECTED_PT;
+			}
+			tempSegs(0).color = wDrawColorBlack;
+			tempSegs(0).width = 0;
+			tempSegs(0).type = context->type;
 			tempSegs(0).u.l.pos[0] = p0;
 			tempSegs(0).u.l.pos[1] = p1;
-			tempSegs(0).u.l.option = segPtr[segInx].u.l.option;
+			tempSegs(0).u.l.option = context->segPtr[segInx].u.l.option;
 			segA1 = FindAngle( p1, p0 );
+			tempSegs_da.cnt = 1;
+			CreateLineAnchors(lineInx,p0,p1);
 			break;
 		case SEG_CRVLIN:
 		case SEG_FILCRCL:
-			REORIGIN( pc, segPtr[segInx].u.c.center, angle, orig )
-			tempSegs(0).type = segPtr[segInx].type;
-			tempSegs(0).u.c.center = pc;
-			tempSegs(0).u.c.radius = fabs(segPtr[segInx].u.c.radius);
-			if (segPtr[segInx].u.c.a1 >= 360.0) {
+			curveInx = -1;
+			tempSegs(0).color = wDrawColorBlack;
+			tempSegs(0).width = 0;
+			tempSegs(0).type = context->type;
+			tempSegs(0).u.c.center = context->pc;
+			tempSegs(0).u.c.radius = context->radius;
+			if (context->segPtr[segInx].u.c.a1 >= 360.0) {
 				tempSegs(0).u.c.a0 = 0.0;
 				tempSegs(0).u.c.a1 = 360.0;
+				InfoMessage("Drag to Change Radius");
+				CreateCircleAnchor(TRUE,tempSegs(0).u.c.center,tempSegs(0).u.c.radius,FindAngle(tempSegs(0).u.c.center,pos));
 			} else {
-				tempSegs(0).u.c.a0 = NormalizeAngle( segPtr[segInx].u.c.a0+angle );
-				tempSegs(0).u.c.a1 = segPtr[segInx].u.c.a1;
-				segA1 = NormalizeAngle( segPtr[segInx].u.c.a0 + segPtr[segInx].u.c.a1 + angle );
-				PointOnCircle( &p0, pc, fabs(segPtr[segInx].u.c.radius), segPtr[segInx].u.c.a0+angle );
-				PointOnCircle( &p1, pc, fabs(segPtr[segInx].u.c.radius), segPtr[segInx].u.c.a0+segPtr[segInx].u.c.a1+angle );
+				p0 = context->p0;
+				p1 = context->p1;
+				pm = context->pm;
+				pc = context->pc;
+				tempSegs(0).u.c.a0 = FindAngle(context->pc,context->p0);
+				tempSegs(0).u.c.a1 = DifferenceBetweenAngles(FindAngle(context->pc,context->p0),FindAngle(context->pc,context->p1));
+				tempSegs(0).u.c.center = context->pc;
+				tempSegs(0).u.c.radius = context->radius;
+				curveInx = -1;
+				dd = FindDistance( p0, pos );
+				if ( IsClose(dd)) {
+					curveInx = 0;
+				} else {
+					dd = FindDistance( p1, pos );
+					if ( IsClose(dd)) {
+						curveInx = 1;
+					} else {
+						dd = FindDistance( pm, pos );
+						if ( IsClose(dd)) {
+							curveInx = 2;
+						}
+					}
+				}
+				if (curveInx < 0) {
+					InfoMessage( _("Not close to ends or middle of mine, reselect"));
+					return C_CONTINUE;
+				} else {
+					if (curveInx <2 )
+						InfoMessage("Drag to move end, +Ctrl to lock to other objects");
+					else
+						InfoMessage("Drag to change radius");
+				}
+				tempSegs_da.cnt = 1;
+				if (tempSegs(0).u.c.a1 < 360.0)
+					CreateCurveAnchors(curveInx,pm,pc,p0,p1);
 			}
-			
+			context->state = MOD_SELECTED_PT;
 			break;
 		case SEG_POLY:
 		case SEG_FILPOLY:
-			tempSegs(0).type = segPtr[segInx].type;
-			tempSegs(0).u.p.cnt = segPtr[segInx].u.p.cnt;
-			tempSegs(0).u.p.angle = 0.0;
-			tempSegs(0).u.p.orig = zero;
-			tempSegs(0).u.p.polyType = segPtr[segInx].u.p.polyType;
-			DYNARR_SET( coOrd, points_da, segPtr[segInx].u.p.cnt+1 );
-			tempSegs(0).u.p.pts = &points(0);
 			d = 10000;
 			polyInx = 0;
-			for ( inx=0; inx<segPtr[segInx].u.p.cnt; inx++ ) {
-				REORIGIN( points(inx), segPtr[segInx].u.p.pts[inx], angle, orig );
-			}
-			for ( inx=0; inx<segPtr[segInx].u.p.cnt; inx++ ) {
+			for ( inx=0; inx<4; inx++ ) {
+				if (IsClose(FindDistance(pos,points(inx).pt))) {
+					corner_mode = TRUE;
+					polyInx = inx;
+					break;
+				}
 				p0 = pos;
-				dd = LineDistance( &p0, points( inx==0?segPtr[segInx].u.p.cnt-1:inx-1), points( inx ) );
+				dd = LineDistance( &p0, points( inx==0?3:inx-1).pt, points( inx ).pt );
 				if ( d > dd ) {
 					d = dd;
-					polyInx = inx;
+					inx_line = inx;
 				}
 			}
-			if (segPtr[segInx].u.p.polyType == RECTANGLE) {
-				d1 = FindDistance( points(polyInx), pos );
-				d2 = FindDistance( points(polyInx==0?segPtr[segInx].u.p.cnt-1:polyInx-1), pos );
+			if (!corner_mode) {
+				d1 = FindDistance( points(inx_line).pt, pos );
+				d2 = FindDistance( points(inx_line==0?3:inx_line-1).pt, pos );
 				if (d2<d1) {
-					inx_line = polyInx;
-					polyInx = polyInx==0?segPtr[segInx].u.p.cnt-1:polyInx-1;
+					polyInx = inx_line==0?3:inx_line-1;
 				} else {
-					inx_line = polyInx==0?segPtr[segInx].u.p.cnt-1:polyInx-1;
+					polyInx = inx_line;
 				}
-				//polyInx is closest point
-				inx1 = (polyInx==0?3:polyInx-1);  //Prev point
-				inx2 = (polyInx==3?0:polyInx+1);  //Next Point
-				inx_origin = (inx2==3?0:inx2+1);  //Opposite point
-				if ( IsClose(d2) || IsClose(d1) ) {
-					corner_mode = TRUE;
-					pos = points(polyInx);
-					start_pos = pos;
-					DrawArrowHeads( &tempSegs(1), pos, FindAngle(points(polyInx),points(inx_origin)), TRUE, wDrawColorRed );
-				    tempSegs_da.cnt = 6;
-					InfoMessage( _("Drag to Move Corner Point"));
-				} else {
-					corner_mode = FALSE;
-					start_pos = pos;
-					pos.x = (points(polyInx).x + points(inx_line).x)/2;
-					pos.y = (points(polyInx).y + points(inx_line).y)/2;
-					DrawArrowHeads( &tempSegs(1), pos, FindAngle(points(polyInx),pos)+90, TRUE, wDrawColorRed );
-				    tempSegs_da.cnt = 6;
-				    InfoMessage( _("Drag to Move Edge "));
-				}
-				return C_CONTINUE;
+			}
+			inx1 = (polyInx==0?3:polyInx-1);  //Prev point
+			inx2 = (polyInx==3?0:polyInx+1);  //Next Point
+			inx_origin = (inx2==3?0:inx2+1);  //Opposite point
+			if ( corner_mode ) {
+				start_pos = pos;
+				pos = points(inx).pt;
+				DYNARR_SET(trkSeg_t,anchors_da,5);
+				DrawArrowHeads( &anchors(0), pos, FindAngle(points(polyInx).pt,points(inx_origin).pt), TRUE, wDrawColorRed );
+				InfoMessage( _("Drag to Move Corner Point"));
 			} else {
-				inx = (polyInx==0?segPtr[segInx].u.p.cnt-1:polyInx-1);
-				d = FindDistance( points(inx), pos );
-				dd = FindDistance( points(inx), points(polyInx) );
-				if ( d < 0.25*dd ) {
-					polyInx = inx;
-				} else if ( d > 0.75*dd ) {
-					;
-				} else {
-					tempSegs(0).u.p.cnt++;
-					for (inx=points_da.cnt-1; inx>polyInx; inx-- ) {
-						points(inx) = points(inx-1);
-					}
-/*fprintf( stderr, "Inserting vertix before %d\n", polyInx );*/
-				}
-				points(polyInx) = pos;
+				start_pos = pos;
+				pos.x = (points(inx_line).pt.x + points(inx_line==0?3:inx_line-1).pt.x)/2;
+				pos.y = (points(inx_line).pt.y + points(inx_line==0?3:inx_line-1).pt.y)/2;
+				DYNARR_SET(trkSeg_t,anchors_da,5);
+				DrawArrowHeads( &anchors(0), pos, FindAngle(points(polyInx).pt,pos)+90, TRUE, wDrawColorRed );
+				InfoMessage( _("Drag to Move Edge "));
 			}
-			p1=p0;
-			break;
+			context->state = MOD_SELECTED_PT;
+			return C_CONTINUE;
 		case SEG_TEXT:
 			segInx = -1;
 			return C_ERROR;
@@ -690,7 +2057,7 @@ STATUS_T DrawGeomModify(
 			segEp = 0;
 		else {
 			segEp = 1;
-			switch ( segPtr[segInx].type ) {
+			switch ( context->type ) {
 			case SEG_TBLEDGE:
 			case SEG_STRLIN:
 			case SEG_DIMLIN:
@@ -701,176 +2068,454 @@ STATUS_T DrawGeomModify(
 				;
 			}
 		}
+		UndrawNewTrack( context->trk );
 		return C_CONTINUE;
 	case C_MOVE:
-		if (segInx == -1)
-			return C_ERROR;
-		if ( ( MyGetKeyState() & WKEY_SHIFT ) &&
-			 (tempSegs(0).type == SEG_STRLIN || tempSegs(0).type == SEG_DIMLIN || tempSegs(0).type == SEG_BENCH || tempSegs(0).type == SEG_TBLEDGE) ) {
-			d = FindDistance( pos, tempSegs(0).u.l.pos[1-segEp] );
-			Translate( &pos, tempSegs(0).u.l.pos[1-segEp], segA1, d );
-		} else if ( (MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_CTRL ) {
-			OnTrack( &pos, FALSE, FALSE );
+		if (context->rotate_state) return DrawGeomOriginMove(action,pos,context);
+
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
+		if (context->state != MOD_SELECTED_PT) return C_CONTINUE;
+		switch (tempSegs(0).type) {
+		case SEG_STRLIN:
+		case SEG_DIMLIN:
+		case SEG_BENCH:
+		case SEG_TBLEDGE:
+			if ( (MyGetKeyState() & WKEY_SHIFT) != 0) {
+				d = FindDistance( pos, tempSegs(0).u.l.pos[1-lineInx] );
+				Translate( &pos, tempSegs(0).u.l.pos[1-lineInx], segA1, d );
+			} else if ((MyGetKeyState() & (WKEY_SHIFT|WKEY_CTRL|WKEY_ALT)) == WKEY_SHIFT ) {
+				OnTrack( &pos, FALSE, FALSE );
+				CreateEndAnchor(pos,TRUE);
+			}
+			break;
+		default:
+			break;
 		}
 		int prior_pnt, next_pnt, orig_pnt;
 		ANGLE_T prior_angle, next_angle, line_angle;
 		tempSegs_da.cnt = 1;
 		switch (tempSegs(0).type) {
 		case SEG_TBLEDGE:
-
+			if ( MyGetKeyState() & WKEY_CTRL )
+				OnTableEdgeEndPt( NULL, &pos );
+			/* no break */
 		case SEG_STRLIN:
 		case SEG_DIMLIN:
 		case SEG_BENCH:
-			tempSegs(0).u.l.pos[segEp] = pos;
-			InfoMessage( _("Length = %0.3f Angle = %0.3f"), FindDistance( tempSegs(0).u.l.pos[segEp], tempSegs(0).u.l.pos[1-segEp] ), FindAngle( tempSegs(0).u.l.pos[1-segEp], tempSegs(0).u.l.pos[segEp] ) );
+			if (lineInx<0 || lineInx>1) return C_CONTINUE;
+			tempSegs(0).u.l.pos[lineInx] = pos;
+			InfoMessage( _("Length = %0.3f Angle = %0.3f"), FindDistance( tempSegs(0).u.l.pos[lineInx], tempSegs(0).u.l.pos[1-lineInx] ), FindAngle( tempSegs(0).u.l.pos[1-lineInx], tempSegs(0).u.l.pos[lineInx] ) );
+			tempSegs_da.cnt = 1;
+			context->p0 = tempSegs(0).u.l.pos[0];
+			context->p1 = tempSegs(0).u.l.pos[1];
+			p0 = context->p0;
+			p1 = context->p1;
+			CreateLineAnchors(lineInx, p0, p1);
 			break;
 		case SEG_CRVLIN:
 		case SEG_FILCRCL:
 			if (tempSegs(0).u.c.a1 >= 360.0) {
-				tempSegs(0).u.c.radius = FindDistance( tempSegs(0).u.c.center, pos );
+				tempSegs(0).u.c.radius = FindDistance( context->pc, pos );
+				CreateCircleAnchor(TRUE,tempSegs(0).u.c.center,tempSegs(0).u.c.radius,FindAngle(tempSegs(0).u.c.center,pos));
 			} else {
-				a = FindAngle( tempSegs(0).u.c.center, pos );
-				if (segEp==0) {
-					tempSegs(0).u.c.a1 = NormalizeAngle(segA1-a);
-					tempSegs(0).u.c.a0 = a;
+				if (context->state != MOD_SELECTED_PT) return C_CONTINUE;
+				if (curveInx < 0 || curveInx > 2) return C_CONTINUE;
+				p0 = context->p0;
+				p1 = context->p1;
+				pc = context->pc;
+				pm = context->pm;
+				if ( (MyGetKeyState() & WKEY_SHIFT) != 0) {
+					//Preserve Radius, Change swept angle
+					a = FindAngle( pc, pos );
+					if (curveInx==0) {
+						tempSegs(0).u.c.a1 = NormalizeAngle(FindAngle(pc,p1)-a);
+						tempSegs(0).u.c.a0 = a;
+					} else if (curveInx ==1) {
+						tempSegs(0).u.c.a1 = NormalizeAngle(a-tempSegs(0).u.c.a0);
+					}
+					PointOnCircle(&p0,pc,context->radius,tempSegs(0).u.c.a0);
+					PointOnCircle(&p1,pc,context->radius,tempSegs(0).u.c.a0+tempSegs(0).u.c.a1);
+					context->p0 = p0;
+					context->p1 = p1;
+					PointOnCircle(&pm,pc,context->radius,tempSegs(0).u.c.a0+(tempSegs(0).u.c.a1/2));
+					context->pm = pm;
 				} else {
-					tempSegs(0).u.c.a1 = NormalizeAngle(a-tempSegs(0).u.c.a0);
+					if (curveInx == 0 || curveInx == 1) {
+						p0 = context->p0;
+						p1 = context->p1;
+						/* Preserve Curve "Deflection" */
+						d = context->disp;  	// Original Deflection
+						if (curveInx == 0) {
+							context->p0 = p0 = pos;
+						} else {
+							context->p1 = p1 = pos;
+						}
+						coOrd posx; //Middle of chord
+						posx.x = (p1.x-p0.x)/2.0+p0.x;
+						posx.y = (p1.y-p0.y)/2.0+p0.y;			//Middle of chord
+						ANGLE_T a0 = FindAngle( p1, p0 );
+						DIST_T d0 = FindDistance( p0, p1 )/2.0;
+						DIST_T r = 1000.0;
+						if ( fabs(d) >= 0.01 ) {
+							d2 = sqrt( d0*d0 + d*d )/2.0;
+							r = d2*d2*2.0/d;
+							if ( fabs(r) > 1000.0 )
+								r = ((r > 0)? 1 : -1) *1000.0;
+						} else {
+							r = ((r > 0) ? 1 : -1 ) *1000.0;
+						}
+						a0 -= 90.0;
+						if (r<0) {
+							coOrd pt = p0;
+							p0 = p1;
+							p1 = pt;
+							a0 += 180.0;
+						}
+						context->radius = tempSegs(0).u.c.radius = fabs(r);
+						Translate( &pc, posx, a0, fabs(r)-fabs(d) );
+						context->pc = tempSegs(0).u.c.center = pc;
+					    tempSegs(0).u.c.a0 = FindAngle(pc,p0);
+					    context->arc_angle = tempSegs(0).u.c.a1 = NormalizeAngle(FindAngle(pc,p1)-FindAngle(pc,p0));
+					    PointOnCircle(&pm,pc,context->radius,tempSegs(0).u.c.a0+(tempSegs(0).u.c.a1/2.0));
+					    context->pm = pm;
+					} else {
+						//Change radius using chord
+						p0 = context->p0;
+						p1 = context->p1;
+						pm = context->pm;
+						ANGLE_T a0 = FindAngle( p1, p0 );
+						DIST_T d0 = FindDistance( p0, p1 )/2.0;
+						coOrd pos2 = pos;
+						Rotate( &pos2, p1, -a0 );
+						pos2.x -= p1.x;
+						DIST_T r = 1000.0;
+						if ( fabs(pos2.x) >= 0.01 ) {
+							d2 = sqrt( d0*d0 + pos2.x*pos2.x )/2.0;
+							r = d2*d2*2.0/pos2.x;
+							if ( fabs(r) > 1000.0 )
+								r = ((r > 0) ? 1 :  -1 ) *1000.0;
+						} else {
+							r = ((r > 0) ? 1 :  -1 ) *1000.0;
+						}
+						coOrd posx; //Middle of chord
+						posx.x = (p1.x-p0.x)/2.0 + p0.x;
+						posx.y = (p1.y-p0.y)/2.0 + p0.y;
+						a0 -= 90.0;
+						if (r<0) {
+							coOrd pt = p0;
+							p0 = p1;
+							p1 = pt;
+							a0 += 180.0;
+						}
+						Translate( &pc, posx, a0, fabs(r) - fabs(pos2.x) );
+						context->pc = tempSegs(0).u.c.center = pc;
+						context->radius = tempSegs(0).u.c.radius = fabs(r);
+						a0 = FindAngle( pc, p0 );
+						ANGLE_T a1 = FindAngle( pc, p1 );
+						tempSegs(0).u.c.a0 = a0;
+						tempSegs(0).u.c.a1 = NormalizeAngle(a1-a0);
+						PointOnCircle(&pm,pc,context->radius,a0+(NormalizeAngle(a1-a0)/2));
+						context->p0 = p0;
+						context->p1 = p1;
+						context->pm = pm;
+						context->disp = pos2.x;
+					}
 				}
+				if (tempSegs(0).u.c.a1 < 360.0)
+					CreateCurveAnchors(curveInx,pm,pc,p0,p1);
 			}
 			break;
 		case SEG_POLY:
 		case SEG_FILPOLY:
-			switch (tempSegs(0).u.p.polyType) {
-				case RECTANGLE:
-					if (!corner_mode) {
-						/* Constrain movement to be perpendicular */
-						d = FindDistance(start_pos, pos);
-						line_angle = NormalizeAngle(FindAngle(points(inx_line),points(polyInx))-90);
-						a = FindAngle(pos,start_pos);
-						Translate( &pos, start_pos, line_angle, - d*cos(D2R(line_angle-a)));
-					}
-					d = FindDistance(start_pos,pos);
-					a = FindAngle(start_pos, pos);
-					start_pos = pos;
-					prior_pnt = (polyInx == 0)?3:polyInx-1;
-					next_pnt = (polyInx == 3)?0:polyInx+1;
-					orig_pnt = (prior_pnt == 0)?3:prior_pnt-1;
-					Translate( &points(polyInx), points(polyInx), a, d);
-					d = FindDistance(points(orig_pnt),points(polyInx));
-					a = FindAngle(points(orig_pnt),points(polyInx));
-					prior_angle = FindAngle(points(orig_pnt),points(prior_pnt));
-					Translate( &points(prior_pnt), points(orig_pnt), prior_angle, d*cos(D2R(prior_angle-a)));
-					next_angle = FindAngle(points(orig_pnt),points(next_pnt));
-					Translate( &points(next_pnt), points(orig_pnt), next_angle, d*cos(D2R(next_angle-a)));
-					if (!corner_mode) {
-						pos.x = (points(polyInx).x + points(inx_line).x)/2;
-						pos.y = (points(polyInx).y + points(inx_line).y)/2;
-						DrawArrowHeads( &tempSegs(1), pos, FindAngle(points(polyInx),points(inx_line))+90, TRUE, wDrawColorRed );
-						tempSegs_da.cnt = 6;
-						InfoMessage( _("Drag to Move Edge"));
-					} else {
-						pos = points(polyInx);
-						DrawArrowHeads( &tempSegs(1), pos, FindAngle(points(polyInx),points(inx_origin)), TRUE, wDrawColorRed );
-						tempSegs_da.cnt = 6;
-						InfoMessage( _("Drag to Move Corner Point"));
-					}
-				break;
-				default:
-					points(polyInx) = pos;
+			if (!corner_mode) {
+				/* Constrain movement to be perpendicular */
+				d = FindDistance(start_pos, pos);
+				line_angle = NormalizeAngle(FindAngle(points(inx_line).pt,points(inx_line==3?0:inx_line+1).pt));
+				a = FindAngle(pos,start_pos);
+				Translate( &pos, start_pos, line_angle, - d*cos(D2R(line_angle-a)));
 			}
-
+			d = FindDistance(start_pos,pos);
+			a = FindAngle(start_pos, pos);
+			start_pos = pos;
+			prior_pnt = (polyInx == 0)?3:polyInx-1;
+			next_pnt = (polyInx == 3)?0:polyInx+1;
+			orig_pnt = (prior_pnt == 0)?3:prior_pnt-1;
+			Translate( &points(polyInx).pt, points(polyInx).pt, a, d);
+			d = FindDistance(points(orig_pnt).pt,points(polyInx).pt);
+			a = FindAngle(points(orig_pnt).pt,points(polyInx).pt);
+			prior_angle = FindAngle(points(orig_pnt).pt,points(prior_pnt).pt);
+			Translate( &points(prior_pnt).pt, points(orig_pnt).pt, prior_angle, d*cos(D2R(prior_angle-a)));
+			next_angle = FindAngle(points(orig_pnt).pt,points(next_pnt).pt);
+			Translate( &points(next_pnt).pt, points(orig_pnt).pt, next_angle, d*cos(D2R(next_angle-a)));
+			if (!corner_mode) {
+				pos.x = (points(inx_line).pt.x + points(inx_line==0?3:inx_line-1).pt.x)/2;
+				pos.y = (points(inx_line).pt.y + points(inx_line==0?3:inx_line-1).pt.y)/2;
+				DYNARR_SET(trkSeg_t,anchors_da,5);
+				DrawArrowHeads( &anchors(0), pos, FindAngle(points(inx_line).pt,points(inx_line==0?3:inx_line-1).pt)+90, TRUE, wDrawColorRed );
+				InfoMessage( _("Drag to Move Edge"));
+			} else {
+				pos = points(polyInx).pt;
+				DYNARR_SET(trkSeg_t,anchors_da,5);
+				DrawArrowHeads( &anchors(0), pos, FindAngle(points(polyInx).pt,points(inx_origin).pt), TRUE, wDrawColorRed );
+				InfoMessage( _("Drag to Move Corner Point"));
+			}
+			context->p0 = points(0).pt;
+			context->p1 = points(1).pt;
 			break;
 		default:
 			;
 		}
-
 		return C_CONTINUE;
 	case C_UP:
+
+		if (context->rotate_state) return DrawGeomOriginMove(action, pos, context);
+
+		if (polyMode) {
+			int rc;
+			rc = DrawGeomPolyModify(action,pos,context);
+			if (context->prev_inx != -1)
+				context->state = MOD_AFTER_PT;
+			return rc;
+		}
+
 		if (segInx == -1)
 			return C_CONTINUE;
 		switch (tempSegs(0).type) {
 		case SEG_TBLEDGE:
-
 		case SEG_STRLIN:
 		case SEG_DIMLIN:
 		case SEG_BENCH:
-			pos = tempSegs(0).u.l.pos[segEp];
-			pos.x -= orig.x;
-			pos.y -= orig.y;
-			Rotate( &pos, zero, -angle );
-			segPtr[segInx].u.l.pos[segEp] = pos;
+			p0 = context->p0;
+			p1 = context->p1;
+			context->abs_angle = FindAngle(p0,p1);
+			context->length = FindDistance(p0,p1);
+			CreateLineAnchors(lineInx,p0,p1);
+			context->last_inx = lineInx;
 			break;
 		case SEG_CRVLIN:
 		case SEG_FILCRCL:
-			if ( tempSegs(0).u.c.a1 >= 360.0 ) {
-				segPtr[segInx].u.c.radius = fabs(tempSegs(0).u.c.radius);
+			if ( (tempSegs(0).type == SEG_FILCRCL) || (tempSegs(0).u.c.a1 == 360.0 || tempSegs(0).u.c.a1 == 0.0) ) {
+				context->radius = fabs(tempSegs(0).u.c.radius);
+				context->arc_angle = 360.0;
+				CreateCircleAnchor(FALSE,tempSegs(0).u.c.center,tempSegs(0).u.c.radius,FindAngle(tempSegs(0).u.c.center,pos));
 			} else {
-				a = FindAngle( tempSegs(0).u.c.center, pos );
-				a = NormalizeAngle( a-angle );
-				segPtr[segInx].u.c.a1 = tempSegs(0).u.c.a1;
-				if (segEp == 0) {
-					segPtr[segInx].u.c.a0 = a;
-				}
+				p0 = context->p0;
+				p1 = context->p1;
+				pc = context->pc;
+				pm = context->pm;
+				context->radius = fabs(tempSegs(0).u.c.radius);
+				context->arc_angle = tempSegs(0).u.c.a1;
+				CreateCurveAnchors(curveInx,pm,pc,p0,p1);
+				a = FindAngle(p1,p0);
+				Rotate(&pm,p1,-a);
+				context->disp = pm.x-p1.x;
 			}
+			context->last_inx = curveInx;
 			break;
 		case SEG_POLY:
 		case SEG_FILPOLY:
-			switch(tempSegs(0).u.p.polyType) {
-			case RECTANGLE:
-				for (int i=0;i<4;i++) {
-					pos = points(i);
-					pos.x -= orig.x;
-					pos.y -= orig.y;
-					Rotate( &pos, zero, -angle );
-					segPtr[segInx].u.p.pts[i] = pos;
-				}
-				break;
-			default:
-				mergePoints = FALSE;
-				if ( IsClose( FindDistance( pos, points( polyInx==0?tempSegs(0).u.p.cnt-1:polyInx-1 ) ) ) ||
-					IsClose( FindDistance( pos, points( (polyInx==tempSegs(0).u.p.cnt-1)?0:polyInx+1 ) ) ) ) {
-					mergePoints = TRUE;
-					if (segPtr[segInx].u.p.cnt <= 3) {
-						ErrorMessage( MSG_POLY_SHAPES_3_SIDES );
+			CreateBoxAnchors(-1,tempSegs(0).u.p.pts);
+			context->width = FindDistance(tempSegs(0).u.p.pts[0].pt,tempSegs(0).u.p.pts[1].pt);
+			context->height = FindDistance(tempSegs(0).u.p.pts[1].pt,tempSegs(0).u.p.pts[2].pt);
+			context->last_inx = polyInx;
+			if (corner_mode) context->last_inx +=5;
+			break;
+		default:
+			;
+		}
+		context->state = MOD_AFTER_PT;
+		curveInx = -1;
+		lineInx = -1;
+		polyInx = -1;
+		InfoMessage("Enter/Space to Accept, ESC to Reject");
+		return C_CONTINUE;
+	case C_UPDATE:
+		if (context->rotate_state) return DrawGeomOriginMove(action, pos, context);
+
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
+		if (context->state == MOD_AFTER_PT) {
+			switch (tempSegs(0).type) {
+				case SEG_TBLEDGE:
+				case SEG_STRLIN:
+				case SEG_DIMLIN:
+				case SEG_BENCH:
+					context->abs_angle = NormalizeAngle(context->abs_angle);
+					Translate(&tempSegs(0).u.l.pos[1],tempSegs(0).u.l.pos[0],context->abs_angle,context->length);
+					CreateLineAnchors(context->last_inx,tempSegs(0).u.l.pos[0],tempSegs(0).u.l.pos[1]);
+					context->p0 = tempSegs(0).u.l.pos[0];
+					context->p1 = tempSegs(0).u.l.pos[1];
+					break;
+				case SEG_CRVLIN:
+				case SEG_FILCRCL:
+					if (tempSegs(0).u.c.a1 == 360.0 || tempSegs(0).u.c.a1 == 0.0) {
+						tempSegs(0).u.c.a1 = 360.0;
+						tempSegs(0).u.c.radius = context->radius;
+						Translate(&p0,tempSegs(0).u.c.center,tempSegs(0).u.c.a0,tempSegs(0).u.c.radius);
+						context->p0 = p0;
+						context->p1 = p0;
+						context->pm = p0;
+						context->pc = tempSegs(0).u.c.center;
 						break;
 					}
-				}
+					if (context->radius < 0) { //swap ends
+						context->radius = fabs(context->radius);
+						p1 = context->p0;
+						p0 = context->p1;
+						a = FindAngle(context->pc,context->pm);
+						Translate(&pm,context->pm,a+180,2*context->disp);
+						Translate(&pc,pm,a,context->radius);
+						context->pm = pm;
+						context->pc = pc;
+						context->p0 = p0;
+						context->p1 = p1;
+					} else {
+						pm = context->pm;
+						pc = context->pc;
+						p0 = context->p0;
+						p1 = context->p1;
+					}
+					if (context->last_inx == 0) {
+						p1 = context->p1;
+						pc = context->pc;
+						a = FindAngle(p1,pc);
+						Translate(&pc,p1,a,context->radius);
+						context->pc = pc;
+						PointOnCircle( &p0, context->pc, context->radius, NormalizeAngle(a+180-context->arc_angle) );
+						context->p0 = p0;
+						PointOnCircle( &pm, context->pc, context->radius, NormalizeAngle(a+180-(context->arc_angle/2)));
+						context->pm = pm;
+					} else if (context->last_inx == 1) {
+						p0 = context->p0;
+						pc = context->pc;
+						a = FindAngle(p0,pc);
+						Translate(&pc,p0,a,context->radius);
+						context->pc = pc;
+						PointOnCircle( &p1, context->pc, context->radius, NormalizeAngle(a+180+context->arc_angle) );
+						context->p1 = p1;
+						PointOnCircle( &pm, context->pc, context->radius, NormalizeAngle(a+180+(context->arc_angle/2)));
+						context->pm = pm;
+					} else {   // Middle if neither
+						a = FindAngle(context->pm,context->pc);
+						Translate(&pc,context->pm,a,context->radius);
+						context->pc = pc;
+						PointOnCircle( &p1, context->pc, context->radius, NormalizeAngle(FindAngle(context->pc,context->pm)+(context->arc_angle/2)) );
+						PointOnCircle( &p0, context->pc, context->radius, NormalizeAngle(FindAngle(context->pc,context->pm)-(context->arc_angle/2)) );
+						context->p1 = p1;
+						context->p0 = p0;
+					}
+					a = FindAngle(p1,p0);
+					Rotate(&pm,p1,-a);
+					context->disp = pm.x-p1.x;
+					tempSegs(0).u.c.center = context->pc;
+					tempSegs(0).u.c.a0 = FindAngle(context->pc,context->p0);
+					tempSegs(0).u.c.a1 = NormalizeAngle(FindAngle(context->pc,context->p1)-tempSegs(0).u.c.a0);
+					if (tempSegs(0).u.c.a1 == 0.0) tempSegs(0).u.c.a1 = 360.0;
+					tempSegs(0).u.c.radius = context->radius;
+					CreateCurveAnchors(context->last_inx,context->pm,context->pc,context->p0,context->p1);
+					break;
+				case SEG_POLY:
+				case SEG_FILPOLY:
+					a = NormalizeAngle(FindAngle(points(0).pt,points(3).pt));
+					Translate( &points(3).pt, points(0).pt, a, context->height);
+					Translate( &points(2).pt, points(1).pt, a, context->height);
+					a = NormalizeAngle(FindAngle(points(0).pt,points(1).pt));;
+					Translate( &points(1).pt, points(0).pt, a, context->width);
+					Translate( &points(2).pt, points(3).pt, a, context->width);
+					CreateBoxAnchors(context->last_inx,&points(0));
+					break;
+				default:
+					break;
+			}
+		}
+		break;
+	case C_TEXT:
+		if (context->rotate_state) DrawGeomOriginMove(action, pos, context);
 
-				coOrd * oldPts = segPtr[segInx].u.p.pts;
-				newPts = (coOrd*)MyMalloc( tempSegs(0).u.p.cnt * sizeof (coOrd) );
-				int size = segPtr[segInx].u.p.cnt;
-				memcpy( newPts, segPtr[segInx].u.p.pts, (size) * sizeof (coOrd) );
-				segPtr[segInx].u.p.pts = newPts;
-				MyFree(oldPts);
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
 
+		if (action>>8 == 'o') {
+			MenuMode(1);
+		}
 
-				if ( tempSegs(0).u.p.cnt > segPtr[segInx].u.p.cnt ) {
-					ASSERT( tempSegs(0).u.p.cnt == segPtr[segInx].u.p.cnt+1 );
-					for (inx=tempSegs(0).u.p.cnt-1; inx>polyInx; inx--)
-						segPtr[segInx].u.p.pts[inx] = segPtr[segInx].u.p.pts[inx-1];
-					segPtr[segInx].u.p.cnt++;
+		if (action>>8 != 32 && action>>8 != 13) return C_CONTINUE;
+		/* no break */
+	case C_FINISH:
+		if (polyMode) {
+			DrawGeomPolyModify(action,pos,context);
+			context->segPtr[segInx].type = context->type;
+			context->segPtr[segInx].u.p.polyType = context->subtype;
+			return C_TERMINATE;
+		}
+		//copy changes back into track
+		context->orig.x = context->rot_center.x;
+		context->orig.y = context->rot_center.y;
+		context->rot_moved = FALSE;
+		context->angle = 0.0;
+		switch (tempSegs(0).type) {
+			case SEG_TBLEDGE:
+			case SEG_STRLIN:
+			case SEG_DIMLIN:
+			case SEG_BENCH:
+				for (int i=0;i<2;i++) {
+					pos = i==0?context->p0:context->p1;
+					pos.x -= context->rot_center.x;
+					pos.y -= context->rot_center.y;
+					context->segPtr[segInx].u.l.pos[i] = pos;
 				}
-		
-				pos = points(polyInx);
-				if ( mergePoints ) {
-					for (inx=polyInx+1; inx<segPtr[segInx].u.p.cnt; inx++)
-					segPtr[segInx].u.p.pts[inx-1] = segPtr[segInx].u.p.pts[inx];
-					segPtr[segInx].u.p.cnt--;
-/*fprintf( stderr, "Merging with vertix %d\n", polyInx );*/
-					break;
+				break;
+			case SEG_CRVLIN:
+			case SEG_FILCRCL:
+				pc = context->pc;
+				pc.x -= context->rot_center.x;
+				pc.y -= context->rot_center.y;
+				context->segPtr[segInx].u.c.center = pc;
+				p0 = context->p0;
+				p0.x -= context->rot_center.x;
+				p0.y -= context->rot_center.y;
+				p1 = context->p1;
+				p1.x -= context->rot_center.x;
+				p1.y -= context->rot_center.y;
+				context->segPtr[segInx].u.c.a0 = FindAngle(pc,p0);
+				context->segPtr[segInx].u.c.a1 = NormalizeAngle(FindAngle(pc,p1)-FindAngle(pc,p0));
+				if (context->segPtr[segInx].u.c.a1 == 0) context->segPtr[segInx].u.c.a1 = 360.0;
+				context->segPtr[segInx].u.c.radius = context->radius;
+				break;
+			case SEG_POLY:
+			case SEG_FILPOLY:
+				for (int i=0;i<4;i++) {
+					pos = points(i).pt;
+					pos.x -= context->rot_center.x;
+					pos.y -= context->rot_center.y;
+					context->segPtr[segInx].u.p.pts[i].pt = pos;
 				}
-				pos.x -= orig.x;
-				pos.y -= orig.y;
-				Rotate( &pos, zero, -angle );
-				segPtr[segInx].u.p.pts[polyInx] = pos;
-			}
-			break;
-		default:
-			;
+				break;
+			default:
+				break;
 		}
+		context->state = MOD_NONE;
+		context->rotate_state = FALSE;
+		context->last_inx = -1;
+		DYNARR_RESET(trkSeg_t,anchors_da);
+		DYNARR_RESET(trkSeg_t,tempSegs_da);
+		DrawNewTrack( context->trk );
 		return C_TERMINATE;
+	case C_REDRAW:
+		if (polyMode) return DrawGeomPolyModify(action,pos,context);
+		if (context->state == MOD_NONE) return C_CONTINUE;
+		DrawSegs( &tempD, zero, 0.0, &tempSegs(0), tempSegs_da.cnt, trackGauge, wDrawColorBlack);
+		DrawSegs( &tempD, zero, 0.0, &anchors(0), anchors_da.cnt, trackGauge, wDrawColorBlack );
+		break;
+	case C_CANCEL:
+	case C_CONFIRM:
+	case C_TERMINATE:
+		context->state = MOD_NONE;
+		context->rotate_state = FALSE;
+		context->rot_moved = FALSE;
+		DYNARR_RESET(trkSeg_t,anchors_da);
+		DYNARR_RESET(trkSeg_t,tempSegs_da);
+		break;
 	default:
 		;
 	}
-	return C_ERROR;
+	return C_CONTINUE;
 }