type = OTDimension;
}
-#if 0
-// This is bad, p1 & p2 could be NULL, causing much consternation...
-Dimension::Dimension(Connection p1, Connection p2, DimensionType dt/*= DTLinear*/, Object * p/*= NULL*/):
- dragging(false), draggingHandle1(false), draggingHandle2(false),
- length(0), dimensionType(dt), size(0.25)//, point1(p1), point2(p2)
-{
- type = OTDimension;
-}
-#endif
Dimension::~Dimension()
{
double angle = v.Angle();
Vector orthogonal = Vector::Normal(position, endpoint);
Vector unit = v.Unit();
+ linePt1 = position, linePt2 = endpoint;
// Horizontally aligned display
#if 1
- Vector pos = position, endp = endpoint, ortho;
- double y1, y2;
+ Vector /*pos = position, endp = endpoint,*/ ortho;
+ double y1;
if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
{
- y1 = (pos.y > endp.y ? pos.y : endp.y);
- y2 = (pos.y > endp.y ? endp.y : pos.y);
+ y1 = (position.y > endpoint.y ? position.y : endpoint.y);
ortho = Vector(0, 1.0);
angle = 0;
}
else
{
- y1 = (pos.y > endp.y ? endp.y : pos.y);
- y2 = (pos.y > endp.y ? pos.y : endp.y);
+ y1 = (position.y > endpoint.y ? endpoint.y : position.y);
ortho = Vector(0, -1.0);
angle = PI;
}
- pos.y = endp.y = y1;
- unit = Vector(pos, endp).Unit();
- Point p1 = pos + (ortho * 10.0 * size);
- Point p2 = endp + (ortho * 10.0 * size);
- Point p3 = pos + (ortho * 16.0 * size);
- Point p4 = endp + (ortho * 16.0 * size);
+// pos.y = endp.y = y1;
+ linePt1.y = linePt2.y = y1;
+ unit = Vector(linePt1, linePt2).Unit();
+ Point p1 = linePt1 + (ortho * 10.0 * size);
+ Point p2 = linePt2 + (ortho * 10.0 * size);
+ Point p3 = linePt1 + (ortho * 16.0 * size);
+ Point p4 = linePt2 + (ortho * 16.0 * size);
Point p5 = position + (ortho * 4.0 * size);
Point p6 = endpoint + (ortho * 4.0 * size);
#endif
// Calculate whether or not the arrowheads are too crowded to put inside
// the extension lines. 9.0 is the length of the arrowhead.
// double t = Geometry::ParameterOfLineAndPoint(position, endpoint, endpoint - (unit * 9.0 * size));
- double t = Geometry::ParameterOfLineAndPoint(pos, endp, endp - (unit * 9.0 * size));
+// double t = Geometry::ParameterOfLineAndPoint(pos, endp, endp - (unit * 9.0 * size));
+ double t = Geometry::ParameterOfLineAndPoint(linePt1, linePt2, linePt2 - (unit * 9.0 * size));
//printf("Dimension::Draw(): t = %lf\n", t);
// On the screen, it's acting like this is actually 58%...
// need to make another handle drawing function in Painter, instead of this
if (hitLine)
{
+#if 0
Point p9 = ((position + endpoint) / 2.0) + (orthogonal * 14.0)
+ (unit * 7.0);
painter->DrawLine(p11, p12);
painter->DrawLine(p12, p13);
painter->DrawLine(p13, p10);
+#else
+ if (hitFlipSwitch)
+ painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+
+ Point hp1 = (p1 + p2) / 2.0;
+ painter->DrawHandle(hp1);
+#endif
}
}
draggingHandle2 = true;
return true;
}
+ else if (hitFlipSwitch)
+ {
+ FlipSides();
+ hitFlipSwitch = hitLine = false;
+// state = OSInactive;
+// return true;
+ }
state = OSInactive;
return false;
}
-/*virtual*/ void Dimension::PointerMoved(Vector point)
+/*virtual*/ bool Dimension::PointerMoved(Vector point)
{
if (selectionInProgress)
{
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);
oldPoint = point;
needUpdate = true;
}
+
+ return hovered;
}
/*virtual*/ bool Dimension::HitTest(Point point)
{
- Vector orthogonal = Vector::Normal(position, endpoint);
+// Vector orthogonal = Vector::Normal(position, endpoint);
+ Vector orthogonal = Vector::Normal(linePt1, linePt2);
// Get our line parallel to our points
+#if 0
Point p1 = position + (orthogonal * 10.0 * size);
Point p2 = endpoint + (orthogonal * 10.0 * size);
+#else
+ Point p1 = linePt1 + (orthogonal * 10.0 * size);
+ Point p2 = linePt2 + (orthogonal * 10.0 * size);
+#endif
Point p3(p1, point);
hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = false;
// double t = Geometry::ParameterOfLineAndPoint(position, endpoint, point);
double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
double distance;
+ Point hFSPoint = Point((p1 + p2) / 2.0, point);
if (t < 0.0)
distance = v1.Magnitude();
else if ((distance * Painter::zoom) < 5.0)
hitLine = true;
- return (hitPoint1 || hitPoint2 || hitLine ? true : false);
+ if ((hFSPoint.Magnitude() * Painter::zoom) < 8.0)
+ hitFlipSwitch = true;
+
+ return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch ? true : false);
}
oldHitPoint1 = hitPoint1;
oldHitPoint2 = hitPoint2;
oldHitLine = hitLine;
+ oldHitFlipSwitch = hitFlipSwitch;
}
bool Dimension::HitStateChanged(void)
{
- if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine))
+ if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch))
return true;
return false;