// "Fixed Length" button is down
// JLH 04/27/2011 Fixed attached dimension to stay a correct length when
// "Fixed Length" button is *not* down ;-)
+// JLH 05/29/2011 Added mouseover hints
//
#include "line.h"
Line::Line(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p), endpoint(p2),
dragging(false), draggingHandle1(false), draggingHandle2(false), //needUpdate(false),
- length(Vector::Magnitude(p2, p1))
+ length(Vector::Magnitude(p2, p1)), hitPoint1(false), hitPoint2(false), hitLine(false)
{
}
/*virtual*/ void Line::Draw(QPainter * painter)
{
- if (state == OSSelected)
- painter->setPen(QPen(Qt::red, 2.0, Qt::DotLine));
- else
- painter->setPen(QPen(Qt::black, 1.0, Qt::SolidLine));
+ painter->setPen(QPen(Qt::red, 2.0, Qt::DotLine));
-// if (draggingHandle1)
- if (state == OSSelected)
+ if ((state == OSSelected) || ((state == OSInactive) && hitPoint1))
painter->drawEllipse(QPointF(position.x, position.y), 4.0, 4.0);
-// if (draggingHandle2)
- if (state == OSSelected)
+ if ((state == OSSelected) || ((state == OSInactive) && hitPoint2))
painter->drawEllipse(QPointF(endpoint.x, endpoint.y), 4.0, 4.0);
+ if ((state == OSInactive) && !hitLine)
+ painter->setPen(QPen(Qt::black, 1.0, Qt::SolidLine));
+
if (Object::fixedLength && (draggingHandle1 || draggingHandle2))
{
Vector point1 = (draggingHandle1 ? endpoint : position);
/*virtual*/ bool Line::Collided(Vector point)
{
+// Can't assume this!
+// Actually, we can, since this is a mouse down event here.
objectWasDragged = false;
- Vector lineSegment = endpoint - position;
- Vector v1 = point - position;
- Vector v2 = point - endpoint;
- double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;
+ HitTest(point);
- // Geometric interpretation:
- // The paremeterized point on the vector ls is where the perpendicular intersects ls.
- // If pp < 0, then the perpendicular lies beyond the 1st endpoint. If pp > length of ls,
- // then the perpendicular lies beyond the 2nd endpoint.
+/*
+There's a small problem here with the implementation: You can have a dimension tied
+to only one point while at the same time you can have a dimension sitting on this line.
+Since there's only *one* dimPoint for each point, this can be problematic...
- if (parameterizedPoint < 0.0)
- distance = v1.Magnitude();
- else if (parameterizedPoint > lineSegment.Magnitude())
- distance = v2.Magnitude();
- else // distance = ?Det?(ls, v1) / |ls|
- distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y) / lineSegment.Magnitude());
+Also: It would be nice to have a preview of the dimension being drawn, with a modifier
+key to make it draw/show on the other side...
+*/
+ // Is the dimension tool active? Let's use it:
+ if (dimensionActive)
+ {
+ // User clicked on the line itself (endpoint checks should preceed this one):
+ // (Priorities are taken care of in HitTest()...)
+ if (hitLine)
+ {
+ // If there's one already there, tell it to flip sides...
+ if (dimPoint1 && (dimPoint1 == dimPoint2))
+ {
+// Here's an interesting problem... When swapping points we can either do it
+// on the dimension or directly here... I think swapping endpoint & position is
+// probably the wrong way to do things here...
+#if 1
+ // Hm, why do we have to do both here???
+ dimPoint1->FlipSides();
+ //dis don't do shit
+/* Vector temp = dimPoint1;
+ dimPoint1 = dimPoint2;
+ dimPoint2 = temp;//*/
+#else
+// It doesn't work correctly anyhow, not until you move an endpoint.
+ Vector temp = position;
+ position = endpoint;
+ endpoint = temp;
+#endif
+ }
+ else if ((dimPoint1 == NULL) && (dimPoint2 == NULL))
+ {
+ // How to get this object into the top level container???
+/*
+The real question is do we care. I think so, because if this isn't in the top
+level container, it won't get drawn...
+But we can fix that by making this object call any attached object's (like
+a dimension only) Draw() function... :-/
+*/
+ dimPoint1 = new Dimension(position, endpoint, this);
+ dimPoint2 = dimPoint1;
+
+ if (parent != NULL)
+ parent->Add(dimPoint1);
+ }
+
+ return true;
+ }
+ }
- // If the segment endpoints are s and e, and the point is p, then the test for the perpendicular
- // intercepting the segment is equivalent to insisting that the two dot products {s-e}.{s-p} and
- // {e-s}.{e-p} are both non-negative. Perpendicular distance from the point to the segment is
- // computed by first computing the area of the triangle the three points form, then dividing by the
- // length of the segment. Distances are done just by the Pythagorean theorem. Twice the area of the
- // triangle formed by three points is the determinant of the following matrix:
- //
- // sx sy 1
- // ex ey 1
- // px py 1
- //
- // By translating the start point to the origin, this can be rewritten as:
- // By subtracting row 1 from all rows, you get the following:
- // [because sx = sy = 0. you could leave out the -sx/y terms below. because we subtracted
- // row 1 from all rows (including row 1) row 1 turns out to be zero. duh!]
- //
- // 0 0 0 0 0 0
- // (ex - sx) (ey - sy) 0 ==> ex ey 0
- // (px - sx) (py - sy) 0 px py 0
- //
- // which greatly simplifies the calculation of the determinant.
if (state == OSInactive)
{
//How to translate this into pixels from Document space???
//Maybe we need to pass a scaling factor in here from the caller? That would make sense, as
//the caller knows about the zoom factor and all that good kinda crap
- if (v1.Magnitude() < 10.0)
+ if (hitPoint1)
{
oldState = state;
state = OSSelected;
draggingHandle1 = true;
return true;
}
- else if (v2.Magnitude() < 10.0)
+ else if (hitPoint2)
{
oldState = state;
state = OSSelected;
draggingHandle2 = true;
return true;
}
- else if (distance < 2.0)
+ else if (hitLine)
{
oldState = state;
state = OSSelected;
}
else if (state == OSSelected)
{
- // Here we test for collision with handles as well! (SOON!)
+ // Here we test for collision with handles as well! (SOON!) [I think it works...NOPE]
/*
Like so:
if (v1.Magnitude() < 2.0) // Handle #1
else if (v2.Magnitude() < 2.0) // Handle #2
*/
- if (distance < 2.0)
+ if (hitLine)
{
oldState = state;
// state = OSInactive;
/*virtual*/ void Line::PointerMoved(Vector point)
{
- // We know this is true because mouse move messages don't come here unless
- // the object was actually clicked on--therefore we *know* we're being
- // dragged...
- objectWasDragged = true;
+ needUpdate = HitTest(point);
- if (dragging)
- {
- // Here we need to check whether or not we're dragging a handle or the object itself...
- Vector delta = point - oldPoint;
+ objectWasDragged = (dragging | draggingHandle1 | draggingHandle2);
- position += delta;
- endpoint += delta;
-
- oldPoint = point;
- needUpdate = true;
- }
- else if (draggingHandle1)
+ if (objectWasDragged)
{
Vector delta = point - oldPoint;
- position += delta;
-
- oldPoint = point;
- needUpdate = true;
- }
- else if (draggingHandle2)
- {
- Vector delta = point - oldPoint;
+ if (draggingHandle1 || dragging)
+ position += delta;
- endpoint += delta;
+ if (draggingHandle2 || dragging)
+ endpoint += delta;
oldPoint = point;
needUpdate = true;
}
- else
- needUpdate = false;
+/*
+We can't count on any coupling between the dimension object, so how do we do this???
+*/
if (needUpdate)
{
// should only do this if "Fixed Length" is set... !!! FIX !!! [DONE]
if (!Object::fixedLength)
v2 = point2;
+//If we tell the dimension to flip sides, this is no longer a valid
+//assumption. !!! FIX !!!
+//Ideally, we should just send the point that's changing to the Dimension object
+//and have it figure out which point needs to move... Or is it???
if (dimPoint1)
dimPoint1->SetPoint1(draggingHandle1 ? v2 : position);
draggingHandle1 = false;
draggingHandle2 = false;
+// hitPoint1 = hitPoint2 = hitLine = false;
+
// Here we check for just a click: If object was clicked and dragged, then
// revert to the old state (OSInactive). Otherwise, keep the new state that
// we set.
dimension->SetPoint2(endpoint);
}
+bool Line::HitTest(Point point)
+{
+ SaveState();
+
+ hitPoint1 = hitPoint2 = hitLine = false;
+ Vector lineSegment = endpoint - position;
+ Vector v1 = point - position;
+ Vector v2 = point - endpoint;
+ double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;
+
+ // Geometric interpretation:
+ // The parameterized point on the vector lineSegment is where the perpendicular
+ // intersects lineSegment. If pp < 0, then the perpendicular lies beyond the 1st
+ // endpoint. If pp > length of ls, then the perpendicular lies beyond the 2nd endpoint.
+
+ if (parameterizedPoint < 0.0)
+ distance = v1.Magnitude();
+ else if (parameterizedPoint > lineSegment.Magnitude())
+ distance = v2.Magnitude();
+ else
+ // distance = ?Det?(ls, v1) / |ls|
+ distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y) / lineSegment.Magnitude());
+
+ // Geometric interpretation of the above:
+ // If the segment endpoints are s and e, and the point is p, then the test
+ // for the perpendicular intercepting the segment is equivalent to insisting
+ // that the two dot products {s-e}.{s-p} and {e-s}.{e-p} are both non-negative.
+ // Perpendicular distance from the point to the segment is computed by first
+ // computing the area of the triangle the three points form, then dividing by
+ // the length of the segment. Distances are done just by the Pythagorean
+ // theorem. Twice the area of the triangle formed by three points is the
+ // determinant of the following matrix:
+ //
+ // sx sy 1 0 0 1 0 0 0
+ // ex ey 1 ==> ex ey 1 ==> ex ey 0
+ // px py 1 px py 1 px py 0
+ //
+ // By translating the start point to the origin, and subtracting row 1 from
+ // all other rows, we end up with the matrix on the right which greatly
+ // simplifies the calculation of the determinant.
+
+//How do we determine distance here? Especially if zoomed in or out???
+#warning "!!! Distances tested for may not be valid if zoomed in or out !!!"
+ if (v1.Magnitude() < 8.0)
+ hitPoint1 = true;
+ else if (v2.Magnitude() < 8.0)
+ hitPoint2 = true;
+ else if (distance < 5.0)
+ hitLine = true;
+
+ return StateChanged();
+}
+
+void Line::SaveState(void)
+{
+ oldHitPoint1 = hitPoint1;
+ oldHitPoint2 = hitPoint2;
+ oldHitLine = hitLine;
+}
+
+bool Line::StateChanged(void)
+{
+ if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine))
+ return true;
+
+ return false;
+}
+
/*
Intersection of two lines:
projects / architektonas / blobdiff