// "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"
#include "dimension.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))
+ draggingLine(false), draggingHandle1(false), draggingHandle2(false), //needUpdate(false),
+ 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...
+
+TODO: Make Dimension preview with modifier keys for showing on 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 (attachedDimension == 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... :-/
+*/
+ attachedDimension = new Dimension(&position, &endpoint, this);
+
+ if (parent != NULL)
+ parent->Add(attachedDimension);
+ }
+ else
+ {
+ // If there's one already there, tell it to flip sides...
+ attachedDimension->FlipSides();
+ }
+
+ 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)
+//I think what's needed is an Object class variable/method that can be changed by the TLC and
+//called in derived classes to properly scale the location to the current zoom level. That *should* work.
+
+// ALSO: Need to code a global (read: Object class) variable that tells use whether a modifier
+// key was pressed in addition to the mouse click, so we can do stuff like, say, hold
+// down CTRL and be able to do multiple selecting of objects (in that case, we would
+// keep the Object state from changing).
+ 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;
oldPoint = point;
- dragging = true;
+ draggingLine = true;
return true;
}
}
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;
oldPoint = point;
- dragging = true;
+ draggingLine = true;
return true;
}
}
+ // If we got here, we clicked on nothing, so set the object to inactive.
+ // (Once we can read key modifiers, we can override this to allow multiple selection.)
state = OSInactive;
return false;
}
/*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;
+ // Hit test tells us what we hit (if anything) through boolean variables. It
+ // also tells us whether or not the state changed.
+ 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;
-
- position += delta;
- endpoint += delta;
+ objectWasDragged = (draggingLine | draggingHandle1 | draggingHandle2);
- oldPoint = point;
- needUpdate = true;
- }
- else if (draggingHandle1)
+ if (objectWasDragged)
{
Vector delta = point - oldPoint;
- position += delta;
+ if (draggingHandle1 || draggingLine)
+ position += delta;
- oldPoint = point;
- needUpdate = true;
- }
- else if (draggingHandle2)
- {
- Vector delta = point - oldPoint;
-
- endpoint += delta;
+ if (draggingHandle2 || draggingLine)
+ endpoint += delta;
oldPoint = point;
needUpdate = true;
}
- else
- needUpdate = false;
+/*
+We can't count on any coupling between the dimension object and us, so how do we do this???
+Also, there may be more than one Dimension object connected to a single endpoint!
+
+Ugly ways to do it:
+ - Keep track of the state of the connected dimension
+ - Pass the Dimension the point that's being changed and the delta
+
+More elegant ways:
+ - Pass the point in a notification function (how?)
+ - Pass the point as a reference to the class instance object (&endpoint). This way, the line
+ doesn't have to care about keeping track of Dimensions connected to it. But still have to
+ care about other connected entities (other Lines, Circles, Arcs, Splines, Texts, etc). I
+ think I'd be OK with this.
+ Since the Dimension has a pointer to our object, all we have to do is update our coordinates
+ and the Dimension object will adjust itself on the next repaint. Problem solved, and we don't
+ have to know anything about how many Dimensions are connected to us, or where! \o/
+ The question then becomes, how do we do this kind of coupling???
+
+We need to know about connected entities so that we can have them either move in expected ways
+or constrain the movement of this Line object. This is how we will be a cut above all other CAD
+software currently out there: the GUI will try to do the right thing, most of the time. :-)
+*/
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???
+// Ideally, we shouldn't have to fuck around with this shit. We need to fix the rendering code
+// so that we don't have to wait until the dragging is done to correct the position of the
+// point in question, but we'd need another variable tho.
+#if 0
if (dimPoint1)
dimPoint1->SetPoint1(draggingHandle1 ? v2 : position);
if (dimPoint2)
dimPoint2->SetPoint2(draggingHandle2 ? v2 : endpoint);
+#endif
}
}
}
}
- dragging = false;
+ draggingLine = false;
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.
state = oldState;
}
+#if 0
void Line::SetDimensionOnPoint1(Dimension * dimension)
{
dimPoint1 = dimension;
if (dimension)
dimension->SetPoint2(endpoint);
}
+#else
+void Line::SetDimensionOnLine(Dimension * dimension/*=NULL*/)
+{
+ // If they don't pass one in, create it for the caller.
+ if (dimension == NULL)
+ {
+ dimension = new Dimension(&position, &endpoint, this);
+
+ if (parent)
+ parent->Add(dimension);
+ }
+
+ attachedDimension = dimension;
+
+ // After we set the points here, we don't have to care about them anymore.
+ if (dimension)
+ {
+ dimension->SetPoint1(&position);
+ dimension->SetPoint2(&endpoint);
+ }
+}
+#endif
+
+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