X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdrawingview.cpp;h=99c4da9f2779054f5edbb6e607ee4e4f8f44371e;hb=8d80165e3ab9173b8689b3b3420b40bf3020161f;hp=5fe3841cab9a35c8cfdb5687ebdd8cd279962aa8;hpb=db0a3d91f37031e155cc8eac7cfdec9889f233ee;p=architektonas

diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index 5fe3841..99c4da9 100644
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -30,15 +30,11 @@
 #include "drawingview.h"
 
 #include <stdint.h>
-#include "mathconstants.h"
-
-//#include "arc.h"
-//#include "circle.h"
-//#include "dimension.h"
-//#include "geometry.h"
-//#include "line.h"
+#include "geometry.h"
 #include "global.h"
+#include "mathconstants.h"
 #include "painter.h"
+#include "structs.h"
 
 
 #define BACKGROUND_MAX_SIZE	512
@@ -49,7 +45,7 @@
 
 DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 	// The value in the settings file will override this.
-	useAntialiasing(true),
+	useAntialiasing(true), numSelected(0),
 	gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
 	scale(1.0), offsetX(-10), offsetY(-10),// document(Vector(0, 0)),
 	gridPixels(0), collided(false)//, toolAction(NULL)
@@ -78,6 +74,23 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
 	// Alternate way to do the above...
 	line->SetDimensionOnLine();
 #endif
+#else
+	Line * line = new Line;//(Vector(5, 5), Vector(50, 40), &document);
+	line->p1 = Vector(5, 5);
+	line->p2 = Vector(50, 40);
+	line->type = OTLine;
+	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)));
+	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 Dimension(Vector(50, 40), Vector(5, 5)));
+	document.objects.push_back(new Text(Vector(10, 83), "Here is some awesome text!"));
 #endif
 
 /*
@@ -89,10 +102,10 @@ arbitrary 12 pixels) to anything we want (within reason, of course :-).
 
 The drawing enforces the grid spacing through the drawing->gridSpacing variable.
 
-	drawing->gridSpacing = 12.0 / Painter::zoom;
+	drawing->gridSpacing = 12.0 / Global::zoom;
 
-Painter::zoom is the zoom factor for the drawing, and all mouse clicks are
-translated to Cartesian coordinates through this. (Initially, Painter::zoom is
+Global::zoom is the zoom factor for the drawing, and all mouse clicks are
+translated to Cartesian coordinates through this. (Initially, Global::zoom is
 set to 1.0. SCREEN_ZOOM is set to 1.0/4.0.)
 
 Really, the 100% zoom level can be set at *any* zoom level, it's more of a
@@ -112,13 +125,13 @@ inch regardless of the zoom level a piece of text can be larger or smaller than
 this. Maybe this is the case for having a base unit and basing point sizes off
 of that.
 
-Here's what's been figured out. Painter::zoom is simply the ratio of pixels to
+Here's what's been figured out. Global::zoom is simply the ratio of pixels to
 base units. What that means is that if you have a 12px grid with a 6" grid size
-(& base unit of "inches"), Painter::zoom becomes 12px / 6" = 2.0 px/in.
+(& base unit of "inches"), Global::zoom becomes 12px / 6" = 2.0 px/in.
 
 Dimensions now have a "size" parameter to set their absolute size in relation
 to the base unit. ATM, the arrows are drawn in pixels, but also scaled by
-Painter::zoom *and* size. Same with the dimension text; it's drawn at 10pt and
+Global::zoom *and* size. Same with the dimension text; it's drawn at 10pt and
 scaled the same way as the arrowheads.
 
 Need a way to scale line widths as well. :-/ Shouldn't be too difficult, just
@@ -166,7 +179,7 @@ void DrawingView::SetGridSize(uint32_t size)
 
 	// Set up new BG brush & zoom level (pixels per base unit)
 //	Painter::zoom = gridPixels / gridSpacing;
-	Painter::zoom = gridPixels / Global::gridSpacing;
+	Global::zoom = gridPixels / Global::gridSpacing;
 	UpdateGridBackground();
 }
 
@@ -310,6 +323,8 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 
 	// The top level document takes care of rendering for us...
 //	document.Draw(&painter);
+	// Not any more it doesn't...
+	RenderObjects(&painter, &document);
 
 #if 0
 	if (toolAction)
@@ -331,9 +346,203 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 }
 
 
+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);
+		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;
+			painter->DrawLine(l->p1, l->p2);
+			break;
+		}
+		case OTCircle:
+		{
+			Circle * ci = (Circle *)obj;
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(ci->p1, ci->radius, ci->radius);
+			break;
+		}
+		case OTArc:
+		{
+			Arc * a = (Arc *)obj;
+			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;
+			painter->DrawTextObject(t->p1, t->s.c_str(), scaledThickness);
+			break;
+		}
+		default:
+			break;
+		}
+	}
+}
+
+
+void DrawingView::DeleteSelectedItems(void)
+{
+	std::vector<void *>::iterator i = document.objects.begin();
+
+	while (i != document.objects.end())
+	{
+		Object * obj = (Object *)(*i);
+
+		if (obj->selected)
+		{
+			delete obj;
+			document.objects.erase(i);
+		}
+		else
+			i++;
+	}
+}
+
+
 void DrawingView::resizeEvent(QResizeEvent * /*event*/)
 {
-	Painter::screenSize = Vector(size().width(), size().height());
+	Global::screenSize = Vector(size().width(), size().height());
 	UpdateGridBackground();
 }
 
@@ -399,9 +608,9 @@ void DrawingView::mouseMoveEvent(QMouseEvent * event)
 		// 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 /= Painter::zoom;
+		delta /= Global::zoom;
 		delta.y = -delta.y;
-		Painter::origin -= delta;
+		Global::origin -= delta;
 
 		UpdateGridBackground();
 		update();
@@ -427,6 +636,113 @@ 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;
+		numSelected = 0;
+
+		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;
+			}
+
+			if (obj->selected)
+				numSelected++;
+		}
+	}
+
 //	oldPoint = point;
 //we should keep track of the last point here and only pass this down *if* the point
 //changed...
@@ -505,14 +821,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
 }
 
 
@@ -560,21 +948,21 @@ void DrawingView::wheelEvent(QWheelEvent * event)
 	// This is not centering for some reason. Need to figure out why. :-/
 	if (event->delta() > 0)
 	{
-		Vector newOrigin = center - ((center - Painter::origin) / zoomFactor);
-		Painter::origin = newOrigin;
-		Painter::zoom *= zoomFactor;
+		Vector newOrigin = center - ((center - Global::origin) / zoomFactor);
+		Global::origin = newOrigin;
+		Global::zoom *= zoomFactor;
 	}
 	else
 	{
-		Vector newOrigin = center + ((-center + Painter::origin) * zoomFactor);
-		Painter::origin = newOrigin;
-		Painter::zoom /= zoomFactor;
+		Vector newOrigin = center + ((-center + Global::origin) * zoomFactor);
+		Global::origin = newOrigin;
+		Global::zoom /= zoomFactor;
 	}
 
 #if 1
 //	Global::gridSpacing = gridPixels / Painter::zoom;
 //	UpdateGridBackground();
-	SetGridSize(Global::gridSpacing * Painter::zoom);
+	SetGridSize(Global::gridSpacing * Global::zoom);
 	update();
 //	zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
 #endif