X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdimension.cpp;h=8b930f05230af7b112af9a4a3e0143f8ab4860b6;hb=2af76acd67a2703859c11446be3be4d3ff8ff4b4;hp=3060ff1b930c8682409f10993b73622562fbb098;hpb=baf67656b97e3d61e9223e66ebe4f554e364cd4a;p=architektonas diff --git a/src/dimension.cpp b/src/dimension.cpp index 3060ff1..8b930f0 100644 --- a/src/dimension.cpp +++ b/src/dimension.cpp @@ -9,6 +9,7 @@ // WHO WHEN WHAT // --- ---------- ------------------------------------------------------------ // JLH 04/04/2011 Created this file, basic rendering +// JLH 03/14/2013 Updated to new connection system // #include "dimension.h" @@ -21,31 +22,36 @@ Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/ ,Object * p/*= NULL*/): Object(p1, p), endpoint(p2), dragging(false), draggingHandle1(false), draggingHandle2(false), - length(p2.Magnitude()), type(dt), point1(NULL), point2(NULL) + length(p2.Magnitude()), dimensionType(dt), size(0.25), point1(NULL), point2(NULL) { + // We set the size to 1/4 base unit. Could be anything. + type = OTDimension; } + // This is bad, p1 & p2 could be NULL, causing much consternation... -Dimension::Dimension(Vector * p1, Vector * p2, DimensionType dt/*= DTLinear*/ , Object * p/*= NULL*/): - Object(*p1, p), endpoint(*p2), +Dimension::Dimension(Connection p1, Connection p2, DimensionType dt/*= DTLinear*/ , Object * p/*= NULL*/): dragging(false), draggingHandle1(false), draggingHandle2(false), - length(p2->Magnitude()), type(dt), point1(p1), point2(p2) + length(0), dimensionType(dt), size(0.25), point1(p1), point2(p2) { + type = OTDimension; } + Dimension::~Dimension() { } + /*virtual*/ void Dimension::Draw(Painter * painter) { // If there are valid Vector pointers in here, use them to update the internal // positions. Otherwise, we just use the internal positions by default. - if (point1) - position = *point1; + if (point1.object) + position = point1.object->GetPointAtParameter(point1.t); - if (point2) - endpoint = *point2; + if (point2.object) + endpoint = point2.object->GetPointAtParameter(point2.t); if (state == OSSelected) painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine)); @@ -58,6 +64,7 @@ Dimension::~Dimension() Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle)); Vector unit = Vector(endpoint - position).Unit(); +#if 0 //NOTE: SCREEN_ZOOM is our kludge factor... We need to figure out a better // way of doing this... // Get our line parallel to our points @@ -71,64 +78,45 @@ Dimension::~Dimension() Point p4 = endpoint + (orthogonal * 16.0 * SCREEN_ZOOM); Point p5 = position + (orthogonal * 4.0 * SCREEN_ZOOM); Point p6 = endpoint + (orthogonal * 4.0 * SCREEN_ZOOM); +#else +/* +The numbers hardcoded into here, what are they? +I believe they are pixels. +*/ + + // Get our line parallel to our points + Point p1 = position + (orthogonal * 10.0 * size); + Point p2 = endpoint + (orthogonal * 10.0 * size); + + // Draw main dimension line + painter->DrawLine(p1, p2); + + Point p3 = position + (orthogonal * 16.0 * size); + Point p4 = endpoint + (orthogonal * 16.0 * size); + Point p5 = position + (orthogonal * 4.0 * size); + Point p6 = endpoint + (orthogonal * 4.0 * size); +#endif // Draw extension lines painter->DrawLine(p3, p5); painter->DrawLine(p4, p6); painter->SetBrush(QBrush(QColor(Qt::blue))); - painter->DrawArrowhead(p1, p2); - painter->DrawArrowhead(p2, p1); +// painter->DrawArrowhead(p1, p2); +// painter->DrawArrowhead(p2, p1); + painter->DrawArrowhead(p1, p2, size); + painter->DrawArrowhead(p2, p1, size); // Draw length of dimension line... - painter->SetFont(QFont("Arial", 10.0 * Painter::zoom * SCREEN_ZOOM)); +// painter->SetFont(QFont("Arial", 10.0 * Painter::zoom * SCREEN_ZOOM)); + painter->SetFont(QFont("Arial", 10.0 * Painter::zoom * size)); Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0); Point ctr = p2 + v1; - // This is in pixels, which isn't even remotely correct... !!! FIX !!! QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude()); -// int textWidth = QFontMetrics(painter->font()).width(dimText); -// int textHeight = QFontMetrics(painter->font()).height(); -#if 0 -//We have to do transformation voodoo to make the text come out readable and in correct orientation... -//Some things to note here: if angle > 90 degrees, then we need to take the negative of the angle -//for our text. -painter->save(); -painter->translate(ctr.x, ctr.y); -int yOffset = -8; -//16 : printf("textHeight: %d\n", textHeight); - -//Fix text so it isn't upside down... -if ((angle > PI * 0.5) && (angle < PI * 1.5)) -{ - angle += PI; - yOffset = 18; +// painter->DrawAngledText(ctr, angle, dimText); + painter->DrawAngledText(ctr, angle, dimText, size); } -painter->rotate(angle * RADIANS_TO_DEGREES); -painter->scale(1.0, -1.0); -//painter->translate(-textWidth / 2, -24); -// painter->drawText(0, 0, textWidth, 20, Qt::AlignCenter, dimText); - // This version draws the y-coord from the baseline of the font - painter->DrawText(-textWidth / 2, yOffset, dimText); -//painter->setPen(QPen(QColor(0xFF, 0x20, 0x20), 1.0, Qt::SolidLine)); -//painter->drawLine(20, 0, -20, 0); -//painter->drawLine(0, 20, 0, -20); -painter->restore(); -#else -// painter->DrawText(QRectF(QPointF(ctr.x, ctr.y), QPointF(ctr.x + textWidth, ctr.y + textHeight)), Qt::AlignVCenter, dimText); -// Now that we've taken our own good advice, maybe we should have the painter class -// do a nice abstracted text draw routine? :-) - painter->DrawAngledText(ctr, angle, dimText); -#endif - -/* -All of the preceeding makes me think that rather than try to compensate for Qt's unbelieveably -AWFUL decision to go with a wrong-handed graphics subsystem, it may be better to just stuff -all of that crap into some kind of subclass that handles all the nastiness behind the scenes. -I mean, really, all this crap just to get some proplerly rendered text on the screen? How -retarded is that? :-/ -*/ -} /*virtual*/ Vector Dimension::Center(void) { @@ -137,6 +125,7 @@ retarded is that? :-/ return endpoint + v; } + /*virtual*/ bool Dimension::Collided(Vector /*point*/) { #if 0 @@ -237,6 +226,7 @@ Like so: return false; } + /*virtual*/ void Dimension::PointerMoved(Vector point) { // We know this is true because mouse move messages don't come here unless @@ -277,6 +267,7 @@ Like so: needUpdate = false; } + /*virtual*/ void Dimension::PointerReleased(void) { if (draggingHandle1 || draggingHandle2) @@ -319,27 +310,104 @@ about keeping track of old states... state = oldState; } -void Dimension::SetPoint1(Vector * v) + +/*virtual*/ void Dimension::Enumerate(FILE * file) { - point1 = v; - needUpdate = true; + fprintf(file, "DIMENSION (%lf,%lf) (%lf,%lf) %i\n", position.x, position.y, endpoint.x, endpoint.y, type); } -void Dimension::SetPoint2(Vector * v) + +// Dimensions are special: they contain exactly *two* points. Here, we check +// only for zero/non-zero in returning the correct points. +/*virtual*/ Vector Dimension::GetPointAtParameter(double parameter) { - point2 = v; - needUpdate = true; + if (parameter == 0) + return position; + + return endpoint; +} + + +/*virtual*/ void Dimension::Connect(Object * obj, double param) +{ + // There are four possibilities here... + // The param is only looking for 0 or 1 here. + if (point1.object == NULL && point2.object == NULL) + { + point1.object = obj; + point1.t = param; + } + else if (point1.object == NULL && point2.object != NULL) + { + if (point2.t == param) + point2.object = obj; + else + { + point1.object = obj; + point1.t = param; + } + } + else if (point1.object != NULL && point2.object == NULL) + { + if (point1.t == param) + point1.object = obj; + else + { + point2.object = obj; + point2.t = param; + } + } + else if (point1.object != NULL && point2.object != NULL) + { + if (point1.t == param) + point1.object = obj; + else + point2.object = obj; + } +} + + +/*virtual*/ void Dimension::Disconnect(Object * obj, double param) +{ + if (point1.object == obj && point1.t == param) + point1.object = NULL; + else if (point2.object == obj && point2.t == param) + point2.object = NULL; } -Vector Dimension::GetPoint1(void) + +/*virtual*/ void Dimension::DisconnectAll(Object * obj) { - return position; + if (point1.object == obj) + point1.object = NULL; + + if (point2.object == obj) + point2.object = NULL; } -Vector Dimension::GetPoint2(void) + +/*virtual*/ QRectF Dimension::Extents(void) { - return endpoint; + Point p1 = position; + Point p2 = endpoint; + + if (point1.object) + p1 = point1.object->GetPointAtParameter(point1.t); + + if (point2.object) + p2 = point2.object->GetPointAtParameter(point2.t); + + return QRectF(QPointF(p1.x, p1.y), QPointF(p2.x, p2.y)); +} + + +#if 0 +/*virtual*/ ObjectType Dimension::Type(void) +{ + return OTDimension; } +#endif + void Dimension::FlipSides(void) { @@ -348,9 +416,15 @@ void Dimension::FlipSides(void) position = endpoint; endpoint = tmp; #else - Vector * tmp = point1; + Connection tmp = point1; point1 = point2; point2 = tmp; +// double tmp = point1.t; +// point1.t = point2.t; +// point2.t = tmp; +// Object * tmp = point1.object; +// point1.object = point2.object; +// point2.object = tmp; #endif needUpdate = true; }