From: Shamus Hammons <jlhamm@acm.org>
Date: Thu, 20 Mar 2014 14:13:47 +0000 (-0500)
Subject: Added more visual feedback to Dimension type changing buttons.
X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=architektonas;a=commitdiff_plain;h=e04e3a62d9f98d0cee6a4cf1e23a3019af8a37a7

Added more visual feedback to Dimension type changing buttons.
---

diff --git a/src/dimension.cpp b/src/dimension.cpp
index 9c9e15c..8729b1c 100644
--- a/src/dimension.cpp
+++ b/src/dimension.cpp
@@ -208,6 +208,8 @@ I believe they are pixels.
 	if (hitLine)
 	{
 		Point hp1 = (p1 + p2) / 2.0;
+		Point hp2 = (p1 + hp1) / 2.0;
+		Point hp3 = (hp1 + p2) / 2.0;
 
 		if (hitFlipSwitch)
 		{
@@ -218,6 +220,28 @@ I believe they are pixels.
 		}
 
 		painter->DrawHandle(hp1);
+		painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+		if (hitChangeSwitch1)
+		{
+			painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+			painter->SetBrush(QBrush(QColor(Qt::magenta)));
+			painter->DrawArrowToLineHandle(hp2, (dimensionType == DTLinearVert ? ortho.Angle() : 0));
+			painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+		}
+
+		painter->DrawHandle(hp2);
+		painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+		if (hitChangeSwitch2)
+		{
+			painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+			painter->SetBrush(QBrush(QColor(Qt::magenta)));
+			painter->DrawArrowToLineHandle(hp3, PI_OVER_2);
+			painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+		}
+
+		painter->DrawHandle(hp3);
 	}
 }
 
@@ -268,6 +292,28 @@ I believe they are pixels.
 //		state = OSInactive;
 //		return true;
 	}
+	else if (hitChangeSwitch1)
+	{
+		// There are three cases here: aligned, horizontal, & vertical. Aligned
+		// and horizontal do the same thing, vertical goes back to linear.
+		if (dimensionType == DTLinearVert)
+			dimensionType = DTLinear;
+		else
+			dimensionType = DTLinearVert;
+
+		hitFlipSwitch = hitLine = false;
+	}
+	else if (hitChangeSwitch2)
+	{
+		// There are three cases here: aligned, horizontal, & vertical. Aligned
+		// and vertical do the same thing, horizontal goes back to linear.
+		if (dimensionType == DTLinearHorz)
+			dimensionType = DTLinear;
+		else
+			dimensionType = DTLinearHorz;
+
+		hitFlipSwitch = hitLine = false;
+	}
 
 	state = OSInactive;
 	return false;
@@ -370,7 +416,8 @@ about keeping track of old states...
 #endif
 	Point p3(p1, point);
 
-	hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = false;
+	hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = hitChangeSwitch1
+		= hitChangeSwitch2 = false;
 	Vector v1(position, point);
 	Vector v2(endpoint, point);
 //	Vector lineSegment(position, endpoint);
@@ -378,7 +425,10 @@ about keeping track of old states...
 //	double t = Geometry::ParameterOfLineAndPoint(position, endpoint, point);
 	double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
 	double distance;
-	Point hFSPoint = Point((p1 + p2) / 2.0, point);
+	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();
@@ -399,8 +449,12 @@ about keeping track of old states...
 
 	if ((hFSPoint.Magnitude() * Painter::zoom) < 8.0)
 		hitFlipSwitch = true;
+	else if ((hCS1Point.Magnitude() * Painter::zoom) < 8.0)
+		hitChangeSwitch1 = true;
+	else if ((hCS2Point.Magnitude() * Painter::zoom) < 8.0)
+		hitChangeSwitch2 = true;
 
-	return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch ? true : false);
+	return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch || hitChangeSwitch1 || hitChangeSwitch2 ? true : false);
 }
 
 
@@ -410,12 +464,17 @@ void Dimension::SaveHitState(void)
 	oldHitPoint2 = hitPoint2;
 	oldHitLine = hitLine;
 	oldHitFlipSwitch = hitFlipSwitch;
+	oldHitChangeSwitch1 = hitChangeSwitch1;
+	oldHitChangeSwitch2 = hitChangeSwitch2;
 }
 
 
 bool Dimension::HitStateChanged(void)
 {
-	if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch))
+	if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2)
+		|| (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch)
+		|| (hitChangeSwitch1 != oldHitChangeSwitch1)
+		|| (hitChangeSwitch2 != oldHitChangeSwitch2))
 		return true;
 
 	return false;
diff --git a/src/dimension.h b/src/dimension.h
index dfbfd1d..fbc2896 100644
--- a/src/dimension.h
+++ b/src/dimension.h
@@ -50,7 +50,9 @@ class Dimension: public Object
 		bool hitPoint2;
 		bool hitLine;
 		bool hitFlipSwitch;
-		bool oldHitPoint1, oldHitPoint2, oldHitLine, oldHitFlipSwitch;
+		bool hitChangeSwitch1;
+		bool hitChangeSwitch2;
+		bool oldHitPoint1, oldHitPoint2, oldHitLine, oldHitFlipSwitch, oldHitChangeSwitch1, oldHitChangeSwitch2;
 	public:
 		double size;						// Size of arrows/text in base units
 };
diff --git a/src/painter.cpp b/src/painter.cpp
index 046dd2a..4213261 100644
--- a/src/painter.cpp
+++ b/src/painter.cpp
@@ -203,6 +203,27 @@ void Painter::DrawArrowHandle(Vector center, double angle)
 }
 
 
+// This function is for drawing object handles without regard for zoom level;
+// we don't want our object handle size to depend on the zoom level!
+void Painter::DrawArrowToLineHandle(Vector center, double angle)
+{
+	DrawArrowHandle(center, angle);
+	center = CartesianToQtCoords(center);
+
+	// Since we're drawing directly on the screen, the Y is inverted. So we use
+	// the mirror of the angle.
+	double orthoAngle = -angle + (PI / 2.0);
+	Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
+	Vector unit = Vector(cos(-angle), sin(-angle));
+
+	Point p1 = center + (unit * 21.0);
+	Point p2 = p1 + (orthogonal * 7.0);
+	Point p3 = p1 - (orthogonal * 7.0);
+
+	painter->drawLine(p2.x, p2.y, p3.x, p3.y);
+}
+
+
 void Painter::DrawLine(int x1, int y1, int x2, int y2)
 {
 	if (!painter)
diff --git a/src/painter.h b/src/painter.h
index 50c79a4..955e553 100644
--- a/src/painter.h
+++ b/src/painter.h
@@ -23,6 +23,7 @@ class Painter
 		void DrawEllipse(Vector, double, double);
 		void DrawHandle(Vector);
 		void DrawArrowHandle(Vector, double);
+		void DrawArrowToLineHandle(Vector, double);
 		void DrawLine(int, int, int, int);
 		void DrawLine(Vector, Vector);
 		void DrawPoint(int, int);