From: Shamus Hammons <jlhamm@acm.org>
Date: Wed, 22 Apr 2015 22:31:13 +0000 (-0500)
Subject: Lines respond to mouse movement, added Text rendering.
X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=architektonas;a=commitdiff_plain;h=f507d97c1b1118834a70332f5f79d8479a6964c0

Lines respond to mouse movement, added Text rendering.

Also, drag selection works now, and mouse hover works for Lines.
---

diff --git a/architektonas.pro b/architektonas.pro
index f29891e..deb6a46 100644
--- a/architektonas.pro
+++ b/architektonas.pro
@@ -55,6 +55,7 @@ HEADERS = \
 	src/drawingview.h \
 	src/fileio.h \
 	src/generaltab.h \
+	src/geometry.h \
 	src/global.h \
 	src/layerwidget.h \
 	src/layeritemwidget.h \
@@ -78,7 +79,6 @@ HEADERS = \
 #	src/drawsplineaction.h \
 #	src/drawtextaction.h \
 #	src/ellipse.h \
-#	src/geometry.h \
 #	src/line.h \
 #	src/mirroraction.h \
 #	src/object.h \
@@ -98,6 +98,7 @@ SOURCES = \
 	src/drawingview.cpp \
 	src/fileio.cpp \
 	src/generaltab.cpp \
+	src/geometry.cpp \
 	src/global.cpp \
 	src/layerwidget.cpp \
 	src/layeritemwidget.cpp \
@@ -119,7 +120,6 @@ SOURCES = \
 #	src/drawsplineaction.cpp \
 #	src/drawtextaction.cpp \
 #	src/ellipse.cpp \
-#	src/geometry.cpp \
 #	src/line.cpp \
 #	src/mirroraction.cpp \
 #	src/object.cpp \
diff --git a/src/arc.cpp b/src/arc.cpp
index f507869..6391eae 100644
--- a/src/arc.cpp
+++ b/src/arc.cpp
@@ -368,6 +368,7 @@ point (to get the correct position).
 	QPointF p2(cos(end), sin(end));
 	QRectF bounds(p1, p2);
 
+#if 0
 	// Swap X/Y coordinates if they're backwards...
 	if (bounds.left() > bounds.right())
 	{
@@ -382,6 +383,9 @@ point (to get the correct position).
 		bounds.setBottom(bounds.top());
 		bounds.setTop(temp);
 	}
+#else
+	bounds = bounds.normalized();
+#endif
 
 	// If the end of the arc is before the beginning, add 360 degrees to it
 	if (end < start)
diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index e93161a..58e0979 100644
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -30,6 +30,7 @@
 #include "drawingview.h"
 
 #include <stdint.h>
+#include "geometry.h"
 #include "global.h"
 #include "mathconstants.h"
 #include "painter.h"
@@ -78,7 +79,9 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 	line->p1 = Vector(5, 5);
 	line->p2 = Vector(50, 40);
 	line->type = OTLine;
-	line->thickness = 1.0;
+	line->thickness = 2.0;
+	line->style = LSDash;
+	line->color = 0xFF7F00;
 	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)));
@@ -86,6 +89,8 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 	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 Dimension(Vector(50, 40), Vector(5, 5)));
+	document.objects.push_back(new Text(Vector(10, 83), "Tyegxt!"));
 #endif
 
 /*
@@ -341,33 +346,175 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 }
 
 
-void DrawingView::RenderObjects(Painter * p, Container * c)
+void DrawingView::RenderObjects(Painter * painter, Container * c)
 {
 	std::vector<void *>::iterator i;
 
 	for(i=c->objects.begin(); i!=c->objects.end(); i++)
 	{
 		Object * obj = (Object *)(*i);
-		p->SetPen(QPen(Qt::black, 1.0 * Global::zoom * obj->thickness, Qt::SolidLine));
+		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);
 
 		switch (obj->type)
 		{
 		case OTLine:
 		{
 			Line * l = (Line *)obj;
-			p->DrawLine(l->p1, l->p2);
+			painter->DrawLine(l->p1, l->p2);
 			break;
 		}
 		case OTCircle:
 		{
 			Circle * ci = (Circle *)obj;
-			p->DrawEllipse(ci->p1, ci->radius, ci->radius);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(ci->p1, ci->radius, ci->radius);
 			break;
 		}
 		case OTArc:
 		{
 			Arc * a = (Arc *)obj;
-			p->DrawArc(a->p1, a->radius, a->angle1, a->angle2);
+			painter->DrawArc(a->p1, a->radius, a->angle1, a->angle2);
+			break;
+		}
+		case OTDimension:
+		{
+			Dimension * d = (Dimension *)obj;
+
+			Vector v(d->p1, d->p2);
+			double angle = v.Angle();
+			Vector unit = v.Unit();
+			Vector linePt1 = d->p1, linePt2 = d->p2;
+			Vector ortho;
+			double x1, y1, length;
+
+			if (d->subtype == DTLinearVert)
+			{
+				if ((angle < 0) || (angle > PI))
+				{
+					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);
+					ortho = Vector(1.0, 0);
+					angle = PI3_OVER_2;
+				}
+				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);
+					ortho = Vector(-1.0, 0);
+					angle = PI_OVER_2;
+				}
+
+				linePt1.x = linePt2.x = x1;
+				length = fabs(d->p1.y - d->p2.y);
+			}
+			else if (d->subtype == DTLinearHorz)
+			{
+				if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
+				{
+					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);
+					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);
+					ortho = Vector(0, -1.0);
+					angle = PI;
+				}
+
+				linePt1.y = linePt2.y = y1;
+				length = fabs(d->p1.x - d->p2.x);
+			}
+			else if (d->subtype == DTLinear)
+			{
+				angle = Vector(linePt1, linePt2).Angle();
+				ortho = Vector::Normal(linePt1, linePt2);
+				length = v.Magnitude();
+			}
+
+			unit = Vector(linePt1, linePt2).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);
+
+		/*
+		The numbers hardcoded into here, what are they?
+		I believe they are pixels.
+		*/
+			// Draw extension lines (if certain type)
+			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);
+
+		// 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
+				painter->DrawLine(p1, p2);
+				painter->DrawArrowhead(p1, p2, scaledThickness);
+				painter->DrawArrowhead(p2, p1, scaledThickness);
+			}
+			else
+			{
+				// Draw outside arrowheads
+				Point p7 = p1 - (unit * 9.0 * scaledThickness);
+				Point p8 = p2 + (unit * 9.0 * scaledThickness);
+				painter->DrawArrowhead(p1, p7, scaledThickness);
+				painter->DrawArrowhead(p2, p8, scaledThickness);
+				painter->DrawLine(p1, p1 - (unit * 14.0 * scaledThickness));
+				painter->DrawLine(p2, p2 + (unit * 14.0 * scaledThickness));
+			}
+
+			// Draw length of dimension line...
+			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)
+				dimText = QString("%1\"").arg(length);
+			else
+			{
+				double feet = (double)((int)length / 12);
+				double inches = length - (feet * 12.0);
+
+				if (inches == 0)
+					dimText = QString("%1'").arg(feet);
+				else
+					dimText = QString("%1' %2\"").arg(feet).arg(inches);
+			}
+		#endif
+
+			painter->DrawAngledText(ctr, angle, dimText, scaledThickness);
+
+			break;
+		}
+		case OTText:
+		{
+			Text * t = (Text *)obj;
+
+			for(float angle=0; angle<(PI*3.0/2.0); angle+=PI/8.0)
+				painter->DrawTextObject(t->p1, t->s.c_str(), scaledThickness, angle);
+
 			break;
 		}
 		default:
@@ -473,6 +620,109 @@ void DrawingView::mouseMoveEvent(QMouseEvent * event)
 	}
 #endif
 
+	// Do checking here to see if object can be selected or not
+	if (Global::selectionInProgress)
+	{
+		std::vector<void *>::iterator i;
+//		QRectF bounds;
+
+		for(i=document.objects.begin(); i!=document.objects.end(); i++)
+		{
+			Object * obj = (Object *)(*i);
+			obj->selected = false;
+//			QRectF extents;
+
+			switch (obj->type)
+			{
+			case OTLine:
+			{
+				Line * l = (Line *)obj;
+
+				if (Global::selection.contains(l->p1.x, l->p1.y) && Global::selection.contains(l->p2.x, l->p2.y))
+					l->selected = true;
+
+				break;
+			}
+			case OTCircle:
+			{
+				Circle * c = (Circle *)obj;
+
+				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;
+
+				break;
+			}
+			case OTArc:
+			{
+				Arc * a = (Arc *)obj;
+
+	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);
+
+#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 += 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);
+
+	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);
+
+	if ((start < ((3.0 * PI) + PI_OVER_2)) && (end > ((3.0 * PI) + PI_OVER_2)))
+		bounds.setBottom(-1.0);
+
+	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);
+
+				if (Global::selection.contains(bounds))
+					a->selected = true;
+
+				break;
+			}
+			default:
+				break;
+			}
+		}
+	}
+
 //	oldPoint = point;
 //we should keep track of the last point here and only pass this down *if* the point
 //changed...
@@ -551,14 +801,86 @@ selected object last and thus fucks up the algorithm. Need to fix this...
 		toolAction->MouseMoved(point);
 	}
 #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++)
+	{
+		Object * obj = (Object *)(*i);
+//		obj->selected = false;
+
+		switch (obj->type)
+		{
+		case OTLine:
+		{
+			Line * l = (Line *)obj;
+
+//	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());
+
+	if ((v1.Magnitude() * Global::zoom) < 8.0)
+	{
+		l->hitPoint[0] = true;
+//		snapPoint = l->p1;
+//		snapPointIsValid = true;
+	}
+	else if ((v2.Magnitude() * Global::zoom) < 8.0)
+	{
+		l->hitPoint[1] = true;
+//		snapPoint = l->p2;
+//		snapPointIsValid = true;
+	}
+	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);
+
+	if (oldHovered != l->hovered)
+		needUpdate = true;
+
+			break;
+		}
+		case OTCircle:
+		{
+			Circle * c = (Circle *)obj;
+
+
+			break;
+		}
+		default:
+			break;
+		}
+	}
+	}
 
 	// This is used to draw the tool crosshair...
 	oldPoint = point;
 
-#if 1
-	if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
+//	if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
+	if (needUpdate || Global::selectionInProgress)
 		update();
-#endif
 }
 
 
diff --git a/src/geometry.cpp b/src/geometry.cpp
index 1ec93db..e572fab 100644
--- a/src/geometry.cpp
+++ b/src/geometry.cpp
@@ -126,6 +126,7 @@ bool Geometry::Intersects(Object * obj1, Object * obj2, double * t, double * s)
 }
 #endif
 
+#if 0
 // Finds the intersection between two lines (if any)
 int Geometry::Intersects(Line * l1, Line * l2, double * tp/*= 0*/, double * up/*= 0*/)
 {
@@ -384,7 +385,7 @@ int Geometry::Intersects(Circle * c1, Circle * c2, double * tp/*= 0*/, double *
 
 	return 2;
 }
-
+#endif
 
 // should we just do common trig solves, like AAS, ASA, SAS, SSA?
 // Law of Cosines:
diff --git a/src/geometry.h b/src/geometry.h
index 410c7e0..2776ae3 100644
--- a/src/geometry.h
+++ b/src/geometry.h
@@ -3,9 +3,9 @@
 
 #include "vector.h"
 
-class Circle;
-class Dimension;
-class Line;
+//class Circle;
+//class Dimension;
+//class Line;
 
 class Geometry
 {
@@ -16,10 +16,10 @@ class Geometry
 		static Point MirrorPointAroundLine(Point, Point, Point);
 		static Point RotatePointAroundPoint(Point, Point, double);
 		static double Determinant(Point, Point);
-		static int Intersects(Line *, Line *, double * tp = 0, double * up = 0);
-		static int Intersects(Line *, Dimension *, double * tp = 0, double * up = 0);
-		static int Intersects(Line * l, Circle * c, double * tp = 0, double * up = 0, double * vp = 0, double * wp = 0);
-		static int Intersects(Circle * c1, Circle * c2, double * tp = 0, double * up = 0, double * vp = 0, double * wp = 0, Point * p1 = 0, Point * p2 = 0);
+//		static int Intersects(Line *, Line *, double * tp = 0, double * up = 0);
+//		static int Intersects(Line *, Dimension *, double * tp = 0, double * up = 0);
+//		static int Intersects(Line * l, Circle * c, double * tp = 0, double * up = 0, double * vp = 0, double * wp = 0);
+//		static int Intersects(Circle * c1, Circle * c2, double * tp = 0, double * up = 0, double * vp = 0, double * wp = 0, Point * p1 = 0, Point * p2 = 0);
 		static void FindAnglesForSides(double s1, double s2, double s3, double * a1, double * a2, double * a3);
 };
 
diff --git a/src/global.cpp b/src/global.cpp
index 296c6a3..be2f219 100644
--- a/src/global.cpp
+++ b/src/global.cpp
@@ -29,3 +29,4 @@ Vector Global::origin(-10.0, -10.0);
 double Global::zoom = 1.0;
 Vector Global::screenSize(200.0, 200.0);
 
+float Global::scale = 0.5;
diff --git a/src/global.h b/src/global.h
index a98b9ac..8143b8d 100644
--- a/src/global.h
+++ b/src/global.h
@@ -10,6 +10,9 @@
 
 class QFont;
 
+enum LineStyle { LSNone, LSSolid, LSDash, LSDot, LSDashDot, LSDashDotDot };
+
+
 class Global
 {
 	public:
@@ -32,10 +35,11 @@ class Global
 		static bool dontMove;
 		static uint32_t objectID;
 
-		// Coming soon...
 		static Point origin;
 		static double zoom;
 		static Vector screenSize;
+
+		static float scale;
 };
 
 #endif	// __GLOBALS_H__
diff --git a/src/painter.cpp b/src/painter.cpp
index 35528fa..61ee9b6 100644
--- a/src/painter.cpp
+++ b/src/painter.cpp
@@ -79,6 +79,26 @@ void Painter::SetRenderHint(int hint)
 }
 
 
+void Painter::SetPen(QPen pen)
+{
+	if (!painter)
+		return;
+
+	painter->setPen(pen);
+}
+
+
+void Painter::SetPen(uint32_t color, float size/*= 0*/, int style/*= 0*/)
+{
+	if (!painter)
+		return;
+
+	// We can cast style as Qt:PenStyle because they line up 1-to-1
+	painter->setPen(QPen(QColor(color >> 16, (color >> 8) & 0xFF, color & 0xFF, 255),
+		size, (Qt::PenStyle)style));
+}
+
+
 void Painter::SetBrush(QBrush brush)
 {
 	if (!painter)
@@ -88,21 +108,21 @@ void Painter::SetBrush(QBrush brush)
 }
 
 
-void Painter::SetFont(QFont font)
+void Painter::SetBrush(uint32_t color)
 {
 	if (!painter)
 		return;
 
-	painter->setFont(font);
+	painter->setBrush(QBrush(QColor(color >> 16, (color >> 8) & 0xFF, color & 0xFF, 255)));
 }
 
 
-void Painter::SetPen(QPen pen)
+void Painter::SetFont(QFont font)
 {
 	if (!painter)
 		return;
 
-	painter->setPen(pen);
+	painter->setFont(font);
 }
 
 
@@ -145,6 +165,30 @@ void Painter::DrawAngledText(Vector center, double angle, QString text, double s
 }
 
 
+//
+// Draw angled text. Draws text using point p as the upper left corner.
+// Size is point size, angle is in radians (defaults to 0).
+//
+void Painter::DrawTextObject(Point p, QString text, double size, double angle/*= 0*/)
+{
+	if (!painter)
+		return;
+
+	p = CartesianToQtCoords(p);
+	painter->setFont(QFont("Arial", Global::zoom * size));
+	int textWidth = QFontMetrics(painter->font()).width(text);
+	int textHeight = QFontMetrics(painter->font()).height();
+
+	QRectF textBox(0, 0, textWidth, textHeight);
+	painter->save();
+	painter->translate(p.x, p.y);
+	// Angles are backwards in the Qt coord system, so we flip ours...
+	painter->rotate(-angle * RADIANS_TO_DEGREES);
+	painter->drawText(textBox, Qt::AlignLeft | Qt::AlignTop , text);
+	painter->restore();
+}
+
+
 void Painter::DrawArc(Vector center, double radius, double startAngle, double span)
 {
 	center = CartesianToQtCoords(center);
diff --git a/src/painter.h b/src/painter.h
index af591b8..5e868d7 100644
--- a/src/painter.h
+++ b/src/painter.h
@@ -1,6 +1,7 @@
 #ifndef __PAINTER_H__
 #define __PAINTER_H__
 
+#include <stdint.h>
 #include <QtWidgets>
 #include "vector.h"
 
@@ -15,10 +16,13 @@ class Painter
 		~Painter();
 
 		void SetRenderHint(int);
+		void SetPen(QPen);
+		void SetPen(uint32_t, float size = 0, int style = 0);
 		void SetBrush(QBrush);
+		void SetBrush(uint32_t);
 		void SetFont(QFont);
-		void SetPen(QPen);
 		void DrawAngledText(Vector, double, QString, double);
+		void DrawTextObject(Vector, QString, double, double angle = 0);
 		void DrawArc(Vector, double, double, double);
 		void DrawEllipse(Vector, double, double);
 		void DrawHandle(Vector);
diff --git a/src/structs.h b/src/structs.h
index a6b52cc..f1b5ce1 100644
--- a/src/structs.h
+++ b/src/structs.h
@@ -7,7 +7,10 @@
 #include "global.h"
 #include "vector.h"
 
-enum ObjectType { OTNone, OTObject, OTLine, OTCircle, OTArc, OTDimension, OTEllipse, OTContainer, OTSpline };
+enum ObjectType { OTNone, OTLine, OTCircle, OTEllipse, OTArc, OTDimension, OTSpline, OTText, OTContainer };
+
+enum DimensionType { DTLinear, DTLinearVert, DTLinearHorz, DTRadial, DTDiametric, DTCircumferential, DTAngular, DTLeader };
+
 
 #define OBJECT_COMMON \
 	int type;         \
@@ -16,7 +19,10 @@ enum ObjectType { OTNone, OTObject, OTLine, OTCircle, OTArc, OTDimension, OTElli
 	uint32_t color;   \
 	float thickness;  \
 	int style;        \
-	bool selected;
+	bool selected;    \
+	bool hovered;     \
+	bool hitPoint[4]; \
+	bool hitObject;
 
 struct Line {
 	OBJECT_COMMON;
@@ -24,9 +30,9 @@ struct Line {
 	Point p2;
 
 	Line(): type(OTLine), id(Global::objectID++) {}
-	Line(Vector pt1, Vector pt2, float th = 1.0, uint32_t c = 0, int l = 0):
-		type(OTLine), id(Global::objectID++), layer(l), color(c), thickness(th),
-		style(0), selected(false), p1(pt1), p2(pt2) {}
+	Line(Vector pt1, Vector pt2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+		type(OTLine), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(l), selected(false), hovered(false), p1(pt1), p2(pt2) {}
 };
 
 struct Circle {
@@ -34,9 +40,21 @@ struct Circle {
 	Point p1;
 	double radius;
 
-	Circle(Vector pt1, double r, float th = 1.0, uint32_t c = 0, int l = 0):
-		type(OTCircle), id(Global::objectID++), layer(l), color(c), thickness(th),
-		style(0), selected(false), p1(pt1), radius(r) {}
+	Circle(Vector pt1, double r, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+		type(OTCircle), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(l), selected(false), hovered(false), p1(pt1), radius(r) {}
+};
+
+struct Ellipse {
+	OBJECT_COMMON;
+	Point p1;
+	Point p2;
+	double radius1;
+	double radius2;
+
+	Ellipse(Vector pt1, Vector pt2, double r1, double r2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+		type(OTEllipse), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(l), selected(false), hovered(false), p1(pt1), p2(pt2), radius1(r1), radius2(r2) {}
 };
 
 struct Arc {
@@ -46,15 +64,31 @@ struct Arc {
 	double angle1;
 	double angle2;
 
-	Arc(Vector pt1, double r, double a1, double a2, float th = 1.0, uint32_t c = 0, int l = 0):
-		type(OTArc), id(Global::objectID++), layer(l), color(c), thickness(th),
-		style(0), selected(false), p1(pt1), radius(r), angle1(a1), angle2(a2) {}
+	Arc(Vector pt1, double r, double a1, double a2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+		type(OTArc), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(l), selected(false), hovered(false), p1(pt1), radius(r), angle1(a1), angle2(a2) {}
+};
+
+struct Dimension {
+	OBJECT_COMMON;
+	int subtype;
+	Point p1;
+	Point p2;
+	double offset;
+
+	Dimension(Vector pt1, Vector pt2, DimensionType dt = DTLinear, float th = 1.0, uint32_t c = 0x0000FF, int l = LSSolid):
+		type(OTDimension), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(l), selected(false), hovered(false), subtype(dt), p1(pt1), p2(pt2) {}
 };
 
 struct Text {
 	OBJECT_COMMON;
 	Point p1;
 	std::string s;
+
+	Text(Vector pt, char * str, float th = 10.0, uint32_t c = 0):
+		type(OTText), id(Global::objectID++), layer(0), color(c), thickness(th),
+		style(LSSolid), selected(false), hovered(false), p1(pt), s(str) {}
 };
 
 struct Container {
@@ -63,14 +97,8 @@ struct Container {
 	std::vector<void *> objects;
 	double angle;
 	double scale;
-};
 
-struct Dimension {
-	OBJECT_COMMON;
-	int subtype;
-	Point p1;
-	Point p2;
-	double offset;
+	Container(): type(OTContainer), id(Global::objectID++), selected(false), hovered(false) {}
 };
 
 struct Object {