X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdrawingview.cpp;h=ca063c51d548070b1a000158d15b0d53e9fdcf7e;hb=3f1e5ba1d42ab40edf75cf05df16b0e25d0821cb;hp=58e0979495b3794d2df175ced51453ac6b6a912b;hpb=f507d97c1b1118834a70332f5f79d8479a6964c0;p=architektonas

diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index 58e0979..ca063c5 100644
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -7,7 +7,7 @@
 // JLH = James Hammons <jlhamm@acm.org>
 //
 // Who  When        What
-// ---  ----------  -------------------------------------------------------------
+// ---  ----------  ------------------------------------------------------------
 // JLH  03/22/2011  Created this file
 // JLH  09/29/2011  Added middle mouse button panning
 //
@@ -20,6 +20,7 @@
 // STILL TO BE DONE:
 //
 // - Lots of stuff
+// - Layer locking (hiding works)
 //
 
 // Uncomment this for debugging...
@@ -35,28 +36,26 @@
 #include "mathconstants.h"
 #include "painter.h"
 #include "structs.h"
+#include "utils.h"
 
 
 #define BACKGROUND_MAX_SIZE	512
 
-// Class variable
-//Container DrawingView::document(Vector(0, 0));
-
 
 DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 	// The value in the settings file will override this.
-	useAntialiasing(true),
+	useAntialiasing(true), /*numSelected(0),*/ numHovered(0), shiftDown(false),
+	ctrlDown(false),
 	gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
-	scale(1.0), offsetX(-10), offsetY(-10),// document(Vector(0, 0)),
-	gridPixels(0), collided(false)//, toolAction(NULL)
+	scale(1.0), offsetX(-10), offsetY(-10), document(true),
+	gridPixels(0), collided(false), hoveringIntersection(false),
+	dragged(NULL), draggingObject(false), angleSnap(false)
 {
-//	document.isTopLevelContainer = true;
 //wtf? doesn't work except in c++11???	document = { 0 };
 	setBackgroundRole(QPalette::Base);
 	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
 	Global::gridSpacing = 12.0;		// In base units (inch is default)
-
 #if 0
 	Line * line = new Line(Vector(5, 5), Vector(50, 40), &document);
 	document.Add(line);
@@ -76,21 +75,22 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 #endif
 #else
 	Line * line = new Line;//(Vector(5, 5), Vector(50, 40), &document);
-	line->p1 = Vector(5, 5);
-	line->p2 = Vector(50, 40);
+	line->p[0] = Vector(5, 5);
+	line->p[1] = Vector(50, 40);
 	line->type = OTLine;
 	line->thickness = 2.0;
 	line->style = LSDash;
 	line->color = 0xFF7F00;
+	line->layer = 0;
 	document.objects.push_back(line);
 	document.objects.push_back(new Line(Vector(50, 40), Vector(10, 83)));
 	document.objects.push_back(new Line(Vector(10, 83), Vector(17, 2)));
 	document.objects.push_back(new Circle(Vector(100, 100), 36));
 	document.objects.push_back(new Circle(Vector(50, 150), 49));
-	document.objects.push_back(new Arc(Vector(300, 300), 32, PI / 4.0, PI * 1.3)),
-	document.objects.push_back(new Arc(Vector(200, 200), 60, PI / 2.0, PI * 1.5));
+	document.objects.push_back(new Arc(Vector(300, 300), 32, TAU / 8.0, TAU * 0.65)),
+	document.objects.push_back(new Arc(Vector(200, 200), 60, TAU / 4.0, TAU * 0.75));
 	document.objects.push_back(new Dimension(Vector(50, 40), Vector(5, 5)));
-	document.objects.push_back(new Text(Vector(10, 83), "Tyegxt!"));
+	document.objects.push_back(new Text(Vector(10, 83), "Here is some awesome text!"));
 #endif
 
 /*
@@ -143,20 +143,6 @@ we do! :-)
 }
 
 
-#if 0
-void DrawingView::SetToolActive(Action * action)
-{
-	if (action != NULL)
-	{
-		toolAction = action;
-		connect(toolAction, SIGNAL(ObjectReady(Object *)), this,
-			SLOT(AddNewObjectToDocument(Object *)));
-		connect(toolAction, SIGNAL(NeedRefresh()), this, SLOT(HandleActionUpdate()));
-	}
-}
-#endif
-
-
 void DrawingView::SetGridSize(uint32_t size)
 {
 	// Sanity check
@@ -178,7 +164,6 @@ void DrawingView::SetGridSize(uint32_t size)
 	pmp.end();
 
 	// Set up new BG brush & zoom level (pixels per base unit)
-//	Painter::zoom = gridPixels / gridSpacing;
 	Global::zoom = gridPixels / Global::gridSpacing;
 	UpdateGridBackground();
 }
@@ -263,36 +248,74 @@ zero; so we do another modulus operation on the result to achieve this.
 }
 
 
-void DrawingView::AddNewObjectToDocument(Object * object)
+//
+// Basically, we just make a single pass through the Container. If the layer #
+// is less than the layer # being deleted, then do nothing. If the layer # is
+// equal to the layer # being deleted, then delete the object. If the layer #
+// is greater than the layer # being deleted, then set the layer # to its layer
+// # - 1.
+//
+void DrawingView::DeleteCurrentLayer(int layer)
 {
-	if (object)
+//printf("DrawingView::DeleteCurrentLayer(): currentLayer = %i\n", layer);
+	std::vector<void *>::iterator i = document.objects.begin();
+
+	while (i != document.objects.end())
 	{
-//		object->Reparent(&document);
-//		document.Add(object);
-		update();
+		Object * obj = (Object *)(*i);
+
+		if (obj->layer < layer)
+			i++;
+		else if (obj->layer == layer)
+		{
+			document.objects.erase(i);
+			delete obj;
+		}
+		else
+		{
+			obj->layer--;
+			i++;
+		}
 	}
-//printf("DrawingView::AddNewObjectToDocument(). object=%08X\n", object);
+
+	// We've just done a destructive action, so update the screen!
+	update();
 }
 
 
-void DrawingView::HandleActionUpdate(void)
+void DrawingView::HandleLayerToggle(void)
 {
+	// A layer's visibility was toggled, so update the screen...
 	update();
 }
 
 
-void DrawingView::SetCurrentLayer(int layer)
+//
+// A layer was moved up or down in the layer list, so we have to swap the
+// document's object's layer numbers in the layers that were swapped.
+//
+void DrawingView::HandleLayerSwap(int layer1, int layer2)
 {
-	Global::currentLayer = layer;
-//printf("DrawingView::CurrentLayer = %i\n", layer);
+//printf("DrawingView: Swapping layers %i and %i.\n", layer1, layer2);
+	std::vector<void *>::iterator i;
+
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+	{
+		Object * obj = (Object *)(*i);
+
+		if (obj->layer == layer1)
+			obj->layer = layer2;
+		else if (obj->layer == layer2)
+			obj->layer = layer1;
+	}
 }
 
 
 QPoint DrawingView::GetAdjustedMousePosition(QMouseEvent * event)
 {
-	// This is undoing the transform, e.g. going from client coords to local coords.
-	// In essence, the height - y is height + (y * -1), the (y * -1) term doing the
-	// conversion of the y-axis from increasing bottom to top.
+	// This is undoing the transform, e.g. going from client coords to local
+	// coords. In essence, the height - y is height + (y * -1), the (y * -1)
+	// term doing the conversion of the y-axis from increasing bottom to top.
 	return QPoint(offsetX + event->x(), offsetY + (size().height() - event->y()));
 }
 
@@ -301,7 +324,7 @@ QPoint DrawingView::GetAdjustedClientPosition(int x, int y)
 {
 	// VOODOO ALERT (ON Y COMPONENT!!!!) (eh?)
 	// No voodoo here, it's just grouped wrong to see it. It should be:
-	// -offsetY + (size.height() + (y * -1.0)) <-- this is wrong, offsetY should be positive
+	// -offsetY + (size.height() + (y * -1.0)) <-- this is wrong, offsetY should be positive [why? we use -offsetX after all]
 	return QPoint(-offsetX + x, (size().height() - (-offsetY + y)) * +1.0);
 }
 
@@ -321,132 +344,165 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 	painter.DrawLine(0, -16384, 0, 16384);
 	painter.DrawLine(-16384, 0, 16384, 0);
 
-	// The top level document takes care of rendering for us...
-//	document.Draw(&painter);
-	// Not any more it doesn't...
-	RenderObjects(&painter, &document);
+	// Do object rendering...
+	for(int i=0; i<Global::numLayers; i++)
+	{
+		if (Global::layerHidden[i] == false)
+			RenderObjects(&painter, document.objects, i);
+	}
 
-#if 0
-	if (toolAction)
+	// Do tool rendering, if any...
+	if (Global::tool)
 	{
 		painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
 		painter.DrawCrosshair(oldPoint);
-		toolAction->Draw(&painter);
+		ToolDraw(&painter);
 	}
-#endif
 
-#if 1
+	// Do selection rectangle rendering, if any
 	if (Global::selectionInProgress)
 	{
 		painter.SetPen(QPen(QColor(255, 127, 0, 255)));
 		painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
 		painter.DrawRect(Global::selection);
 	}
-#endif
+
+	if (hoveringIntersection)
+		painter.DrawHandle(intersectionPoint);
+
+	if (!informativeText.isEmpty())
+		painter.DrawInformativeText(informativeText);
 }
 
 
-void DrawingView::RenderObjects(Painter * painter, Container * c)
+//
+// Renders objects in the passed in vector
+//
+void DrawingView::RenderObjects(Painter * painter, std::vector<void *> & v, int layer, bool ignoreLayer/*= false*/)
 {
 	std::vector<void *>::iterator i;
 
-	for(i=c->objects.begin(); i!=c->objects.end(); i++)
+	for(i=v.begin(); i!=v.end(); i++)
 	{
 		Object * obj = (Object *)(*i);
 		float scaledThickness = Global::scale * obj->thickness;
-		painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
-		painter->SetBrush(obj->color);
 
-		if (obj->selected || obj->hovered)
-			painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash);
+		// If the object isn't on the current layer being drawn, skip it
+		if (!ignoreLayer && (obj->layer != layer))
+			continue;
+
+		if ((Global::tool == TTRotate) && ctrlDown && obj->selected)
+		{
+			painter->SetPen(0x00FF00, 2.0, LSSolid);
+		}
+		else
+		{
+			painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
+			painter->SetBrush(obj->color);
+
+			if (obj->selected || obj->hitObject)
+				painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash);
+		}
 
 		switch (obj->type)
 		{
 		case OTLine:
-		{
-			Line * l = (Line *)obj;
-			painter->DrawLine(l->p1, l->p2);
+			painter->DrawLine(obj->p[0], obj->p[1]);
+
+			if (obj->hitPoint[0])
+				painter->DrawHandle(obj->p[0]);
+
+			if (obj->hitPoint[1])
+				painter->DrawHandle(obj->p[1]);
+
 			break;
-		}
 		case OTCircle:
-		{
-			Circle * ci = (Circle *)obj;
 			painter->SetBrush(QBrush(Qt::NoBrush));
-			painter->DrawEllipse(ci->p1, ci->radius, ci->radius);
+			painter->DrawEllipse(obj->p[0], obj->radius[0], obj->radius[0]);
+
+			if (obj->hitPoint[0])
+				painter->DrawHandle(obj->p[0]);
+
 			break;
-		}
 		case OTArc:
-		{
-			Arc * a = (Arc *)obj;
-			painter->DrawArc(a->p1, a->radius, a->angle1, a->angle2);
+			painter->DrawArc(obj->p[0], obj->radius[0], obj->angle[0], obj->angle[1]);
+
+			if (obj->hitPoint[0])
+				painter->DrawHandle(obj->p[0]);
+
+			if (obj->hitPoint[1])
+				painter->DrawHandle(obj->p[0] + (Vector(cos(obj->angle[0]), sin(obj->angle[0])) * obj->radius[0]));
+
+			if (obj->hitPoint[2])
+				painter->DrawHandle(obj->p[0] + (Vector(cos(obj->angle[0] + obj->angle[1]), sin(obj->angle[0] + obj->angle[1])) * obj->radius[0]));
+
 			break;
-		}
 		case OTDimension:
 		{
 			Dimension * d = (Dimension *)obj;
 
-			Vector v(d->p1, d->p2);
+			Vector v(d->p[0], d->p[1]);
 			double angle = v.Angle();
 			Vector unit = v.Unit();
-			Vector linePt1 = d->p1, linePt2 = d->p2;
+			d->lp[0] = d->p[0], d->lp[1] = d->p[1];
 			Vector ortho;
 			double x1, y1, length;
 
 			if (d->subtype == DTLinearVert)
 			{
-				if ((angle < 0) || (angle > PI))
+				if ((angle < 0) || (angle > HALF_TAU))
 				{
-					x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x);
-					y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y);
+					x1 = (d->p[0].x > d->p[1].x ? d->p[0].x : d->p[1].x);
+					y1 = (d->p[0].y > d->p[1].y ? d->p[0].y : d->p[1].y);
 					ortho = Vector(1.0, 0);
-					angle = PI3_OVER_2;
+					angle = THREE_QTR_TAU;
 				}
 				else
 				{
-					x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x);
-					y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y);
+					x1 = (d->p[0].x > d->p[1].x ? d->p[1].x : d->p[0].x);
+					y1 = (d->p[0].y > d->p[1].y ? d->p[1].y : d->p[0].y);
 					ortho = Vector(-1.0, 0);
-					angle = PI_OVER_2;
+					angle = QTR_TAU;
 				}
 
-				linePt1.x = linePt2.x = x1;
-				length = fabs(d->p1.y - d->p2.y);
+				d->lp[0].x = d->lp[1].x = x1;
+				length = fabs(d->p[0].y - d->p[1].y);
 			}
 			else if (d->subtype == DTLinearHorz)
 			{
-				if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
+				if ((angle < QTR_TAU) || (angle > THREE_QTR_TAU))
 				{
-					x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x);
-					y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y);
+					x1 = (d->p[0].x > d->p[1].x ? d->p[0].x : d->p[1].x);
+					y1 = (d->p[0].y > d->p[1].y ? d->p[0].y : d->p[1].y);
 					ortho = Vector(0, 1.0);
 					angle = 0;
 				}
 				else
 				{
-					x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x);
-					y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y);
+					x1 = (d->p[0].x > d->p[1].x ? d->p[1].x : d->p[0].x);
+					y1 = (d->p[0].y > d->p[1].y ? d->p[1].y : d->p[0].y);
 					ortho = Vector(0, -1.0);
-					angle = PI;
+					angle = HALF_TAU;
 				}
 
-				linePt1.y = linePt2.y = y1;
-				length = fabs(d->p1.x - d->p2.x);
+				d->lp[0].y = d->lp[1].y = y1;
+				length = fabs(d->p[0].x - d->p[1].x);
 			}
 			else if (d->subtype == DTLinear)
 			{
-				angle = Vector(linePt1, linePt2).Angle();
-				ortho = Vector::Normal(linePt1, linePt2);
+				angle = Vector(d->lp[0], d->lp[1]).Angle();
+				ortho = Vector::Normal(d->lp[0], d->lp[1]);
 				length = v.Magnitude();
 			}
 
-			unit = Vector(linePt1, linePt2).Unit();
+			unit = Vector(d->lp[0], d->lp[1]).Unit();
 
-			Point p1 = linePt1 + (ortho * 10.0 * scaledThickness);
-			Point p2 = linePt2 + (ortho * 10.0 * scaledThickness);
-			Point p3 = linePt1 + (ortho * 16.0 * scaledThickness);
-			Point p4 = linePt2 + (ortho * 16.0 * scaledThickness);
-			Point p5 = d->p1 + (ortho * 4.0 * scaledThickness);
-			Point p6 = d->p2 + (ortho * 4.0 * scaledThickness);
+			Point p1 = d->lp[0] + (ortho * 10.0 * scaledThickness);
+			Point p2 = d->lp[1] + (ortho * 10.0 * scaledThickness);
+			Point p3 = d->lp[0] + (ortho * 16.0 * scaledThickness);
+			Point p4 = d->lp[1] + (ortho * 16.0 * scaledThickness);
+			Point p5 = d->p[0] + (ortho * 4.0 * scaledThickness);
+			Point p6 = d->p[1] + (ortho * 4.0 * scaledThickness);
 
 		/*
 		The numbers hardcoded into here, what are they?
@@ -456,13 +512,12 @@ void DrawingView::RenderObjects(Painter * painter, Container * c)
 			painter->DrawLine(p3, p5);
 			painter->DrawLine(p4, p6);
 
-			// Calculate whether or not the arrowheads are too crowded to put inside
-			// the extension lines. 9.0 is the length of the arrowhead.
-			double t = Geometry::ParameterOfLineAndPoint(linePt1, linePt2, linePt2 - (unit * 9.0 * scaledThickness));
-		//printf("Dimension::Draw(): t = %lf\n", t);
+			// Calculate whether or not the arrowheads are too crowded to put
+			// inside the extension lines. 9.0 is the length of the arrowhead.
+			double t = Geometry::ParameterOfLineAndPoint(d->lp[0], d->lp[1], d->lp[1] - (unit * 9.0 * scaledThickness));
 
-		// On the screen, it's acting like this is actually 58%...
-		// This is correct, we want it to happen at > 50%
+			// On the screen, it's acting like this is actually 58%...
+			// This is correct, we want it to happen at > 50%
 			if (t > 0.58)
 			{
 				// Draw main dimension line + arrowheads
@@ -485,9 +540,6 @@ void DrawingView::RenderObjects(Painter * painter, Container * c)
 			painter->SetFont(QFont("Arial", 8.0 * Global::zoom * scaledThickness));
 			Point ctr = p2 + (Vector(p2, p1) / 2.0);
 
-		#if 0
-			QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
-		#else
 			QString dimText;
 
 			if (length < 12.0)
@@ -502,18 +554,83 @@ void DrawingView::RenderObjects(Painter * painter, Container * c)
 				else
 					dimText = QString("%1' %2\"").arg(feet).arg(inches);
 			}
-		#endif
 
 			painter->DrawAngledText(ctr, angle, dimText, scaledThickness);
 
+			if (d->hitObject)
+			{
+				Point hp1 = (p1 + p2) / 2.0;
+				Point hp2 = (p1 + hp1) / 2.0;
+				Point hp3 = (hp1 + p2) / 2.0;
+
+				if (d->hitPoint[2])
+				{
+					painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+					painter->SetBrush(QBrush(QColor(Qt::magenta)));
+					painter->DrawArrowHandle(hp1, ortho.Angle() + HALF_TAU);
+					painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+				}
+
+				painter->DrawHandle(hp1);
+				painter->SetPen(QPen(Qt::blue, 1.0 * Global::zoom * scaledThickness, Qt::SolidLine));
+
+				if (d->hitPoint[3])
+				{
+					painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+					painter->SetBrush(QBrush(QColor(Qt::magenta)));
+					painter->DrawArrowToLineHandle(hp2, (d->subtype == DTLinearVert ? v.Angle() - QTR_TAU : (v.Angle() < HALF_TAU ? HALF_TAU : 0)));
+					painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+				}
+
+				painter->DrawHandle(hp2);
+				painter->SetPen(QPen(Qt::blue, 1.0 * Global::zoom * scaledThickness, Qt::SolidLine));
+
+				if (d->hitPoint[4])
+				{
+					painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+					painter->SetBrush(QBrush(QColor(Qt::magenta)));
+					painter->DrawArrowToLineHandle(hp3, (d->subtype == DTLinearHorz ? v.Angle() - QTR_TAU : (v.Angle() > HALF_TAU && v.Angle() < THREE_QTR_TAU ? THREE_QTR_TAU : QTR_TAU)));
+					painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+				}
+
+				painter->DrawHandle(hp3);
+			}
+
+			if (obj->hitPoint[0])
+				painter->DrawHandle(obj->p[0]);
+
+			if (obj->hitPoint[1])
+				painter->DrawHandle(obj->p[1]);
+
 			break;
 		}
 		case OTText:
 		{
 			Text * t = (Text *)obj;
+			painter->DrawTextObject(t->p[0], t->s.c_str(), scaledThickness);
+			break;
+		}
+		case OTSpline:
+		{
+			break;
+		}
+		case OTPolygon:
+		{
+			break;
+		}
+		case OTContainer:
+		{
+			// Containers require recursive rendering...
+			Container * c = (Container *)obj;
+			RenderObjects(painter, (*c).objects, layer);
 
-			for(float angle=0; angle<(PI*3.0/2.0); angle+=PI/8.0)
-				painter->DrawTextObject(t->p1, t->s.c_str(), scaledThickness, angle);
+//printf("Container extents: <%lf, %lf>, <%lf, %lf>\nsize: %i\n", r.l, r.t, r.r, r.b, c->objects.size());
+			// Containers also have special indicators showing they are selected
+			if (c->selected || c->hitObject)
+			{
+				Rect r = GetObjectExtents(obj);
+				painter->DrawRectCorners(r);
+			}
 
 			break;
 		}
@@ -524,362 +641,771 @@ void DrawingView::RenderObjects(Painter * painter, Container * c)
 }
 
 
-void DrawingView::resizeEvent(QResizeEvent * /*event*/)
+void DrawingView::AddHoveredToSelection(void)
 {
-	Global::screenSize = Vector(size().width(), size().height());
-	UpdateGridBackground();
+	std::vector<void *>::iterator i;
+
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+	{
+		if (((Object *)(*i))->hovered)
+			((Object *)(*i))->selected = true;
+	}
 }
 
 
-void DrawingView::mousePressEvent(QMouseEvent * event)
+void DrawingView::GetSelection(std::vector<void *> & v)
 {
-	if (event->button() == Qt::LeftButton)
-	{
-		Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
-//		collided = document.Collided(point);
-		collided = false;
-
-		// Do an update if collided with at least *one* object in the document
-//		if (collided)
-//			update();
+	v.clear();
+	std::vector<void *>::iterator i;
 
-#if 0
-		if (toolAction)
-		{
-			if (Global::snapToGrid)
-				point = Global::SnapPointToGrid(point);
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+	{
+		if (((Object *)(*i))->selected)
+			v.push_back(*i);
+	}
+}
 
-			// We always snap to object points, and they take precendence over
-			// grid points...
-			if (Global::snapPointIsValid)
-				point = Global::snapPoint;
 
-			toolAction->MouseDown(point);
-		}
-#endif
+void DrawingView::GetHovered(std::vector<void *> & v)
+{
+	v.clear();
+	std::vector<void *>::iterator i;
 
-#if 1
-		// Didn't hit any object and not using a tool, so do a selection rectangle
-		if (!(collided))// || toolAction))
-		{
-			Global::selectionInProgress = true;
-			Global::selection.setTopLeft(QPointF(point.x, point.y));
-			Global::selection.setBottomRight(QPointF(point.x, point.y));
-		}
-#endif
-	}
-	else if (event->button() == Qt::MiddleButton)
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
 	{
-		scrollDrag = true;
-		oldPoint = Vector(event->x(), event->y());
-		// Should also change the mouse pointer as well...
-		setCursor(Qt::SizeAllCursor);
+		if (((Object *)(*i))->hovered)
+//		{
+//printf("GetHovered: adding object (%X) to hover... hp1=%s, hp2=%s, hl=%s\n", (*i), (((Line *)(*i))->hitPoint[0] ? "true" : "false"), (((Line *)(*i))->hitPoint[1] ? "true" : "false"), (((Line *)(*i))->hitObject ? "true" : "false"));
+			v.push_back(*i);
+//		}
 	}
 }
 
 
-void DrawingView::mouseMoveEvent(QMouseEvent * event)
+void DrawingView::resizeEvent(QResizeEvent * /*event*/)
 {
-	Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
-	Global::selection.setBottomRight(QPointF(point.x, point.y));
-	// Only needs to be done here, as mouse down is always preceded by movement
-	Global::snapPointIsValid = false;
+	Global::screenSize = Vector(size().width(), size().height());
+	UpdateGridBackground();
+}
 
-	// Scrolling...
-	if (event->buttons() & Qt::MiddleButton)
-	{
-		point = Vector(event->x(), event->y());
-		// Since we're using Qt coords for scrolling, we have to adjust them here to
-		// conform to Cartesian coords, since the origin is using Cartesian. :-)
-		Vector delta(oldPoint, point);
-		delta /= Global::zoom;
-		delta.y = -delta.y;
-		Global::origin -= delta;
 
-		UpdateGridBackground();
-		update();
-		oldPoint = point;
-		return;
-	}
+void DrawingView::ToolHandler(int mode, Point p)
+{
+	// Drop angle snap until it's needed
+	angleSnap = false;
+
+	if (Global::tool == TTLine)
+		LineHandler(mode, p);
+	else if (Global::tool == TTCircle)
+		CircleHandler(mode, p);
+	else if (Global::tool == TTArc)
+		ArcHandler(mode, p);
+	else if (Global::tool == TTRotate)
+		RotateHandler(mode, p);
+	else if (Global::tool == TTMirror)
+		MirrorHandler(mode, p);
+}
 
-#if 1
-	// Grid processing... (only snap here is left button is down)
-	if ((event->buttons() & Qt::LeftButton) && Global::snapToGrid)
+
+void DrawingView::ToolDraw(Painter * painter)
+{
+	if (Global::tool == TTLine)
 	{
-		point = SnapPointToGrid(point);
+		if (Global::toolState == TSNone)
+		{
+			painter->DrawHandle(toolPoint[0]);
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			painter->DrawHandle(toolPoint[1]);
+		}
+		else
+		{
+			painter->DrawLine(toolPoint[0], toolPoint[1]);
+			painter->DrawHandle(toolPoint[1]);
+
+			Vector v(toolPoint[0], toolPoint[1]);
+			double absAngle = v.Angle() * RADIANS_TO_DEGREES;
+			double absLength = v.Magnitude();
+			QString text = tr("Length: %1 in.\n") + QChar(0x2221) + tr(": %2");
+			informativeText = text.arg(absLength).arg(absAngle);
+		}
 	}
-
-	// Snap points on objects always take precedence over the grid, whether
-	// dragging an object or not...
-//thisnowok
-	if (Global::snapPointIsValid)
+	else if (Global::tool == TTCircle)
 	{
-// Uncommenting this causes the cursor to become unresponsive after the first
-// object is added.
-//		point = Global::snapPoint;
+		if (Global::toolState == TSNone)
+		{
+			painter->DrawHandle(toolPoint[0]);
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			painter->DrawHandle(toolPoint[1]);
+		}
+		else
+		{
+			painter->DrawCross(toolPoint[0]);
+			double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(toolPoint[0], length, length);
+			QString text = tr("Radius: %1 in.");
+			informativeText = text.arg(length);
+		}
 	}
-#endif
-
-	// Do checking here to see if object can be selected or not
-	if (Global::selectionInProgress)
+	else if (Global::tool == TTArc)
 	{
-		std::vector<void *>::iterator i;
-//		QRectF bounds;
+		if (Global::toolState == TSNone)
+		{
+			painter->DrawHandle(toolPoint[0]);
+		}
+		else if (Global::toolState == TSPoint2)
+		{
+			double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(toolPoint[0], length, length);
+			painter->DrawLine(toolPoint[0], toolPoint[1]);
+			painter->DrawHandle(toolPoint[1]);
+			QString text = tr("Radius: %1 in.");
+			informativeText = text.arg(length);
+		}
+		else if (Global::toolState == TSPoint3)
+		{
+			double angle = Vector::Angle(toolPoint[0], toolPoint[2]);
+			painter->DrawLine(toolPoint[0], toolPoint[2]);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(toolPoint[0], toolPoint[1].x, toolPoint[1].x);
+			painter->DrawHandle(toolPoint[0] + (Vector(cos(angle), sin(angle)) * toolPoint[1].x));
+			QString text = tr("Angle start: %1") + QChar(0x00B0);
+			informativeText = text.arg(RADIANS_TO_DEGREES * angle);
+		}
+		else
+		{
+			double angle = Vector::Angle(toolPoint[0], toolPoint[3]);
+			double span = angle - toolPoint[2].x;
 
-		for(i=document.objects.begin(); i!=document.objects.end(); i++)
+			if (span < 0)
+				span += TAU;
+
+			painter->DrawLine(toolPoint[0], toolPoint[3]);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(toolPoint[0], toolPoint[1].x, toolPoint[1].x);
+			painter->SetPen(0xFF00FF, 2.0, LSSolid);
+			painter->DrawArc(toolPoint[0], toolPoint[1].x, toolPoint[2].x, span);
+			painter->DrawHandle(toolPoint[0] + (Vector(cos(angle), sin(angle)) * toolPoint[1].x));
+			QString text = tr("Arc span: %1") + QChar(0x00B0);
+			informativeText = text.arg(RADIANS_TO_DEGREES * span);
+		}
+	}
+	else if (Global::tool == TTRotate)
+	{
+		if ((Global::toolState == TSNone) || (Global::toolState == TSPoint1))
+			painter->DrawHandle(toolPoint[0]);
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+			painter->DrawHandle(toolPoint[1]);
+		else
 		{
-			Object * obj = (Object *)(*i);
-			obj->selected = false;
-//			QRectF extents;
+			if (toolPoint[0] == toolPoint[1])
+				return;
 
-			switch (obj->type)
-			{
-			case OTLine:
-			{
-				Line * l = (Line *)obj;
+			painter->DrawLine(toolPoint[0], toolPoint[1]);
 
-				if (Global::selection.contains(l->p1.x, l->p1.y) && Global::selection.contains(l->p2.x, l->p2.y))
-					l->selected = true;
+			double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
+			QString text = QChar(0x2221) + QObject::tr(": %1");
+			informativeText = text.arg(absAngle);
 
-				break;
-			}
-			case OTCircle:
-			{
-				Circle * c = (Circle *)obj;
+			if (ctrlDown)
+				informativeText += " (Copy)";
+		}
+	}
+	else if (Global::tool == TTMirror)
+	{
+		if ((Global::toolState == TSNone) || (Global::toolState == TSPoint1))
+			painter->DrawHandle(toolPoint[0]);
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+			painter->DrawHandle(toolPoint[1]);
+		else
+		{
+			if (toolPoint[0] == toolPoint[1])
+				return;
+			
+			Point mirrorPoint = toolPoint[0] + Vector(toolPoint[1], toolPoint[0]);
+			painter->DrawLine(mirrorPoint, toolPoint[1]);
 
-				if (Global::selection.contains(c->p1.x - c->radius, c->p1.y - c->radius) && Global::selection.contains(c->p1.x + c->radius, c->p1.y + c->radius))
-					c->selected = true;
+			double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
 
-				break;
-			}
-			case OTArc:
-			{
-				Arc * a = (Arc *)obj;
+			if (absAngle > 180.0)
+				absAngle -= 180.0;
 
-	double start = a->angle1;
-	double end = start + a->angle2;
-	QPointF p1(cos(start), sin(start));
-	QPointF p2(cos(end), sin(end));
-	QRectF bounds(p1, p2);
+			QString text = QChar(0x2221) + QObject::tr(": %1");
+			informativeText = text.arg(absAngle);
 
-#if 1
-	// Swap X/Y coordinates if they're backwards...
-	if (bounds.left() > bounds.right())
-	{
-		double temp = bounds.left();
-		bounds.setLeft(bounds.right());
-		bounds.setRight(temp);
+			if (ctrlDown)
+				informativeText += " (Copy)";
+		}
 	}
+}
 
-	if (bounds.bottom() > bounds.top())
+
+void DrawingView::LineHandler(int mode, Point p)
+{
+	switch (mode)
 	{
-		double temp = bounds.bottom();
-		bounds.setBottom(bounds.top());
-		bounds.setTop(temp);
+	case ToolMouseDown:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseMove:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseUp:
+		if (Global::toolState == TSNone)
+		{
+			Global::toolState = TSPoint2;
+			// Prevent spurious line from drawing...
+			toolPoint[1] = toolPoint[0];
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			// Key override is telling us to make a new line, not continue the
+			// previous one.
+			toolPoint[0] = toolPoint[1];
+		}
+		else
+		{
+			Line * l = new Line(toolPoint[0], toolPoint[1]);
+			l->layer = Global::activeLayer;
+			document.objects.push_back(l);
+			toolPoint[0] = toolPoint[1];
+		}
 	}
-#else
-	// Doesn't work as advertised! For shame!
-	bounds = bounds.normalized();
-#endif
-
-	// If the end of the arc is before the beginning, add 360 degrees to it
-	if (end < start)
-		end += 2.0 * PI;
-
-	// Adjust the bounds depending on which axes are crossed
-	if ((start < PI_OVER_2) && (end > PI_OVER_2))
-		bounds.setTop(1.0);
-
-	if ((start < PI) && (end > PI))
-		bounds.setLeft(-1.0);
+}
 
-	if ((start < (PI + PI_OVER_2)) && (end > (PI + PI_OVER_2)))
-		bounds.setBottom(-1.0);
 
-	if ((start < (2.0 * PI)) && (end > (2.0 * PI)))
-		bounds.setRight(1.0);
+void DrawingView::CircleHandler(int mode, Point p)
+{
+	switch (mode)
+	{
+	case ToolMouseDown:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseMove:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseUp:
+		if (Global::toolState == TSNone)
+		{
+			Global::toolState = TSPoint2;
+			// Prevent spurious line from drawing...
+			toolPoint[1] = toolPoint[0];
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			// Key override is telling us to make a new line, not continue the
+			// previous one.
+			toolPoint[0] = toolPoint[1];
+		}
+		else
+		{
+			double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+			Circle * c = new Circle(toolPoint[0], length);
+			c->layer = Global::activeLayer;
+			document.objects.push_back(c);
+			toolPoint[0] = toolPoint[1];
+			Global::toolState = TSNone;
+		}
+	}
+}
 
-	if ((start < ((2.0 * PI) + PI_OVER_2)) && (end > ((2.0 * PI) + PI_OVER_2)))
-		bounds.setTop(1.0);
 
-	if ((start < (3.0 * PI)) && (end > (3.0 * PI)))
-		bounds.setLeft(-1.0);
+void DrawingView::ArcHandler(int mode, Point p)
+{
+	switch (mode)
+	{
+	case ToolMouseDown:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else if (Global::toolState == TSPoint2)
+			toolPoint[1] = p;
+		else if (Global::toolState == TSPoint3)
+			toolPoint[2] = p;
+		else
+			toolPoint[3] = p;
+
+		break;
+	case ToolMouseMove:
+		if (Global::toolState == TSNone)
+			toolPoint[0] = p;
+		else if (Global::toolState == TSPoint2)
+			toolPoint[1] = p;
+		else if (Global::toolState == TSPoint3)
+		{
+			toolPoint[2] = p;
+			angleSnap = true;
+		}
+		else
+		{
+			toolPoint[3] = p;
+			angleSnap = true;
+		}
 
-	if ((start < ((3.0 * PI) + PI_OVER_2)) && (end > ((3.0 * PI) + PI_OVER_2)))
-		bounds.setBottom(-1.0);
+		break;
+	case ToolMouseUp:
+		if (Global::toolState == TSNone)
+		{
+			// Prevent spurious line from drawing...
+			toolPoint[1] = toolPoint[0];
+			Global::toolState = TSPoint2;
+		}
+		else if (Global::toolState == TSPoint2)
+		{
+			if (shiftDown)
+			{
+				// Key override is telling us to start arc at new center, not
+				// continue the current one.
+				toolPoint[0] = toolPoint[1];
+				return;
+			}
 
-	bounds.setTopLeft(QPointF(bounds.left() * a->radius, bounds.top() * a->radius));
-	bounds.setBottomRight(QPointF(bounds.right() * a->radius, bounds.bottom() * a->radius));
-	bounds.translate(a->p1.x, a->p1.y);
+			// Set the radius in toolPoint[1].x
+			toolPoint[1].x = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+			Global::toolState = TSPoint3;
+		}
+		else if (Global::toolState == TSPoint3)
+		{
+			// Set the angle in toolPoint[2].x
+			toolPoint[2].x = Vector::Angle(toolPoint[0], toolPoint[2]);
+			Global::toolState = TSPoint4;
+		}
+		else
+		{
+			double endAngle = Vector::Angle(toolPoint[0], toolPoint[3]);
+			double span = endAngle - toolPoint[2].x;
 
-				if (Global::selection.contains(bounds))
-					a->selected = true;
+			if (span < 0)
+				span += TAU;
 
-				break;
-			}
-			default:
-				break;
-			}
+			Arc * arc = new Arc(toolPoint[0], toolPoint[1].x, toolPoint[2].x, span);
+			arc->layer = Global::activeLayer;
+			document.objects.push_back(arc);
+			Global::toolState = TSNone;
 		}
 	}
+}
 
-//	oldPoint = point;
-//we should keep track of the last point here and only pass this down *if* the point
-//changed...
 
-#if 0
-	// This returns true if we've moved over an object...
-	if (document.PointerMoved(point))
+void DrawingView::RotateHandler(int mode, Point p)
+{
+	switch (mode)
 	{
-/*
-Now objects handle mouse move snapping as well. The code below mainly works only
-for tools; we need to fix it so that objects work as well...
+	case ToolMouseDown:
+		if (Global::toolState == TSNone)
+		{
+			toolPoint[0] = p;
+			SavePointsFrom(select, toolScratch);
+			Global::toolState = TSPoint1;
+		}
+		else if (Global::toolState == TSPoint1)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseMove:
+		if ((Global::toolState == TSPoint1) || (Global::toolState == TSNone))
+			toolPoint[0] = p;
+		else if (Global::toolState == TSPoint2)
+		{
+			toolPoint[1] = p;
 
-There's a problem with the object point snapping in that it's dependent on the
-order of the objects in the document. Most likely this is because it counts the
-selected object last and thus fucks up the algorithm. Need to fix this...
+			if (shiftDown)
+				return;
 
+			angleSnap = true;
+			double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+			std::vector<void *>::iterator j = select.begin();
+			std::vector<Object>::iterator i = toolScratch.begin();
 
-*/
-		// Do object snapping here. Grid snapping on mouse down is done in the
-		// objects themselves, only because we have to hit test the raw point,
-		// not the snapped point. There has to be a better way...!
-		if (document.penultimateObjectHovered)
-		{
-			// Two objects are hovered, see if we have an intersection point
-			if ((document.lastObjectHovered->type == OTLine) && (document.penultimateObjectHovered->type == OTLine))
+			for(; i!=toolScratch.end(); i++, j++)
 			{
-				double t;
-				int n = Geometry::Intersects((Line *)document.lastObjectHovered, (Line *)document.penultimateObjectHovered, &t);
-
-				if (n == 1)
+				Object obj = *i;
+				Point p1 = Geometry::RotatePointAroundPoint(obj.p[0], toolPoint[0], angle);
+				Point p2 = Geometry::RotatePointAroundPoint(obj.p[1], toolPoint[0], angle);
+				Object * obj2 = (Object *)(*j);
+				obj2->p[0] = p1;
+				obj2->p[1] = p2;
+
+				if (obj.type == OTArc)
 				{
-					Global::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
-					Global::snapPointIsValid = true;
+					obj2->angle[0] = obj.angle[0] + angle;
+
+					if (obj2->angle[0] > TAU)
+						obj2->angle[0] -= TAU;
 				}
 			}
-			else if ((document.lastObjectHovered->type == OTCircle) && (document.penultimateObjectHovered->type == OTCircle))
+		}
+
+		break;
+	case ToolMouseUp:
+		if (Global::toolState == TSPoint1)
+		{
+			Global::toolState = TSPoint2;
+			// Prevent spurious line from drawing...
+			toolPoint[1] = toolPoint[0];
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			// Key override is telling us to make a new line, not continue the
+			// previous one.
+			toolPoint[0] = toolPoint[1];
+		}
+		else
+		{
+			// Either we're finished with our rotate, or we're stamping a copy.
+			if (ctrlDown)
 			{
-				Point p1, p2;
-				int n = Geometry::Intersects((Circle *)document.lastObjectHovered, (Circle *)document.penultimateObjectHovered, 0, 0, 0, 0, &p1, &p2);
+				// Stamp a copy of the selection at the current rotation & bail
+				std::vector<void *> temp;
+				CopyObjects(select, temp);
+				ClearSelected(temp);
+				AddObjectsTo(document.objects, temp);
+				RestorePointsTo(select, toolScratch);
+				return;
+			}
 
-				if (n == 1)
-				{
-					Global::snapPoint = p1;
-					Global::snapPointIsValid = true;
-				}
-				else if (n == 2)
-				{
-					double d1 = Vector(point, p1).Magnitude();
-					double d2 = Vector(point, p2).Magnitude();
+			toolPoint[0] = p;
+			Global::toolState = TSPoint1;
+			SavePointsFrom(select, toolScratch);
+		}
+
+		break;
+	case ToolKeyDown:
+		// Reset the selection if shift held down...
+		if (shiftDown)
+			RestorePointsTo(select, toolScratch);
+
+		break;
+	case ToolKeyUp:
+		// Reset selection when key is let up
+		if (!shiftDown)
+			RotateHandler(ToolMouseMove, toolPoint[1]);
+
+		break;
+	case ToolCleanup:
+		RestorePointsTo(select, toolScratch);
+	}
+}
+
+
+void DrawingView::MirrorHandler(int mode, Point p)
+{
+	switch (mode)
+	{
+	case ToolMouseDown:
+		if (Global::toolState == TSNone)
+		{
+			toolPoint[0] = p;
+			SavePointsFrom(select, toolScratch);
+			Global::toolState = TSPoint1;
+		}
+		else if (Global::toolState == TSPoint1)
+			toolPoint[0] = p;
+		else
+			toolPoint[1] = p;
+
+		break;
+	case ToolMouseMove:
+		if ((Global::toolState == TSPoint1) || (Global::toolState == TSNone))
+			toolPoint[0] = p;
+		else if (Global::toolState == TSPoint2)
+		{
+			toolPoint[1] = p;
+
+			if (shiftDown)
+				return;
 
-					if (d1 < d2)
-						Global::snapPoint = p1;
-					else
-						Global::snapPoint = p2;
+			angleSnap = true;
+			double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+			std::vector<void *>::iterator j = select.begin();
+			std::vector<Object>::iterator i = toolScratch.begin();
 
-					Global::snapPointIsValid = true;
+			for(; i!=toolScratch.end(); i++, j++)
+			{
+				Object obj = *i;
+				Point p1 = Geometry::MirrorPointAroundLine(obj.p[0], toolPoint[0], toolPoint[1]);
+				Point p2 = Geometry::MirrorPointAroundLine(obj.p[1], toolPoint[0], toolPoint[1]);
+				Object * obj2 = (Object *)(*j);
+				obj2->p[0] = p1;
+				obj2->p[1] = p2;
+
+				if (obj.type == OTArc)
+				{
+					// This is 2*mirror angle - obj angle - obj span
+					obj2->angle[0] = (2.0 * angle) - obj.angle[0] - obj.angle[1];
+
+					if (obj2->angle[0] > TAU)
+						obj2->angle[0] -= TAU;
 				}
 			}
 		}
-//		else
-//		{
-			// Otherwise, it was a single object hovered...
-//		}
-	}
 
-	if (toolAction)
-	{
-		if (Global::snapToGrid)
-			point = Global::SnapPointToGrid(point);
+		break;
+	case ToolMouseUp:
+		if (Global::toolState == TSPoint1)
+		{
+			Global::toolState = TSPoint2;
+			// Prevent spurious line from drawing...
+			toolPoint[1] = toolPoint[0];
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			// Key override is telling us to make a new line, not continue the
+			// previous one.
+			toolPoint[0] = toolPoint[1];
+		}
+		else
+		{
+			// Either we're finished with our rotate, or we're stamping a copy.
+			if (ctrlDown)
+			{
+				// Stamp a copy of the selection at the current rotation & bail
+				std::vector<void *> temp;
+				CopyObjects(select, temp);
+				ClearSelected(temp);
+				AddObjectsTo(document.objects, temp);
+				RestorePointsTo(select, toolScratch);
+				return;
+			}
 
-		// We always snap to object points, and they take precendence over
-		// grid points...
-		if (Global::snapPointIsValid)
-			point = Global::snapPoint;
+			toolPoint[0] = p;
+			Global::toolState = TSPoint1;
+			SavePointsFrom(select, toolScratch);
+		}
 
-		toolAction->MouseMoved(point);
+		break;
+	case ToolKeyDown:
+		// Reset the selection if shift held down...
+		if (shiftDown)
+			RestorePointsTo(select, toolScratch);
+
+		break;
+	case ToolKeyUp:
+		// Reset selection when key is let up
+		if (!shiftDown)
+			MirrorHandler(ToolMouseMove, toolPoint[1]);
+
+		break;
+	case ToolCleanup:
+		RestorePointsTo(select, toolScratch);
 	}
-#endif
-	bool needUpdate = false;
+}
 
-	// Don't do this kind of checking unless we're not doing a selection rectangle!
-	// Hmm, lines don't stay selected if globally selected... !!! FIX !!!
-	// it's because there were extra state variables, the hit* vars...
-	if (!Global::selectionInProgress)
-	{
-	std::vector<void *>::iterator i;
-	int numHovered = 0;
 
-	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+void DrawingView::mousePressEvent(QMouseEvent * event)
+{
+	if (event->button() == Qt::LeftButton)
 	{
-		Object * obj = (Object *)(*i);
-//		obj->selected = false;
+		Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
 
-		switch (obj->type)
+		// Handle tool processing, if any
+		if (Global::tool)
 		{
-		case OTLine:
+			if (hoveringIntersection)
+				point = intersectionPoint;
+			else if (Global::snapToGrid)
+				point = SnapPointToGrid(point);
+
+			//Also, may want to figure out if hovering over a snap point on an
+			//object, snap to grid if not.
+			// Snap to object point if valid...
+//			if (Global::snapPointIsValid)
+//				point = Global::snapPoint;
+
+			ToolHandler(ToolMouseDown, point);
+			return;
+		}
+
+		// Clear the selection only if CTRL isn't being held on click
+		if (!ctrlDown)
+			ClearSelected(document.objects);
+//			ClearSelection();
+
+		// If any objects are being hovered on click, add them to the selection
+		// & return
+		if (numHovered > 0)
 		{
-			Line * l = (Line *)obj;
+			AddHoveredToSelection();
+			update();	// needed??
+			GetHovered(hover);	// prolly needed
+			dragged = (Object *)hover[0];
+			draggingObject = true;
+
+			// See if anything is using just a straight click on a handle
+			if (HandleObjectClicked())
+			{
+				draggingObject = false;
+				update();
+				return;
+			}
 
-//	bool hitPoint1, hitPoint2, hitLine;
-	l->hitPoint[0] = l->hitPoint[1] = l->hitObject = false;
-	Vector lineSegment = l->p2 - l->p1;
-	Vector v1 = point - l->p1;
-	Vector v2 = point - l->p2;
-	double t = Geometry::ParameterOfLineAndPoint(l->p1, l->p2, point);
-	double distance;
-
-	if (t < 0.0)
-		distance = v1.Magnitude();
-	else if (t > 1.0)
-		distance = v2.Magnitude();
-	else
-		// distance = ?Det?(ls, v1) / |ls|
-		distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y)
-			/ lineSegment.Magnitude());
+			// Needed for grab & moving objects
+			// We do it *after*... why? (doesn't seem to confer any advantage...)
+			if (hoveringIntersection)
+				oldPoint = intersectionPoint;
+			else if (Global::snapToGrid)
+				oldPoint = SnapPointToGrid(point);
 
-	if ((v1.Magnitude() * Global::zoom) < 8.0)
+			return;
+		}
+
+		// Didn't hit any object and not using a tool, so do a selection rectangle
+		Global::selectionInProgress = true;
+		Global::selection.setTopLeft(QPointF(point.x, point.y));
+		Global::selection.setBottomRight(QPointF(point.x, point.y));
+	}
+	else if (event->button() == Qt::MiddleButton)
 	{
-		l->hitPoint[0] = true;
-//		snapPoint = l->p1;
-//		snapPointIsValid = true;
+		scrollDrag = true;
+		oldPoint = Vector(event->x(), event->y());
+		// Should also change the mouse pointer as well...
+		setCursor(Qt::SizeAllCursor);
 	}
-	else if ((v2.Magnitude() * Global::zoom) < 8.0)
+}
+
+
+void DrawingView::mouseMoveEvent(QMouseEvent * event)
+{
+	Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
+	Global::selection.setBottomRight(QPointF(point.x, point.y));
+	// Only needs to be done here, as mouse down is always preceded by movement
+	Global::snapPointIsValid = false;
+	hoveringIntersection = false;
+
+	// Scrolling...
+	if (event->buttons() & Qt::MiddleButton)
+	{
+		point = Vector(event->x(), event->y());
+		// Since we're using Qt coords for scrolling, we have to adjust them
+		// here to conform to Cartesian coords, since the origin is using
+		// Cartesian. :-)
+		Vector delta(oldPoint, point);
+		delta /= Global::zoom;
+		delta.y = -delta.y;
+		Global::origin -= delta;
+
+		UpdateGridBackground();
+		update();
+		oldPoint = point;
+		return;
+	}
+
+	// If we're doing a selection rect, see if any objects are engulfed by it
+	// (implies left mouse button held down)
+	if (Global::selectionInProgress)
 	{
-		l->hitPoint[1] = true;
-//		snapPoint = l->p2;
-//		snapPointIsValid = true;
+		CheckObjectBounds();
+		update();
+		return;
 	}
-	else if ((distance * Global::zoom) < 5.0)
-		l->hitObject = true;
 
-	bool oldHovered = l->hovered;
-	l->hovered = (l->hitPoint[0] || l->hitPoint[1] || l->hitObject ? true : false);
+	// Do object hit testing...
+	bool needUpdate = HitTestObjects(point);
+	GetHovered(hover);
 
-	if (oldHovered != l->hovered)
-		needUpdate = true;
+	// Check for multi-hover...
+	if (numHovered > 1)
+	{
+//need to check for case where hover is over 2 circles and a 3rd's center...
+		Object * obj1 = (Object *)hover[0], * obj2 = (Object *)hover[1];
 
-			break;
+		Geometry::Intersects(obj1, obj2);
+		int numIntersecting = Global::numIntersectParams;
+		double t = Global::intersectParam[0];
+		double u = Global::intersectParam[1];
+
+		if (numIntersecting > 0)
+		{
+			Vector v1 = Geometry::GetPointForParameter(obj1, t);
+			Vector v2 = Geometry::GetPointForParameter(obj2, u);
+			QString text = tr("Intersection t=%1 (%3, %4), u=%2 (%5, %6)");
+			informativeText = text.arg(t).arg(u).arg(v1.x).arg(v1.y).arg(v2.x).arg(v2.y);
+
+			hoveringIntersection = true;
+			intersectionPoint = v1;
 		}
-		case OTCircle:
+
+		numIntersecting = Global::numIntersectPoints;
+
+		if (numIntersecting > 0)
 		{
-			Circle * c = (Circle *)obj;
+			Vector v1 = Global::intersectPoint[0];
 
+			if (numIntersecting == 2)
+			{
+				Vector v2 = Global::intersectPoint[1];
 
-			break;
-		}
-		default:
-			break;
+				if (Vector::Magnitude(v2, point) < Vector::Magnitude(v1, point))
+					v1 = v2;
+			}
+
+			QString text = tr("Intersection <%1, %2>");
+			informativeText = text.arg(v1.x).arg(v1.y);
+			hoveringIntersection = true;
+			intersectionPoint = v1;
 		}
 	}
+
+	// Handle object movement (left button down & over an object)
+	if ((event->buttons() & Qt::LeftButton) && draggingObject && !Global::tool)
+	{
+		if (hoveringIntersection)
+			point = intersectionPoint;
+		else if (hoverPointValid)
+			point = hoverPoint;
+		else if (Global::snapToGrid)
+			point = SnapPointToGrid(point);
+
+		HandleObjectMovement(point);
+		update();
+		oldPoint = point;
+		return;
+	}
+
+	// Do tool handling, if any are active...
+	if (Global::tool)
+	{
+		if (hoveringIntersection)
+			point = intersectionPoint;
+		else if (hoverPointValid)
+			point = hoverPoint;
+		else if (Global::snapToGrid)
+		{
+			if (angleSnap)
+				point = SnapPointToAngle(point);
+			else
+				point = SnapPointToGrid(point);
+		}
+
+		ToolHandler(ToolMouseMove, point);
 	}
 
 	// This is used to draw the tool crosshair...
 	oldPoint = point;
 
-//	if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
-	if (needUpdate || Global::selectionInProgress)
+	if (needUpdate || Global::tool)
 		update();
 }
 
@@ -888,27 +1414,40 @@ void DrawingView::mouseReleaseEvent(QMouseEvent * event)
 {
 	if (event->button() == Qt::LeftButton)
 	{
-#if 0
-		document.PointerReleased();
-#endif
-
 //We need to update especially if nothing collided and the state needs to change. !!! FIX !!!
-//could set it up to use the document's update function (assumes that all object updates
-//are being reported correctly:
+//could set it up to use the document's update function (assumes that all object
+//updates are being reported correctly:
 //		if (document.NeedsUpdate())
+		// Do an update if collided with at least *one* object in the document
 //		if (collided)
-			update();	// Do an update if collided with at least *one* object in the document
+			update();
 
-#if 0
-		if (toolAction)
-			toolAction->MouseReleased();
-#endif
+		if (Global::tool)
+		{
+			Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
+			ToolHandler(ToolMouseUp, point);
+			return;
+		}
 
 		if (Global::selectionInProgress)
-		{
-			// Select all the stuff inside of selection
 			Global::selectionInProgress = false;
+
+		informativeText.clear();
+// Should we be doing this automagically? Hmm...
+		// Clear our vectors
+		select.clear();
+		hover.clear();
+
+		// Scoop 'em up
+		std::vector<void *>::iterator i;
+
+		for(i=document.objects.begin(); i!=document.objects.end(); i++)
+		{
+			if (((Object *)(*i))->selected)
+				select.push_back(*i);
 		}
+
+		draggingObject = false;
 	}
 	else if (event->button() == Qt::MiddleButton)
 	{
@@ -939,33 +1478,78 @@ void DrawingView::wheelEvent(QWheelEvent * event)
 		Global::zoom /= zoomFactor;
 	}
 
-#if 1
 //	Global::gridSpacing = gridPixels / Painter::zoom;
 //	UpdateGridBackground();
 	SetGridSize(Global::gridSpacing * Global::zoom);
 	update();
 //	zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
-#endif
 }
 
 
 void DrawingView::keyPressEvent(QKeyEvent * event)
 {
-#if 0
-	if (toolAction)
-		toolAction->KeyDown(event->key());
-#endif
+	bool oldShift = shiftDown;
+	bool oldCtrl = ctrlDown;
+
+	if (event->key() == Qt::Key_Shift)
+		shiftDown = true;
+	else if (event->key() == Qt::Key_Control)
+		ctrlDown = true;
+
+	if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
+	{
+		if (Global::tool)
+			ToolHandler(ToolKeyDown, Point(0, 0));
+
+		update();
+	}
+
+	if (select.size() > 0)
+	{
+		if (event->key() == Qt::Key_Up)
+		{
+			TranslateObjects(select, Point(0, +1.0));
+			update();
+		}
+		else if (event->key() == Qt::Key_Down)
+		{
+			TranslateObjects(select, Point(0, -1.0));
+			update();
+		}
+		else if (event->key() == Qt::Key_Right)
+		{
+			TranslateObjects(select, Point(+1.0, 0));
+			update();
+		}
+		else if (event->key() == Qt::Key_Left)
+		{
+			TranslateObjects(select, Point(-1.0, 0));
+			update();
+		}
+	}
 }
 
 
 void DrawingView::keyReleaseEvent(QKeyEvent * event)
 {
-#if 0
-	if (toolAction)
-		toolAction->KeyReleased(event->key());
-#endif
+	bool oldShift = shiftDown;
+	bool oldCtrl = ctrlDown;
+
+	if (event->key() == Qt::Key_Shift)
+		shiftDown = false;
+	else if (event->key() == Qt::Key_Control)
+		ctrlDown = false;
+
+	if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
+	{
+		if (Global::tool)
+			ToolHandler(ToolKeyUp, Point(0, 0));
+
+		update();
+	}
 }
 
+
 //
 // This looks strange, but it's really quite simple: We want a point that's
 // more than half-way to the next grid point to snap there while conversely we
@@ -985,3 +1569,604 @@ Point DrawingView::SnapPointToGrid(Point point)
 	return point;
 }
 
+
+Point DrawingView::SnapPointToAngle(Point point)
+{
+	// Snap to a single digit angle (using toolpoint #1 as the center)
+	double angle = Vector::Angle(toolPoint[0], point);
+	double length = Vector::Magnitude(toolPoint[0], point);
+
+	// Convert from radians to degrees
+	double degAngle = angle * RADIANS_TO_DEGREES;
+	double snapAngle = (double)((int)(degAngle + 0.5));
+
+	Vector v;
+	v.SetAngleAndLength(snapAngle * DEGREES_TO_RADIANS, length);
+	point = toolPoint[0] + v;
+
+	return point;
+}
+
+
+Rect DrawingView::GetObjectExtents(Object * obj)
+{
+	// Default to empty rect, if object checks below fail for some reason
+	Rect rect;
+
+	switch (obj->type)
+	{
+	case OTLine:
+	case OTDimension:
+	{
+		rect = Rect(obj->p[0], obj->p[1]);
+		break;
+	}
+	case OTCircle:
+	{
+		rect = Rect(obj->p[0], obj->p[0]);
+		rect.Expand(obj->radius[0]);
+		break;
+	}
+	case OTArc:
+	{
+		Arc * a = (Arc *)obj;
+
+		double start = a->angle[0];
+		double end = start + a->angle[1];
+		rect = Rect(Point(cos(start), sin(start)), Point(cos(end), sin(end)));
+
+		// If the end of the arc is before the beginning, add 360 degrees to it
+		if (end < start)
+			end += TAU;
+
+		// Adjust the bounds depending on which axes are crossed
+		if ((start < QTR_TAU) && (end > QTR_TAU))
+			rect.t = 1.0;
+
+		if ((start < HALF_TAU) && (end > HALF_TAU))
+			rect.l = -1.0;
+
+		if ((start < THREE_QTR_TAU) && (end > THREE_QTR_TAU))
+			rect.b = -1.0;
+
+		if ((start < TAU) && (end > TAU))
+			rect.r = 1.0;
+
+		if ((start < (TAU + QTR_TAU)) && (end > (TAU + QTR_TAU)))
+			rect.t = 1.0;
+
+		if ((start < (TAU + HALF_TAU)) && (end > (TAU + HALF_TAU)))
+			rect.l = -1.0;
+
+		if ((start < (TAU + THREE_QTR_TAU)) && (end > (TAU + THREE_QTR_TAU)))
+			rect.b = -1.0;
+
+		rect *= a->radius[0];
+		rect.Translate(a->p[0]);
+
+		break;
+	}
+	case OTContainer:
+	{
+		Container * c = (Container *)obj;
+		std::vector<void *>::iterator i = c->objects.begin();
+		rect = GetObjectExtents((Object *)*i);
+		i++;
+
+		for(; i!=c->objects.end(); i++)
+			rect |= GetObjectExtents((Object *)*i);
+	}
+	default:
+		break;
+	}
+
+	return rect;
+}
+
+
+void DrawingView::CheckObjectBounds(void)
+{
+	std::vector<void *>::iterator i;
+
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+	{
+		Object * obj = (Object *)(*i);
+		obj->selected = false;
+
+		switch (obj->type)
+		{
+		case OTLine:
+		case OTDimension:
+		{
+			Line * l = (Line *)obj;
+
+			if (Global::selection.contains(l->p[0].x, l->p[0].y) && Global::selection.contains(l->p[1].x, l->p[1].y))
+				l->selected = true;
+
+			break;
+		}
+		case OTCircle:
+		{
+			Circle * c = (Circle *)obj;
+
+			if (Global::selection.contains(c->p[0].x - c->radius[0], c->p[0].y - c->radius[0]) && Global::selection.contains(c->p[0].x + c->radius[0], c->p[0].y + c->radius[0]))
+				c->selected = true;
+
+			break;
+		}
+		case OTArc:
+		{
+			Arc * a = (Arc *)obj;
+
+			double start = a->angle[0];
+			double end = start + a->angle[1];
+			QPointF p1(cos(start), sin(start));
+			QPointF p2(cos(end), sin(end));
+			QRectF bounds(p1, p2);
+
+#if 1
+			// Swap X/Y coordinates if they're backwards...
+			if (bounds.left() > bounds.right())
+			{
+				double temp = bounds.left();
+				bounds.setLeft(bounds.right());
+				bounds.setRight(temp);
+			}
+
+			if (bounds.bottom() > bounds.top())
+			{
+				double temp = bounds.bottom();
+				bounds.setBottom(bounds.top());
+				bounds.setTop(temp);
+			}
+#else
+			// Doesn't work as advertised! For shame!
+			bounds = bounds.normalized();
+#endif
+
+			// If the end of the arc is before the beginning, add 360 degrees to it
+			if (end < start)
+				end += TAU;
+
+			// Adjust the bounds depending on which axes are crossed
+			if ((start < QTR_TAU) && (end > QTR_TAU))
+				bounds.setTop(1.0);
+
+			if ((start < HALF_TAU) && (end > HALF_TAU))
+				bounds.setLeft(-1.0);
+
+			if ((start < THREE_QTR_TAU) && (end > THREE_QTR_TAU))
+				bounds.setBottom(-1.0);
+
+			if ((start < TAU) && (end > TAU))
+				bounds.setRight(1.0);
+
+			if ((start < (TAU + QTR_TAU)) && (end > (TAU + QTR_TAU)))
+				bounds.setTop(1.0);
+
+			if ((start < (TAU + HALF_TAU)) && (end > (TAU + HALF_TAU)))
+				bounds.setLeft(-1.0);
+
+			if ((start < (TAU + THREE_QTR_TAU)) && (end > (TAU + THREE_QTR_TAU)))
+				bounds.setBottom(-1.0);
+
+			bounds.setTopLeft(QPointF(bounds.left() * a->radius[0], bounds.top() * a->radius[0]));
+			bounds.setBottomRight(QPointF(bounds.right() * a->radius[0], bounds.bottom() * a->radius[0]));
+			bounds.translate(a->p[0].x, a->p[0].y);
+
+			if (Global::selection.contains(bounds))
+				a->selected = true;
+
+			break;
+		}
+		default:
+			break;
+		}
+	}
+}
+
+
+bool DrawingView::HitTestObjects(Point point)
+{
+	std::vector<void *>::iterator i;
+	numHovered = 0;
+	bool needUpdate = false;
+	hoverPointValid = false;
+
+	for(i=document.objects.begin(); i!=document.objects.end(); i++)
+	{
+		Object * obj = (Object *)(*i);
+
+		// If we're seeing the object we're dragging, skip it
+		if (draggingObject && (obj == dragged))
+			continue;
+
+		if (HitTest(obj, point))
+			needUpdate = true;
+
+		if (obj->hovered)
+		{
+			numHovered++;
+//printf("MouseMove: OBJECT HOVERED (numHovered = %i)\n", numHovered);
+			emit(ObjectHovered(obj));
+		}
+	}
+
+	return needUpdate;
+}
+
+
+bool DrawingView::HitTest(Object * obj, Point point)
+{
+	bool needUpdate = false;
+
+	switch (obj->type)
+	{
+	case OTLine:
+	{
+		bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHO = obj->hitObject;
+		obj->hitPoint[0] = obj->hitPoint[1] = obj->hitObject = false;
+		Vector lineSegment = obj->p[1] - obj->p[0];
+		Vector v1 = point - obj->p[0];
+		Vector v2 = point - obj->p[1];
+		double t = Geometry::ParameterOfLineAndPoint(obj->p[0], obj->p[1], point);
+		double distance;
+
+		if (t < 0.0)
+			distance = v1.Magnitude();
+		else if (t > 1.0)
+			distance = v2.Magnitude();
+		else
+			// distance = ?Det?(ls, v1) / |ls|
+			distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y)
+				/ lineSegment.Magnitude());
+
+		if ((v1.Magnitude() * Global::zoom) < 8.0)
+		{
+			obj->hitPoint[0] = true;
+			hoverPoint = obj->p[0];
+			hoverPointValid = true;
+		}
+		else if ((v2.Magnitude() * Global::zoom) < 8.0)
+		{
+			obj->hitPoint[1] = true;
+			hoverPoint = obj->p[1];
+			hoverPointValid = true;
+		}
+		else if ((distance * Global::zoom) < 5.0)
+			obj->hitObject = true;
+
+		obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitObject ? true : false);
+
+		if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHO != obj->hitObject))
+			needUpdate = true;
+
+		break;
+	}
+	case OTCircle:
+	{
+		bool oldHP = obj->hitPoint[0], oldHO = obj->hitObject;
+		obj->hitPoint[0] = obj->hitObject = false;
+		double length = Vector::Magnitude(obj->p[0], point);
+
+		if ((length * Global::zoom) < 8.0)
+			obj->hitPoint[0] = true;
+		else if ((fabs(length - obj->radius[0]) * Global::zoom) < 2.0)
+			obj->hitObject = true;
+
+		obj->hovered = (obj->hitPoint[0] || obj->hitObject ? true : false);
+
+		if ((oldHP != obj->hitPoint[0]) || (oldHO != obj->hitObject))
+			needUpdate = true;
+
+		break;
+	}
+	case OTArc:
+	{
+		bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHP2 = obj->hitPoint[2], oldHO = obj->hitObject;
+		obj->hitPoint[0] = obj->hitPoint[1] = obj->hitPoint[2] = obj->hitObject = false;
+		double length = Vector::Magnitude(obj->p[0], point);
+		double angle = Vector::Angle(obj->p[0], point);
+
+		// Make sure we get the angle in the correct spot
+		if (angle < obj->angle[0])
+			angle += TAU;
+
+		// Get the span that we're pointing at...
+		double span = angle - obj->angle[0];
+
+		// N.B.: Still need to hit test the arc start & arc span handles...
+		double spanAngle = obj->angle[0] + obj->angle[1];
+		Point handle1 = obj->p[0] + (Vector(cos(obj->angle[0]), sin(obj->angle[0])) * obj->radius[0]);
+		Point handle2 = obj->p[0] + (Vector(cos(spanAngle), sin(spanAngle)) * obj->radius[0]);
+		double length2 = Vector::Magnitude(point, handle1);
+		double length3 = Vector::Magnitude(point, handle2);
+
+		if ((length * Global::zoom) < 8.0)
+			obj->hitPoint[0] = true;
+		else if ((length2 * Global::zoom) < 8.0)
+		{
+			obj->hitPoint[1] = true;
+			hoverPoint = handle1;
+			hoverPointValid = true;
+		}
+		else if ((length3 * Global::zoom) < 8.0)
+		{
+			obj->hitPoint[2] = true;
+			hoverPoint = handle2;
+			hoverPointValid = true;
+		}
+		else if (((fabs(length - obj->radius[0]) * Global::zoom) < 2.0) && (span < obj->angle[1]))
+			obj->hitObject = true;
+
+		obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitPoint[2] || obj->hitObject ? true : false);
+
+		if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHP2 != obj->hitPoint[2]) || (oldHO != obj->hitObject))
+			needUpdate = true;
+
+		break;
+	}
+	case OTDimension:
+	{
+		bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHP2 = obj->hitPoint[2], oldHP3 = obj->hitPoint[3], oldHP4 = obj->hitPoint[4], oldHO = obj->hitObject;
+		obj->hitPoint[0] = obj->hitPoint[1] = obj->hitPoint[2] = obj->hitPoint[3] = obj->hitPoint[4] = obj->hitObject = false;
+
+		Dimension * d = (Dimension *)obj;
+
+		Vector orthogonal = Vector::Normal(d->lp[0], d->lp[1]);
+		// Get our line parallel to our points
+		float scaledThickness = Global::scale * obj->thickness;
+		Point p1 = d->lp[0] + (orthogonal * 10.0 * scaledThickness);
+		Point p2 = d->lp[1] + (orthogonal * 10.0 * scaledThickness);
+		Point p3(p1, point);
+
+		Vector v1(d->p[0], point);
+		Vector v2(d->p[1], point);
+		Vector lineSegment(p1, p2);
+		double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
+		double distance;
+		Point midpoint = (p1 + p2) / 2.0;
+		Point hFSPoint = Point(midpoint, point);
+		Point hCS1Point = Point((p1 + midpoint) / 2.0, point);
+		Point hCS2Point = Point((midpoint + p2) / 2.0, point);
+
+		if (t < 0.0)
+			distance = v1.Magnitude();
+		else if (t > 1.0)
+			distance = v2.Magnitude();
+		else
+			// distance = ?Det?(ls, v1) / |ls|
+			distance = fabs((lineSegment.x * p3.y - p3.x * lineSegment.y)
+				/ lineSegment.Magnitude());
+
+		if ((v1.Magnitude() * Global::zoom) < 8.0)
+			obj->hitPoint[0] = true;
+		else if ((v2.Magnitude() * Global::zoom) < 8.0)
+			obj->hitPoint[1] = true;
+		else if ((distance * Global::zoom) < 5.0)
+			obj->hitObject = true;
+
+		if ((hFSPoint.Magnitude() * Global::zoom) < 8.0)
+			obj->hitPoint[2] = true;
+		else if ((hCS1Point.Magnitude() * Global::zoom) < 8.0)
+			obj->hitPoint[3] = true;
+		else if ((hCS2Point.Magnitude() * Global::zoom) < 8.0)
+			obj->hitPoint[4] = true;
+
+//		return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch || hitChangeSwitch1 || hitChangeSwitch2 ? true : false);
+		obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitPoint[2] || obj->hitPoint[3] || obj->hitPoint[4] || obj->hitObject ? true : false);
+
+		if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHP2 != obj->hitPoint[2]) || (oldHP3 != obj->hitPoint[3]) || (oldHP4 != obj->hitPoint[4]) || (oldHO != obj->hitObject))
+			needUpdate = true;
+
+
+		break;
+	}
+	case OTContainer:
+	{
+		// Containers must be recursively tested...
+		Container * c = (Container *)obj;
+		c->hitObject = false;
+		c->hovered = false;
+		std::vector<void *>::iterator i;
+
+		for(i=c->objects.begin(); i!=c->objects.end(); i++)
+		{
+			Object * cObj = (Object *)*i;
+
+			if (HitTest(cObj, point))
+				needUpdate = true;
+
+			if (cObj->hitObject == true)
+				c->hitObject = true;
+
+			if (cObj->hovered == true)
+				c->hovered = true;
+		}
+
+		break;
+	}
+	default:
+		break;
+	}
+
+	return needUpdate;
+}
+
+
+bool DrawingView::HandleObjectClicked(void)
+{
+	if (dragged->type == OTDimension)
+	{
+		Dimension * d = (Dimension *)dragged;
+
+		if (d->hitPoint[2])
+		{
+			// Hit the "flip sides" switch, so flip 'em
+			Point temp = d->p[0];
+			d->p[0] = d->p[1];
+			d->p[1] = temp;
+			return true;
+		}
+		else if (d->hitPoint[3])
+		{
+			// There are three cases here: aligned, horizontal, & vertical.
+			// Aligned and horizontal do the same thing, vertical goes back to
+			// linear.
+			if (d->subtype == DTLinearVert)
+				d->subtype = DTLinear;
+			else
+				d->subtype = DTLinearVert;
+
+			return true;
+		}
+		else if (d->hitPoint[4])
+		{
+			// There are three cases here: aligned, horizontal, & vertical.
+			// Aligned and vertical do the same thing, horizontal goes back to
+			// linear.
+			if (d->subtype == DTLinearHorz)
+				d->subtype = DTLinear;
+			else
+				d->subtype = DTLinearHorz;
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+void DrawingView::HandleObjectMovement(Point point)
+{
+	Point delta = point - oldPoint;
+//printf("HOM: old = (%f,%f), new = (%f, %f), delta = (%f, %f)\n", oldPoint.x, oldPoint.y, point.x, point.y, delta.x, delta.y);
+//	Object * obj = (Object *)hover[0];
+	Object * obj = dragged;
+//printf("Object type = %i (size=%i), ", obj->type, hover.size());
+//printf("Object (%X) move: hp1=%s, hp2=%s, hl=%s\n", obj, (obj->hitPoint[0] ? "true" : "false"), (obj->hitPoint[1] ? "true" : "false"), (obj->hitObject ? "true" : "false"));
+
+	switch (obj->type)
+	{
+	case OTLine:
+		if (obj->hitPoint[0])
+			obj->p[0] = point;
+		else if (obj->hitPoint[1])
+			obj->p[1] = point;
+		else if (obj->hitObject)
+		{
+			obj->p[0] += delta;
+			obj->p[1] += delta;
+		}
+
+		break;
+
+	case OTCircle:
+		if (obj->hitPoint[0])
+			obj->p[0] = point;
+		else if (obj->hitObject)
+		{
+//this doesn't work. we need to save this on mouse down for this to work correctly!
+//			double oldRadius = obj->radius[0];
+			obj->radius[0] = Vector::Magnitude(obj->p[0], point);
+
+			QString text = QObject::tr("Radius: %1");//\nScale: %2%");
+			informativeText = text.arg(obj->radius[0], 0, 'd', 4);//.arg(obj->radius[0] / oldRadius * 100.0, 0, 'd', 0);
+		}
+
+		break;
+
+	case OTArc:
+		if (obj->hitPoint[0])
+			obj->p[0] = point;
+		else if (obj->hitPoint[1])
+		{
+			// Change the Arc's span (handle #1)
+			if (shiftDown)
+			{
+				double angle = Vector::Angle(obj->p[0], point);
+				double delta = angle - obj->angle[0];
+
+				if (delta < 0)
+					delta += TAU;
+
+				obj->angle[1] -= delta;
+				obj->angle[0] = angle;
+
+				if (obj->angle[1] < 0)
+					obj->angle[1] += TAU;
+
+				QString text = QObject::tr("Span: %1") + QChar(0x00B0) + QObject::tr("\n%2") + QChar(0x00B0) + QObject::tr(" - %3") + QChar(0x00B0);
+				informativeText = text.arg(obj->angle[1] * RADIANS_TO_DEGREES, 0, 'd', 4).arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 2).arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 2);
+				return;
+			}
+
+			double angle = Vector::Angle(obj->p[0], point);
+			obj->angle[0] = angle;
+			QString text = QObject::tr("Start angle: %1") + QChar(0x00B0);
+			informativeText = text.arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 4);
+		}
+		else if (obj->hitPoint[2])
+		{
+			// Change the Arc's span (handle #2)
+			if (shiftDown)
+			{
+				double angle = Vector::Angle(obj->p[0], point);
+				obj->angle[1] = angle - obj->angle[0];
+
+				if (obj->angle[1] < 0)
+					obj->angle[1] += TAU;
+
+				QString text = QObject::tr("Span: %1") + QChar(0x00B0) + QObject::tr("\n%2") + QChar(0x00B0) + QObject::tr(" - %3") + QChar(0x00B0);
+				informativeText = text.arg(obj->angle[1] * RADIANS_TO_DEGREES, 0, 'd', 4).arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 2).arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 2);
+				return;
+			}
+
+			double angle = Vector::Angle(obj->p[0], point);
+			obj->angle[0] = angle - obj->angle[1];
+
+			if (obj->angle[0] < 0)
+				obj->angle[0] += TAU;
+
+			QString text = QObject::tr("End angle: %1") + QChar(0x00B0);
+			informativeText = text.arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 4);
+		}
+		else if (obj->hitObject)
+		{
+			if (shiftDown)
+			{
+				return;
+			}
+
+			obj->radius[0] = Vector::Magnitude(obj->p[0], point);
+			QString text = QObject::tr("Radius: %1");
+			informativeText = text.arg(obj->radius[0], 0, 'd', 4);
+		}
+
+		break;
+
+	case OTDimension:
+		if (obj->hitPoint[0])
+			obj->p[0] = point;
+		else if (obj->hitPoint[1])
+			obj->p[1] = point;
+		else if (obj->hitObject)
+		{
+			obj->p[0] += delta;
+			obj->p[1] += delta;
+		}
+
+		break;
+
+	case OTContainer:
+		// This is shitty, but works for now until I can code up something
+		// nicer :-)
+		TranslateObject(obj, delta);
+
+		break;
+	default:
+		break;
+	}
+}
+