#include <QtGui>
#include "container.h"
#include "dimension.h"
+#include "geometry.h"
#include "mathconstants.h"
#include "painter.h"
// connect to this dimension object at this point, instead of just becoming
// detached.
#endif
+//actually not true, we know the object pointer and parameter!
+//actuall, the Object base class does this for us...!
+#if 0
+ std::vector<Connection>::iterator i;
+
+ for(i=connected.begin(); i!=connected.end(); i++)
+ {
+ (*i).object->Disconnect(this, (*i).t);
+ }
+#endif
}
QString text = QObject::tr("Length: %1 in.\n") + QChar(0x2221) + QObject::tr(": %2");
text = text.arg(absLength).arg(absAngle);
-#if 0
- QPen pen = QPen(QColor(0x00, 0xFF, 0x00), 1.0, Qt::SolidLine);
- painter->SetPen(pen);
- painter->SetBrush(QBrush(QColor(0x40, 0xFF, 0x40, 0x9F)));
- QRectF textRect(10.0, 10.0, 270.0, 70.0); // x, y, w, h (in Qt coords)
- painter->DrawRoundedRect(textRect, 7.0, 7.0);
-
- textRect.setLeft(textRect.left() + 14);
- painter->SetFont(*Object::font);
- pen = QPen(QColor(0x00, 0x5F, 0xDF));
- painter->SetPen(pen);
- painter->DrawText(textRect, Qt::AlignVCenter, text);
-#else
painter->DrawInformativeText(text);
-#endif
}
}
/*virtual*/ bool Line::Collided(Vector point)
{
+/*
+what we can do here is set ignoreClicks to true to keep other objects that are
+selected from deselecting themselves. Will that fuck up something else? Not sure
+yet... :-/
+Actually, this is done here to keep tools from selecting stuff inadvertantly...
+*/
// We can assume this, since this is a mouse down event here.
objectWasDragged = false;
- HitTest(point);
+ bool hit = HitTest(point);
+
+ // Someone told us to fuck off, so we'll fuck off. :-)
+ if (ignoreClicks)
+// return false;
+ return hit;
// Now that we've done our hit testing on the non-snapped point, snap it if
// necessary...
TODO: Make Dimension preview with modifier keys for showing on other side
*/
+/*
+
+N.B.: This no longer works, as the DrawDimension object takes precedence over this code.
+ THIS DOES NOTHING ANYMORE!!!
+
+*/
+#if 0
// Is the dimension tool active? Let's use it:
if (dimensionActive)
{
return true;
}
}
+#endif
if (state == OSInactive)
{
}
-/*virtual*/ void Line::PointerMoved(Vector point)
+/*virtual*/ bool Line::PointerMoved(Vector point)
{
if (selectionInProgress)
{
// Check for whether or not the rect contains this line
-#if 0
- if (selection.normalized().contains(Extents()))
-#else
-// if (selection.normalized().contains(position.x, position.y)
-// && selection.normalized().contains(endpoint.x, endpoint.y))
if (selection.contains(position.x, position.y)
&& selection.contains(endpoint.x, endpoint.y))
-#endif
state = OSSelected;
else
state = OSInactive;
- return;
+ return false;
}
// Hit test tells us what we hit (if anything) through boolean variables. (It
// also tells us whether or not the state changed. --not any more)
SaveHitState();
- HitTest(point);
+ bool hovered = HitTest(point);
needUpdate = HitStateChanged();
objectWasDragged = (draggingLine | draggingHandle1 | draggingHandle2);
needUpdate = true;
//doesn't work QMainWindow::statusBar()->setText("You are manipulating a line");
+
+ // Tell connected objects to move themselves...
+ if (draggingLine)
+ {
+ std::vector<Connection>::iterator i;
+
+ for(i=connected.begin(); i!=connected.end(); i++)
+ {
+ if ((*i).object->type == OTLine)
+ ((Line *)((*i).object))->MovePointAtParameter((*i).t, delta);
+ else if ((*i).object->type == OTDimension)
+ ((Dimension *)((*i).object))->MovePointAtParameter((*i).t, delta);
+ }
+ }
}
/*
dimPoint2->SetPoint2(draggingHandle2 ? v2 : endpoint);
#endif
}
+
+ return hovered;
}
/*virtual*/ bool Line::HitTest(Point point)
{
-// SaveHitState();
-
hitPoint1 = hitPoint2 = hitLine = false;
Vector lineSegment = endpoint - position;
Vector v1 = point - position;
Vector v2 = point - endpoint;
- double t = Vector::Parameter(position, endpoint, point);
+ double t = Geometry::ParameterOfLineAndPoint(position, endpoint, point);
double distance;
- // Geometric interpretation:
- // The parameter "t" on the vector lineSegment is where the normal of
- // lineSegment coincides with point. If t < 0, the normal lies beyond the
- // 1st endpoint. If t > 1, then the normal lies beyond the 2nd endpoint. We
- // only calculate the length of the normal between the point and the
- // lineSegment when the parameter is between 0 and 1.
-
// Geometric interpretation of "distance = ?Det?(ls, v1) / |ls|":
// 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
hitLine = true;
return (hitPoint1 || hitPoint2 || hitLine ? true : false);
-// return HitStateChanged();
}
/*virtual*/ Vector Line::GetPointAtParameter(double parameter)
{
+// Is there any real reason to clamp this to the endpoints?
+// (hey, whaddya know? this was masking a bug!)
+#if 0
if (parameter <= 0)
return position;
else if (parameter >= 1.0)
return endpoint;
+#endif
+
+ // The parameter is a percentage of the length of the vector, so all we
+ // have to do is scale the vector by it to find the point.
+ return position + (Vector(position, endpoint) * parameter);
+}
- // Our parameter lies between zero and one, so calculate it!
- Vector v(endpoint, position);
- double length = v.Magnitude();
- // We scale the magnitude of v so that it lies between 0 and 1...
- // By multiplying the parameter by the magnitude, we obtain the point we
- // want. No scaling necessary as it's inherent in the approach!
- double spotOnLength = length * parameter;
-
- // To get our point, we use the initial point of the line and add in our
- // scaled point.
- Vector result = position + (v * spotOnLength);
- return result;
+
+/*virtual*/ void Line::MovePointAtParameter(double parameter, Vector v)
+{
+ if (parameter == 0)
+ position += v;
+ else if (parameter == 1.0)
+ endpoint += v;
+ else
+ {} // Not sure how to handle this case :-P
}
}
-/*virtual*/ void Line::Rotate(Vector point, double angle)
+/*virtual*/ void Line::Rotate(Point point, double angle)
{
+ Point l1 = Geometry::RotatePointAroundPoint(position, point, angle);
+ Point l2 = Geometry::RotatePointAroundPoint(endpoint, point, angle);
+ position = l1;
+ endpoint = l2;
}
-/*virtual*/ void Line::Scale(Vector point, double amount)
+/*virtual*/ void Line::Scale(Point point, double amount)
{
}
-/*virtual*/ Object * Line::Mirror(Vector p1, Vector p2)
-{
-#if 0
- return NULL;
-
-double Vector::Parameter(Vector v1, Vector v2, Vector p)
+/*virtual*/ void Line::Mirror(Point p1, Point p2)
{
- // Geometric interpretation:
- // The parameterized point on the vector lineSegment is where the normal of
- // the lineSegment to the point intersects lineSegment. If the pp < 0, then
- // the perpendicular lies beyond the 1st endpoint. If pp > 1, then the
- // perpendicular lies beyond the 2nd endpoint.
-
- Vector lineSegment = v2 - v1;
- double magnitude = lineSegment.Magnitude();
- Vector pointSegment = p - v1;
- double t = lineSegment.Dot(pointSegment) / (magnitude * magnitude);
- return t;
+ Point l1 = Geometry::MirrorPointAroundLine(position, p1, p2);
+ Point l2 = Geometry::MirrorPointAroundLine(endpoint, p1, p2);
+ position = l1;
+ endpoint = l2;
}
-// Return the normal to the linesegment formed by the passed in points.
-// (Not sure which is head or tail, or which hand the normal lies)
-/*static*/ Vector Vector::Normal(Vector v1, Vector v2)
-#endif
-
- double t1 = Vector::Parameter(p1, p2, position);
- double t2 = Vector::Parameter(p1, p2, endpoint);
-
- Vector unit = Vector(p1, p2).Unit();
- Vector v1 = unit * t1;
- Vector v2 = unit * t2;
-
-// Vector normal = Vector::Normal(p1, p2);
- // Get the points normal to position & endpoint to the line passed in
- // (these are tails)
- Vector v3 = p1 + v1;
- Vector v4 = p1 + v2;
-
- // Make our mirrored vectors
- Vector v5 = -(position - v3);
- Vector v6 = -(endpoint - v4);
+/*virtual*/ void Line::Save(void)
+{
+ Object::Save();
+ oldEndpoint = endpoint;
+}
- // Find the points
- Vector v7 = v3 + v5;
- Vector v8 = v4 + v6;
- return new Line(v7, v8);
+/*virtual*/ void Line::Restore(void)
+{
+ Object::Restore();
+ endpoint = oldEndpoint;
}
-void Line::SetDimensionOnLine(Dimension * dimension/*=NULL*/)
+void Line::SetDimensionOnLine(Dimension * dimension/*= NULL*/)
{
// If they don't pass one in, create it for the caller.
- if (dimension == NULL)
+ // But ONLY if this line has a parent container!
+ // This is really bad to do here, it should be done in the parent container, always!
+#warning "!!! Parent container should be creating Dimension object !!!"
+ if ((dimension == NULL) && (parent != NULL))
{
//printf("Line::SetDimensionOnLine(): Creating new dimension...\n");
-// dimension = new Dimension(position, endpoint, DTLinear, this);
- dimension = new Dimension(Connection(this, 0), Connection(this, 1.0), DTLinear, this);
+ dimension = new Dimension(position, endpoint, DTLinear, parent);
+// dimension = new Dimension(Connection(this, 0), Connection(this, 1.0), DTLinear, this);
- if (parent)
+ // THIS IS SERIOUS!!! WITHOUT A PARENT, THIS OBJECT IS IN LIMBO!!!
+// if (parent)
//{
//printf("Line::SetDimensionOnLine(): Adding to parent...\n");
- parent->Add(dimension);
+ parent->Add(dimension);
//}
}
- else
- {
- dimension->Connect(this, 0);
- dimension->Connect(this, 1.0);
- }
+
+ dimension->Connect(this, 0);
+ dimension->Connect(this, 1.0);
// Make sure the Dimension is connected to us...
Connect(dimension, 0);
Connect(dimension, 1.0);
+
+ dimension->position = position;
+ dimension->endpoint = endpoint;
}
projects / architektonas / blobdiff