X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdrawingview.cpp;h=8c581bfc1df8e904ccb41bd2b724b26b3c3ae7d5;hb=4a979ddae8aa6b3556f24e8b961f7787c4b40cbe;hp=15579c9ab7dd5a8ef6790e408652fdc22b58dd00;hpb=e4b06adab54fbd906d75d1d5951f5fc5d3f62183;p=architektonas

diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index 15579c9..8c581bf 100644
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -323,6 +323,9 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 		painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
 		painter.DrawRect(Global::selection);
 	}
+
+	if (!informativeText.isEmpty())
+		painter.DrawInformativeText(informativeText);
 }
 
 
@@ -373,6 +376,16 @@ void DrawingView::RenderObjects(Painter * painter, std::vector<void *> & v)
 			break;
 		case OTArc:
 			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:
 		{
@@ -566,8 +579,14 @@ void DrawingView::ToolHandler(int mode, Point p)
 {
 	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);
 }
 
 
@@ -592,8 +611,72 @@ void DrawingView::ToolDraw(Painter * painter)
 			double absAngle = v.Angle() * RADIANS_TO_DEGREES;
 			double absLength = v.Magnitude();
 			QString text = tr("Length: %1 in.\n") + QChar(0x2221) + tr(": %2");
-			text = text.arg(absLength).arg(absAngle);
-			painter->DrawInformativeText(text);
+			informativeText = text.arg(absLength).arg(absAngle);
+		}
+	}
+	else if (Global::tool == TTCircle)
+	{
+		if (Global::toolState == TSNone)
+		{
+			painter->DrawHandle(toolPoint[0]);
+		}
+		else if ((Global::toolState == TSPoint2) && shiftDown)
+		{
+			painter->DrawHandle(toolPoint[1]);
+		}
+		else
+		{
+			double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+//			painter->DrawLine(toolPoint[0], toolPoint[1]);
+//			painter->DrawHandle(toolPoint[1]);
+			painter->SetBrush(QBrush(Qt::NoBrush));
+			painter->DrawEllipse(toolPoint[0], length, length);
+			QString text = tr("Radius: %1 in.");//\n") + QChar(0x2221) + tr(": %2");
+			informativeText = text.arg(length);//.arg(absAngle);
+		}
+	}
+	else if (Global::tool == TTArc)
+	{
+		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;
+
+			if (span < 0)
+				span += PI_TIMES_2;
+
+			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)
@@ -606,7 +689,7 @@ void DrawingView::ToolDraw(Painter * painter)
 		{
 			if (toolPoint[0] == toolPoint[1])
 				return;
-			
+
 			painter->DrawLine(toolPoint[0], toolPoint[1]);
 			// Likely we need a tool container for this... (now we do!)
 #if 0
@@ -621,14 +704,49 @@ void DrawingView::ToolDraw(Painter * painter)
 #endif
 
 			double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
-
 			QString text = QChar(0x2221) + QObject::tr(": %1");
-			text = text.arg(absAngle);
+			informativeText = text.arg(absAngle);
 
 			if (ctrlDown)
-				text += " (Copy)";
+				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(toolPoint[0], toolPoint[1]);
+			painter->DrawLine(mirrorPoint, toolPoint[1]);
+			// Likely we need a tool container for this... (now we do!)
+#if 0
+			if (ctrlDown)
+			{
+				painter->SetPen(0x00FF00, 2.0, LSSolid);
+				overrideColor = true;
+			}
+
+			RenderObjects(painter, toolObjects);
+			overrideColor = false;
+#endif
+
+			double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
+
+			if (absAngle > 180.0)
+				absAngle -= 180.0;
+
+			QString text = QChar(0x2221) + QObject::tr(": %1");
+			informativeText = text.arg(absAngle);
 
-			painter->DrawInformativeText(text);
+			if (ctrlDown)
+				informativeText += " (Copy)";
 		}
 	}
 }
@@ -675,6 +793,118 @@ void DrawingView::LineHandler(int mode, Point p)
 }
 
 
+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);
+			document.objects.push_back(c);
+			toolPoint[0] = toolPoint[1];
+			Global::toolState = TSNone;
+		}
+	}
+}
+
+
+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;
+		else
+			toolPoint[3] = p;
+
+		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 circle at new center, not
+				// continue the current one.
+				toolPoint[0] = toolPoint[1];
+				return;
+			}
+
+			// 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 (span < 0)
+				span += PI_TIMES_2;
+
+			Arc * arc = new Arc(toolPoint[0], toolPoint[1].x, toolPoint[2].x, span);
+			document.objects.push_back(arc);
+			Global::toolState = TSNone;
+		}
+	}
+}
+
+
 void DrawingView::RotateHandler(int mode, Point p)
 {
 	switch (mode)
@@ -717,7 +947,6 @@ void DrawingView::RotateHandler(int mode, Point p)
 
 				if (obj.type == OTArc)
 				{
-//printf("Obj2->angle[0] = %f, obj.angle[0] = %f, angle = %f\n", obj2->angle[0], obj.angle[0], angle);
 					obj2->angle[0] = obj.angle[0] + angle;
 
 					if (obj2->angle[0] > PI_TIMES_2)
@@ -778,6 +1007,109 @@ void DrawingView::RotateHandler(int mode, Point p)
 }
 
 
+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;
+
+			double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+			std::vector<void *>::iterator j = select.begin();
+			std::vector<Object>::iterator i = toolScratch.begin();
+
+			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] > PI_TIMES_2)
+						obj2->angle[0] -= PI_TIMES_2;
+				}
+			}
+		}
+
+		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;
+			}
+
+			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)
+			MirrorHandler(ToolMouseMove, toolPoint[1]);
+
+		break;
+	case ToolCleanup:
+		RestorePointsTo(select, toolScratch);
+	}
+}
+
+
 void DrawingView::mousePressEvent(QMouseEvent * event)
 {
 	if (event->button() == Qt::LeftButton)
@@ -814,6 +1146,7 @@ void DrawingView::mousePressEvent(QMouseEvent * event)
 			GetHovered(hover);	// prolly needed
 
 			// Needed for grab & moving objects
+			// We do it *after*... why? (doesn't seem to confer any advantage...)
 			if (Global::snapToGrid)
 				oldPoint = SnapPointToGrid(point);
 
@@ -871,6 +1204,9 @@ void DrawingView::mouseMoveEvent(QMouseEvent * event)
 	// Handle object movement (left button down & over an object)
 	if ((event->buttons() & Qt::LeftButton) && numHovered && !Global::tool)
 	{
+		if (Global::snapToGrid)
+			point = SnapPointToGrid(point);
+
 		HandleObjectMovement(point);
 		update();
 		oldPoint = point;
@@ -880,6 +1216,21 @@ void DrawingView::mouseMoveEvent(QMouseEvent * event)
 	// Do object hit testing...
 	bool needUpdate = HitTestObjects(point);
 
+	// Check for multi-hover...
+	if (numHovered > 1)
+	{
+		GetHovered(hover);
+
+		double t, u;
+		int numIntersecting = Geometry::Intersects((Object *)hover[0], (Object *)hover[1], &t, &u);
+
+		if (numIntersecting > 0)
+		{
+			QString text = tr("Intersection t=%1, u=%2");
+			informativeText = text.arg(t).arg(u);
+		}
+	}
+
 	// Do tool handling, if any are active...
 	if (Global::tool)
 	{
@@ -919,7 +1270,8 @@ void DrawingView::mouseReleaseEvent(QMouseEvent * event)
 		if (Global::selectionInProgress)
 			Global::selectionInProgress = false;
 
-// Should be we do this automagically? Hmm...
+		informativeText.clear();
+// Should we be doing this automagically? Hmm...
 		// Clear our vectors
 		select.clear();
 		hover.clear();
@@ -933,9 +1285,8 @@ void DrawingView::mouseReleaseEvent(QMouseEvent * event)
 				select.push_back(*i);
 
 //hmm, this is no good, too late to do any good :-P
-//				if ((*i)->hovered)
-//					hover.push_back(*i);
-//			}
+//			if ((*i)->hovered)
+//				hover.push_back(*i);
 		}
 	}
 	else if (event->button() == Qt::MiddleButton)
@@ -967,13 +1318,11 @@ 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
 }
 
 
@@ -1016,6 +1365,7 @@ void DrawingView::keyReleaseEvent(QKeyEvent * event)
 	}
 }
 
+
 //
 // 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
@@ -1204,6 +1554,43 @@ bool DrawingView::HitTestObjects(Point point)
 
 			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 += PI_TIMES_2;
+
+			// 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;
+			else if ((length3 * Global::zoom) < 8.0)
+				obj->hitPoint[2] = 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;
+		}
 		default:
 			break;
 		}
@@ -1221,10 +1608,8 @@ bool DrawingView::HitTestObjects(Point point)
 
 void DrawingView::HandleObjectMovement(Point point)
 {
-	if (Global::snapToGrid)
-		point = SnapPointToGrid(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];
 //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"));
@@ -1232,9 +1617,6 @@ void DrawingView::HandleObjectMovement(Point point)
 	switch (obj->type)
 	{
 	case OTLine:
-	{
-//		Line * l = (Line *)obj;
-
 		if (obj->hitPoint[0])
 			obj->p[0] = point;
 		else if (obj->hitPoint[1])
@@ -1246,7 +1628,88 @@ void DrawingView::HandleObjectMovement(Point point)
 		}
 
 		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 += PI_TIMES_2;
+
+				obj->angle[1] -= delta;
+				obj->angle[0] = angle;
+
+				if (obj->angle[1] < 0)
+					obj->angle[1] += PI_TIMES_2;
+
+				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] += PI_TIMES_2;
+
+				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] += PI_TIMES_2;
+
+			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;
 	default:
 		break;
 	}