X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdimension.cpp;h=1e9b785e0be7d2981a30c892d2d05360627378ba;hb=7f3a6b11585376eecd80979ec3da2346c5314d88;hp=2d37eeaed366815b282f70034ce78dfb3b838281;hpb=771113b26ca27707c96fdcd80d79a08e40884268;p=architektonas diff --git a/src/dimension.cpp b/src/dimension.cpp index 2d37eea..1e9b785 100644 --- a/src/dimension.cpp +++ b/src/dimension.cpp @@ -27,6 +27,7 @@ Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/, Objec { // We set the size to 1/4 base unit. Could be anything. type = OTDimension; +// dimensionType = DTLinearHorz; } @@ -62,31 +63,66 @@ all objects move as a unified whole. // Draw an aligned dimension line Vector v(position, endpoint); double angle = v.Angle(); - Vector orthogonal = Vector::Normal(position, endpoint); +// 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; + Vector ortho; + double x1, y1, length; - if ((angle < PI_OVER_2) || (angle > PI3_OVER_2)) + if (dimensionType == DTLinearVert) { - y1 = (position.y > endpoint.y ? position.y : endpoint.y); - ortho = Vector(0, 1.0); - angle = 0; + if ((angle < 0) || (angle > PI)) + { + x1 = (position.x > endpoint.x ? position.x : endpoint.x); + y1 = (position.y > endpoint.y ? position.y : endpoint.y); + ortho = Vector(1.0, 0); + angle = PI3_OVER_2; + } + else + { + x1 = (position.x > endpoint.x ? endpoint.x : position.x); + y1 = (position.y > endpoint.y ? endpoint.y : position.y); + ortho = Vector(-1.0, 0); + angle = PI_OVER_2; + } + + linePt1.x = linePt2.x = x1; + length = fabs(position.y - endpoint.y); } - else + else if (dimensionType == DTLinearHorz) { - y1 = (position.y > endpoint.y ? endpoint.y : position.y); - ortho = Vector(0, -1.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(0, 1.0); + angle = 0; + } + else + { + x1 = (position.x > endpoint.x ? endpoint.x : position.x); + y1 = (position.y > endpoint.y ? endpoint.y : position.y); + ortho = Vector(0, -1.0); + angle = PI; + } + + linePt1.y = linePt2.y = y1; + length = fabs(position.x - endpoint.x); + } + else if (dimensionType == DTLinear) + { + angle = Vector(linePt1, linePt2).Angle(); + ortho = Vector::Normal(linePt1, linePt2); + length = v.Magnitude(); } -// pos.y = endp.y = y1; - linePt1.y = linePt2.y = y1; unit = Vector(linePt1, linePt2).Unit(); +// angle = Vector(linePt1, linePt2).Angle(); +// ortho = Vector::Normal(linePt1, linePt2); + Point p1 = linePt1 + (ortho * 10.0 * size); Point p2 = linePt2 + (ortho * 10.0 * size); Point p3 = linePt1 + (ortho * 16.0 * size); @@ -141,19 +177,12 @@ I believe they are pixels. // Draw length of dimension line... painter->SetFont(QFont("Arial", 8.0 * Painter::zoom * size)); -#if 0 - Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0); - Point ctr = p2 + v1; -#else Point ctr = p2 + (Vector(p2, p1) / 2.0); -#endif #if 0 QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude()); #else QString dimText; -// double length = v.Magnitude(); - double length = fabs(position.x - endpoint.x); if (length < 12.0) dimText = QString("%1\"").arg(length); @@ -171,28 +200,43 @@ I believe they are pixels. painter->DrawAngledText(ctr, angle, dimText, size); -// 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); - - Point p10 = p9 + (orthogonal * -7.0); - Point p11 = p10 + (unit * 7.0); - Point p12 = p11 + (orthogonal * 7.0); - Point p13 = p12 + (unit * -7.0); - painter->DrawLine(p10, p11); - painter->DrawLine(p11, p12); - painter->DrawLine(p12, p13); - painter->DrawLine(p13, p10); -#else + Point hp1 = (p1 + p2) / 2.0; + Point hp2 = (p1 + hp1) / 2.0; + Point hp3 = (hp1 + p2) / 2.0; + if (hitFlipSwitch) + { + painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine)); + painter->SetBrush(QBrush(QColor(Qt::magenta))); + painter->DrawArrowHandle(hp1, ortho.Angle() + PI); painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine)); + } - Point hp1 = (p1 + p2) / 2.0; painter->DrawHandle(hp1); -#endif + 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); } } @@ -220,6 +264,9 @@ I believe they are pixels. if (snapToGrid) point = SnapPointToGrid(point); + if (snapPointIsValid) + point = snapPoint; + if (hitPoint1) { oldState = state; @@ -243,6 +290,28 @@ I believe they are pixels. // 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; @@ -269,6 +338,12 @@ I believe they are pixels. bool hovered = HitTest(point); needUpdate = HitStateChanged(); + if (snapToGrid) + point = SnapPointToGrid(point); + + if (snapPointIsValid) + point = snapPoint; + objectWasDragged = (/*draggingLine |*/ draggingHandle1 | draggingHandle2); if (objectWasDragged) @@ -345,7 +420,8 @@ about keeping track of old states... #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); @@ -353,7 +429,10 @@ about keeping track of old states... // 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(); @@ -374,8 +453,12 @@ about keeping track of old states... 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); } @@ -385,21 +468,65 @@ void Dimension::SaveHitState(void) 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); }