X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdimension.cpp;h=2b49ff8d08e3d7564c5ae2c9c37ad223ec901188;hb=3047a65eb459ddb4a85e1a694aa2b2491437472e;hp=26a39f5d29d9b4c001a47e5d79c4b793336ed203;hpb=5446001bd9adfd9f4787f5de5a2a7afd8d7cdb5a;p=architektonas diff --git a/src/dimension.cpp b/src/dimension.cpp index 26a39f5..2b49ff8 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" @@ -18,37 +19,47 @@ #include "painter.h" -Dimension::Dimension(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p), endpoint(p2), +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()), 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, 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()), 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)); else - painter->SetPen(QPen(Qt::blue, 1.0, Qt::SolidLine)); +// painter->SetPen(QPen(Qt::blue, 1.0, Qt::SolidLine)); + painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine)); + + painter->SetBrush(QBrush(QColor(Qt::blue))); // Draw an aligned dimension line double angle = Vector(endpoint - position).Angle(); @@ -56,77 +67,59 @@ Dimension::~Dimension() Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle)); Vector unit = Vector(endpoint - position).Unit(); -//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 - Point p1 = position + (orthogonal * 10.0 * SCREEN_ZOOM); - Point p2 = endpoint + (orthogonal * 10.0 * SCREEN_ZOOM); +// Arrowhead: +// Point p1 = head - (unit * 9.0 * size); +// Point p2 = p1 + (orthogonal * 3.0 * size); +// Point p3 = p1 - (orthogonal * 3.0 * size); + +/* +The numbers hardcoded into here, what are they? +I believe they are pixels. +*/ - // Draw main dimension line - painter->DrawLine(p1, p2); + // Get our line parallel to our points + Point p1 = position + (orthogonal * 10.0 * size); + Point p2 = endpoint + (orthogonal * 10.0 * size); - Point p3 = position + (orthogonal * 16.0 * SCREEN_ZOOM); - Point p4 = endpoint + (orthogonal * 16.0 * SCREEN_ZOOM); - Point p5 = position + (orthogonal * 4.0 * SCREEN_ZOOM); - Point p6 = endpoint + (orthogonal * 4.0 * SCREEN_ZOOM); + 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); // 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); + // 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 = Vector::Parameter(position, endpoint, endpoint - (unit * 9.0 * size)); +//printf("Dimension::Draw(): t = %lf\n", t); + + if (t > 0.42) + { + // Draw main dimension line + arrowheads + painter->DrawLine(p1, p2); + painter->DrawArrowhead(p1, p2, size); + painter->DrawArrowhead(p2, p1, size); + } + else + { + Point p7 = p1 - (unit * 9.0 * size); + Point p8 = p2 + (unit * 9.0 * size); + painter->DrawArrowhead(p1, p7, size); + painter->DrawArrowhead(p2, p8, size); + painter->DrawLine(p1, p1 - (unit * 14.0 * size)); + painter->DrawLine(p2, p2 + (unit * 14.0 * size)); + } // Draw length of dimension line... - painter->SetFont(QFont("Arial", 10.0 * Painter::zoom * SCREEN_ZOOM)); + painter->SetFont(QFont("Arial", 8.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, 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) { @@ -135,6 +128,7 @@ retarded is that? :-/ return endpoint + v; } + /*virtual*/ bool Dimension::Collided(Vector /*point*/) { #if 0 @@ -235,6 +229,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 @@ -275,6 +270,7 @@ Like so: needUpdate = false; } + /*virtual*/ void Dimension::PointerReleased(void) { if (draggingHandle1 || draggingHandle2) @@ -317,28 +313,105 @@ 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; } -Vector Dimension::GetPoint1(void) + +/*virtual*/ void Dimension::Connect(Object * obj, double param) { - return position; + // 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; + } } -Vector Dimension::GetPoint2(void) + +/*virtual*/ void Dimension::Disconnect(Object * obj, double param) { - return endpoint; + if (point1.object == obj && point1.t == param) + point1.object = NULL; + else if (point2.object == obj && point2.t == param) + point2.object = NULL; } + +/*virtual*/ void Dimension::DisconnectAll(Object * obj) +{ + if (point1.object == obj) + point1.object = NULL; + + if (point2.object == obj) + point2.object = NULL; +} + + +/*virtual*/ QRectF Dimension::Extents(void) +{ + 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) { #if 0 @@ -346,9 +419,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; }