X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdimension.cpp;h=8b930f05230af7b112af9a4a3e0143f8ab4860b6;hb=2af76acd67a2703859c11446be3be4d3ff8ff4b4;hp=4ccd48e52352e97ad69938f3873b0090221fc11e;hpb=bd9b40058a376c946318a444dd6c77737ec6ac98;p=architektonas diff --git a/src/dimension.cpp b/src/dimension.cpp index 4ccd48e..8b930f0 100644 --- a/src/dimension.cpp +++ b/src/dimension.cpp @@ -4,11 +4,12 @@ // (C) 2011 Underground Software // See the README and GPLv3 files for licensing and warranty information // -// JLH = James L. Hammons +// JLH = James Hammons // // 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,32 +19,39 @@ #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)); @@ -56,71 +64,59 @@ 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 - Point p1 = position + (orthogonal * 10.0); - Point p2 = endpoint + (orthogonal * 10.0); + Point p1 = position + (orthogonal * 10.0 * SCREEN_ZOOM); + Point p2 = endpoint + (orthogonal * 10.0 * SCREEN_ZOOM); // Draw main dimension line painter->DrawLine(p1, p2); - Point p3 = position + (orthogonal * 16.0); - Point p4 = endpoint + (orthogonal * 16.0); - Point p5 = position + (orthogonal * 4.0); - Point p6 = endpoint + (orthogonal * 4.0); + 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); +#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, size); + painter->DrawArrowhead(p2, p1, size); + // Draw length of dimension line... - painter->SetFont(QFont("Arial", 10)); +// 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) { @@ -129,6 +125,7 @@ retarded is that? :-/ return endpoint + v; } + /*virtual*/ bool Dimension::Collided(Vector /*point*/) { #if 0 @@ -229,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 @@ -269,6 +267,7 @@ Like so: needUpdate = false; } + /*virtual*/ void Dimension::PointerReleased(void) { if (draggingHandle1 || draggingHandle2) @@ -311,18 +310,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; +} + + +/*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; +} + + +/*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 @@ -330,9 +416,16 @@ 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; } +