if (dimensionType == DTLinearVert)
{
if ((angle < 0) || (angle > PI))
- // if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
{
x1 = (position.x > endpoint.x ? position.x : endpoint.x);
y1 = (position.y > endpoint.y ? position.y : endpoint.y);
ortho = Vector(1.0, 0);
- // ortho = Vector(0, 1.0);
angle = PI3_OVER_2;
- // angle = 0;
}
else
{
x1 = (position.x > endpoint.x ? endpoint.x : position.x);
y1 = (position.y > endpoint.y ? endpoint.y : position.y);
ortho = Vector(-1.0, 0);
- // ortho = Vector(0, -1.0);
angle = PI_OVER_2;
- // angle = PI;
}
linePt1.x = linePt2.x = x1;
if (hitLine)
{
Point hp1 = (p1 + p2) / 2.0;
+ Point hp2 = (p1 + hp1) / 2.0;
+ Point hp3 = (hp1 + p2) / 2.0;
if (hitFlipSwitch)
{
}
painter->DrawHandle(hp1);
+ painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+ if (hitChangeSwitch1)
+ {
+ painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+ painter->SetBrush(QBrush(QColor(Qt::magenta)));
+ painter->DrawArrowToLineHandle(hp2, (dimensionType == DTLinearVert ? v.Angle() - PI_OVER_2 : (v.Angle() < PI ? PI : 0)));
+ painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+ }
+
+ painter->DrawHandle(hp2);
+ painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+ if (hitChangeSwitch2)
+ {
+ painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+ painter->SetBrush(QBrush(QColor(Qt::magenta)));
+ painter->DrawArrowToLineHandle(hp3, (dimensionType == DTLinearHorz ? v.Angle() - PI_OVER_2 : (v.Angle() > PI_OVER_2 && v.Angle() < PI3_OVER_2 ? PI3_OVER_2 : PI_OVER_2)));
+ painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+ }
+
+ painter->DrawHandle(hp3);
}
}
if (snapToGrid)
point = SnapPointToGrid(point);
+ if (snapPointIsValid)
+ point = snapPoint;
+
if (hitPoint1)
{
oldState = state;
// state = OSInactive;
// return true;
}
+ else if (hitChangeSwitch1)
+ {
+ // There are three cases here: aligned, horizontal, & vertical. Aligned
+ // and horizontal do the same thing, vertical goes back to linear.
+ if (dimensionType == DTLinearVert)
+ dimensionType = DTLinear;
+ else
+ dimensionType = DTLinearVert;
+
+ hitFlipSwitch = hitLine = false;
+ }
+ else if (hitChangeSwitch2)
+ {
+ // There are three cases here: aligned, horizontal, & vertical. Aligned
+ // and vertical do the same thing, horizontal goes back to linear.
+ if (dimensionType == DTLinearHorz)
+ dimensionType = DTLinear;
+ else
+ dimensionType = DTLinearHorz;
+
+ hitFlipSwitch = hitLine = false;
+ }
state = OSInactive;
return false;
bool hovered = HitTest(point);
needUpdate = HitStateChanged();
+ if (snapToGrid)
+ point = SnapPointToGrid(point);
+
+ if (snapPointIsValid)
+ point = snapPoint;
+
objectWasDragged = (/*draggingLine |*/ draggingHandle1 | draggingHandle2);
if (objectWasDragged)
#endif
Point p3(p1, point);
- hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = false;
+ hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = hitChangeSwitch1
+ = hitChangeSwitch2 = false;
Vector v1(position, point);
Vector v2(endpoint, point);
// Vector lineSegment(position, endpoint);
// double t = Geometry::ParameterOfLineAndPoint(position, endpoint, point);
double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
double distance;
- Point hFSPoint = Point((p1 + p2) / 2.0, point);
+ Point midpoint = (p1 + p2) / 2.0;
+ Point hFSPoint = Point(midpoint, point);
+ Point hCS1Point = Point((p1 + midpoint) / 2.0, point);
+ Point hCS2Point = Point((midpoint + p2) / 2.0, point);
if (t < 0.0)
distance = v1.Magnitude();
if ((hFSPoint.Magnitude() * Painter::zoom) < 8.0)
hitFlipSwitch = true;
+ else if ((hCS1Point.Magnitude() * Painter::zoom) < 8.0)
+ hitChangeSwitch1 = true;
+ else if ((hCS2Point.Magnitude() * Painter::zoom) < 8.0)
+ hitChangeSwitch2 = true;
- return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch ? true : false);
+ return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch || hitChangeSwitch1 || hitChangeSwitch2 ? true : false);
}
oldHitPoint2 = hitPoint2;
oldHitLine = hitLine;
oldHitFlipSwitch = hitFlipSwitch;
+ oldHitChangeSwitch1 = hitChangeSwitch1;
+ oldHitChangeSwitch2 = hitChangeSwitch2;
}
bool Dimension::HitStateChanged(void)
{
- if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch))
+ if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2)
+ || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch)
+ || (hitChangeSwitch1 != oldHitChangeSwitch1)
+ || (hitChangeSwitch2 != oldHitChangeSwitch2))
return true;
return false;
}
+/*virtual*/ void Dimension::Translate(Vector amount)
+{
+ position += amount;
+ endpoint += amount;
+}
+
+
+/*virtual*/ void Dimension::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 Dimension::Mirror(Point p1, Point p2)
+{
+ Point l1 = Geometry::MirrorPointAroundLine(position, p1, p2);
+ Point l2 = Geometry::MirrorPointAroundLine(endpoint, p1, p2);
+ position = l1;
+ endpoint = l2;
+}
+
+
+/*virtual*/ void Dimension::Save(void)
+{
+ Object::Save();
+ oldEndpoint = endpoint;
+}
+
+
+/*virtual*/ void Dimension::Restore(void)
+{
+ Object::Restore();
+ endpoint = oldEndpoint;
+}
+
+
/*virtual*/ void Dimension::Enumerate(FILE * file)
{
- fprintf(file, "DIMENSION %i (%lf,%lf) (%lf,%lf) %i\n", layer, position.x, position.y, endpoint.x, endpoint.y, type);
+ fprintf(file, "DIMENSION %i (%lf,%lf) (%lf,%lf) %i\n", layer, position.x, position.y, endpoint.x, endpoint.y, dimensionType);
}