Further refinements to the Circle class.

[architektonas] / src / line.cpp

diff --git a/src/line.cpp b/src/line.cpp
index 60e5ab0c1095ff67856aa5b333bf72a0d46afbcf..2e3539f7b0cfa510045ce1569c1139578b304d1e 100644 (file)
--- a/src/line.cpp
+++ b/src/line.cpp
@@ -20,10 +20,13 @@
 
 #include <QtGui>
 #include "dimension.h"
+#include "painter.h"
+
 
 Line::Line(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p), endpoint(p2),
        draggingLine(false), draggingHandle1(false), draggingHandle2(false), //needUpdate(false),
-       length(Vector::Magnitude(p2, p1)), hitPoint1(false), hitPoint2(false), hitLine(false)
+       length(Vector::Magnitude(p2, p1)), angle(Vector(endpoint - position).Unit()),
+       hitPoint1(false), hitPoint2(false), hitLine(false)
 {
 }
 
@@ -41,18 +44,18 @@ Line::~Line()
        // detached.
 }
 
-/*virtual*/ void Line::Draw(QPainter * painter)
+/*virtual*/ void Line::Draw(Painter * painter)
 {
-       painter->setPen(QPen(Qt::red, 2.0, Qt::DotLine));
+       painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
 
        if ((state == OSSelected) || ((state == OSInactive) && hitPoint1))
-               painter->drawEllipse(QPointF(position.x, position.y), 4.0, 4.0);
+               painter->DrawHandle(position);
 
        if ((state == OSSelected) || ((state == OSInactive) && hitPoint2))
-               painter->drawEllipse(QPointF(endpoint.x, endpoint.y), 4.0, 4.0);
+               painter->DrawHandle(endpoint);
 
        if ((state == OSInactive) && !hitLine)
-               painter->setPen(QPen(Qt::black, 1.0, Qt::SolidLine));
+               painter->SetPen(QPen(Qt::black, 1.0, Qt::SolidLine));
 
        if (Object::fixedLength && (draggingHandle1 || draggingHandle2))
        {
@@ -62,16 +65,16 @@ Line::~Line()
                Vector current(point2 - point1);
                Vector v = current.Unit() * length;
                Vector v2 = point1 + v;
-               painter->drawLine((int)point1.x, (int)point1.y, (int)v2.x, (int)v2.y);
+               painter->DrawLine((int)point1.x, (int)point1.y, (int)v2.x, (int)v2.y);
 
                if (current.Magnitude() > length)
                {
-                       painter->setPen(QPen(QColor(128, 0, 0), 1.0, Qt::DashLine));
-                       painter->drawLine((int)v2.x, (int)v2.y, (int)point2.x, (int)point2.y);
+                       painter->SetPen(QPen(QColor(128, 0, 0), 1.0, Qt::DashLine));
+                       painter->DrawLine((int)v2.x, (int)v2.y, (int)point2.x, (int)point2.y);
                }
        }
        else
-               painter->drawLine((int)position.x, (int)position.y, (int)endpoint.x, (int)endpoint.y);
+               painter->DrawLine((int)position.x, (int)position.y, (int)endpoint.x, (int)endpoint.y);
 }
 
 /*virtual*/ Vector Line::Center(void)
@@ -83,8 +86,7 @@ Line::~Line()
 
 /*virtual*/ bool Line::Collided(Vector point)
 {
-// Can't assume this!
-// Actually, we can, since this is a mouse down event here.
+       // We can assume this, since this is a mouse down event here.
        objectWasDragged = false;
        HitTest(point);
 
@@ -97,7 +99,7 @@ We solve this by allowing only *one* Dimension object to be attached to the Line
 Arc, etc. and by giving the Dimension object a pointer to our endpoints.
 
 Problem still arises when we delete this object; The attached Dimension object will
-then have bad pointers! What is *should* do is delete the object if and only if this
+then have bad pointers! What it *should* do is delete the object if and only if this
 line is not attached to any other object. If it is, then one of those attachment
 points should be sent to the dimension object (done for position & endpoint).
 
@@ -257,6 +259,7 @@ software currently out there: the GUI will try to do the right thing, most of th
                Vector point1 = (draggingHandle1 ? endpoint : position);
                Vector point2 = (draggingHandle1 ? position : endpoint);
 
+#if 0
                Vector current(point2, point1);
                Vector v = current.Unit() * length;
                Vector v2 = point1 + v;
@@ -264,6 +267,26 @@ software currently out there: the GUI will try to do the right thing, most of th
                //bleh
                if (!Object::fixedLength)
                        v2 = point2;
+#endif
+
+               if (Object::fixedAngle)
+               {
+                       // Here we calculate the component of the current vector along the fixed angle.
+                       // A_compB = (A . Bu) * Bu
+                       double magnitudeAlongB = Vector::Dot(Vector(point2 - point1), angle);
+/*
+Actually, this isn't quite right. What we want to do is look for the intersection along either
+the horizontal line or vertical line that intersects from the current mouse position.
+*/
+
+                       if (draggingHandle1)
+                               position = endpoint + (angle * magnitudeAlongB);
+
+                       if (draggingHandle2)
+                               endpoint = position + (angle * magnitudeAlongB);
+               }
+//             else
+//                     v2 = point2;
 
 //If we tell the dimension to flip sides, this is no longer a valid
 //assumption. !!! FIX !!!
@@ -307,6 +330,13 @@ software currently out there: the GUI will try to do the right thing, most of th
                        // it turns out to have a fixed length. :-)
                        length = Vector(endpoint - position).Magnitude();
                }
+
+               if (!Object::fixedAngle)
+               {
+                       // Calculate the new angle, just in case on the next move it turns out to
+                       // be fixed. :-)
+                       angle = Vector(endpoint - position).Unit();
+               }
        }
 
        draggingLine = false;