X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fdrawingview.cpp;h=58e0979495b3794d2df175ced51453ac6b6a912b;hb=f507d97c1b1118834a70332f5f79d8479a6964c0;hp=e93161a5a7235c544f93f0ae64b85d37e56c8c5f;hpb=84afe881653a02a16b19d4da37435b8701b1a826;p=architektonas diff --git a/src/drawingview.cpp b/src/drawingview.cpp index e93161a..58e0979 100644 --- a/src/drawingview.cpp +++ b/src/drawingview.cpp @@ -30,6 +30,7 @@ #include "drawingview.h" #include +#include "geometry.h" #include "global.h" #include "mathconstants.h" #include "painter.h" @@ -78,7 +79,9 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent), line->p1 = Vector(5, 5); line->p2 = Vector(50, 40); line->type = OTLine; - line->thickness = 1.0; + line->thickness = 2.0; + line->style = LSDash; + line->color = 0xFF7F00; document.objects.push_back(line); document.objects.push_back(new Line(Vector(50, 40), Vector(10, 83))); document.objects.push_back(new Line(Vector(10, 83), Vector(17, 2))); @@ -86,6 +89,8 @@ DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent), document.objects.push_back(new Circle(Vector(50, 150), 49)); document.objects.push_back(new Arc(Vector(300, 300), 32, PI / 4.0, PI * 1.3)), document.objects.push_back(new Arc(Vector(200, 200), 60, PI / 2.0, PI * 1.5)); + document.objects.push_back(new Dimension(Vector(50, 40), Vector(5, 5))); + document.objects.push_back(new Text(Vector(10, 83), "Tyegxt!")); #endif /* @@ -341,33 +346,175 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/) } -void DrawingView::RenderObjects(Painter * p, Container * c) +void DrawingView::RenderObjects(Painter * painter, Container * c) { std::vector::iterator i; for(i=c->objects.begin(); i!=c->objects.end(); i++) { Object * obj = (Object *)(*i); - p->SetPen(QPen(Qt::black, 1.0 * Global::zoom * obj->thickness, Qt::SolidLine)); + float scaledThickness = Global::scale * obj->thickness; + painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style); + painter->SetBrush(obj->color); + + if (obj->selected || obj->hovered) + painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash); switch (obj->type) { case OTLine: { Line * l = (Line *)obj; - p->DrawLine(l->p1, l->p2); + painter->DrawLine(l->p1, l->p2); break; } case OTCircle: { Circle * ci = (Circle *)obj; - p->DrawEllipse(ci->p1, ci->radius, ci->radius); + painter->SetBrush(QBrush(Qt::NoBrush)); + painter->DrawEllipse(ci->p1, ci->radius, ci->radius); break; } case OTArc: { Arc * a = (Arc *)obj; - p->DrawArc(a->p1, a->radius, a->angle1, a->angle2); + painter->DrawArc(a->p1, a->radius, a->angle1, a->angle2); + break; + } + case OTDimension: + { + Dimension * d = (Dimension *)obj; + + Vector v(d->p1, d->p2); + double angle = v.Angle(); + Vector unit = v.Unit(); + Vector linePt1 = d->p1, linePt2 = d->p2; + Vector ortho; + double x1, y1, length; + + if (d->subtype == DTLinearVert) + { + if ((angle < 0) || (angle > PI)) + { + x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x); + y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y); + ortho = Vector(1.0, 0); + angle = PI3_OVER_2; + } + else + { + x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x); + y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y); + ortho = Vector(-1.0, 0); + angle = PI_OVER_2; + } + + linePt1.x = linePt2.x = x1; + length = fabs(d->p1.y - d->p2.y); + } + else if (d->subtype == DTLinearHorz) + { + if ((angle < PI_OVER_2) || (angle > PI3_OVER_2)) + { + x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x); + y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y); + ortho = Vector(0, 1.0); + angle = 0; + } + else + { + x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x); + y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y); + ortho = Vector(0, -1.0); + angle = PI; + } + + linePt1.y = linePt2.y = y1; + length = fabs(d->p1.x - d->p2.x); + } + else if (d->subtype == DTLinear) + { + angle = Vector(linePt1, linePt2).Angle(); + ortho = Vector::Normal(linePt1, linePt2); + length = v.Magnitude(); + } + + unit = Vector(linePt1, linePt2).Unit(); + + Point p1 = linePt1 + (ortho * 10.0 * scaledThickness); + Point p2 = linePt2 + (ortho * 10.0 * scaledThickness); + Point p3 = linePt1 + (ortho * 16.0 * scaledThickness); + Point p4 = linePt2 + (ortho * 16.0 * scaledThickness); + Point p5 = d->p1 + (ortho * 4.0 * scaledThickness); + Point p6 = d->p2 + (ortho * 4.0 * scaledThickness); + + /* + The numbers hardcoded into here, what are they? + I believe they are pixels. + */ + // Draw extension lines (if certain type) + painter->DrawLine(p3, p5); + painter->DrawLine(p4, p6); + + // 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 = Geometry::ParameterOfLineAndPoint(linePt1, linePt2, linePt2 - (unit * 9.0 * scaledThickness)); + //printf("Dimension::Draw(): t = %lf\n", t); + + // On the screen, it's acting like this is actually 58%... + // This is correct, we want it to happen at > 50% + if (t > 0.58) + { + // Draw main dimension line + arrowheads + painter->DrawLine(p1, p2); + painter->DrawArrowhead(p1, p2, scaledThickness); + painter->DrawArrowhead(p2, p1, scaledThickness); + } + else + { + // Draw outside arrowheads + Point p7 = p1 - (unit * 9.0 * scaledThickness); + Point p8 = p2 + (unit * 9.0 * scaledThickness); + painter->DrawArrowhead(p1, p7, scaledThickness); + painter->DrawArrowhead(p2, p8, scaledThickness); + painter->DrawLine(p1, p1 - (unit * 14.0 * scaledThickness)); + painter->DrawLine(p2, p2 + (unit * 14.0 * scaledThickness)); + } + + // Draw length of dimension line... + painter->SetFont(QFont("Arial", 8.0 * Global::zoom * scaledThickness)); + Point ctr = p2 + (Vector(p2, p1) / 2.0); + + #if 0 + QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude()); + #else + QString dimText; + + if (length < 12.0) + dimText = QString("%1\"").arg(length); + else + { + double feet = (double)((int)length / 12); + double inches = length - (feet * 12.0); + + if (inches == 0) + dimText = QString("%1'").arg(feet); + else + dimText = QString("%1' %2\"").arg(feet).arg(inches); + } + #endif + + painter->DrawAngledText(ctr, angle, dimText, scaledThickness); + + break; + } + case OTText: + { + Text * t = (Text *)obj; + + for(float angle=0; angle<(PI*3.0/2.0); angle+=PI/8.0) + painter->DrawTextObject(t->p1, t->s.c_str(), scaledThickness, angle); + break; } default: @@ -473,6 +620,109 @@ void DrawingView::mouseMoveEvent(QMouseEvent * event) } #endif + // Do checking here to see if object can be selected or not + if (Global::selectionInProgress) + { + std::vector::iterator i; +// QRectF bounds; + + for(i=document.objects.begin(); i!=document.objects.end(); i++) + { + Object * obj = (Object *)(*i); + obj->selected = false; +// QRectF extents; + + switch (obj->type) + { + case OTLine: + { + Line * l = (Line *)obj; + + if (Global::selection.contains(l->p1.x, l->p1.y) && Global::selection.contains(l->p2.x, l->p2.y)) + l->selected = true; + + break; + } + case OTCircle: + { + Circle * c = (Circle *)obj; + + if (Global::selection.contains(c->p1.x - c->radius, c->p1.y - c->radius) && Global::selection.contains(c->p1.x + c->radius, c->p1.y + c->radius)) + c->selected = true; + + break; + } + case OTArc: + { + Arc * a = (Arc *)obj; + + double start = a->angle1; + double end = start + a->angle2; + QPointF p1(cos(start), sin(start)); + QPointF p2(cos(end), sin(end)); + QRectF bounds(p1, p2); + +#if 1 + // Swap X/Y coordinates if they're backwards... + if (bounds.left() > bounds.right()) + { + double temp = bounds.left(); + bounds.setLeft(bounds.right()); + bounds.setRight(temp); + } + + if (bounds.bottom() > bounds.top()) + { + double temp = bounds.bottom(); + bounds.setBottom(bounds.top()); + bounds.setTop(temp); + } +#else + // Doesn't work as advertised! For shame! + bounds = bounds.normalized(); +#endif + + // If the end of the arc is before the beginning, add 360 degrees to it + if (end < start) + end += 2.0 * PI; + + // Adjust the bounds depending on which axes are crossed + if ((start < PI_OVER_2) && (end > PI_OVER_2)) + bounds.setTop(1.0); + + if ((start < PI) && (end > PI)) + bounds.setLeft(-1.0); + + if ((start < (PI + PI_OVER_2)) && (end > (PI + PI_OVER_2))) + bounds.setBottom(-1.0); + + if ((start < (2.0 * PI)) && (end > (2.0 * PI))) + bounds.setRight(1.0); + + if ((start < ((2.0 * PI) + PI_OVER_2)) && (end > ((2.0 * PI) + PI_OVER_2))) + bounds.setTop(1.0); + + if ((start < (3.0 * PI)) && (end > (3.0 * PI))) + bounds.setLeft(-1.0); + + if ((start < ((3.0 * PI) + PI_OVER_2)) && (end > ((3.0 * PI) + PI_OVER_2))) + bounds.setBottom(-1.0); + + bounds.setTopLeft(QPointF(bounds.left() * a->radius, bounds.top() * a->radius)); + bounds.setBottomRight(QPointF(bounds.right() * a->radius, bounds.bottom() * a->radius)); + bounds.translate(a->p1.x, a->p1.y); + + if (Global::selection.contains(bounds)) + a->selected = true; + + break; + } + default: + break; + } + } + } + // oldPoint = point; //we should keep track of the last point here and only pass this down *if* the point //changed... @@ -551,14 +801,86 @@ selected object last and thus fucks up the algorithm. Need to fix this... toolAction->MouseMoved(point); } #endif + bool needUpdate = false; + + // Don't do this kind of checking unless we're not doing a selection rectangle! + // Hmm, lines don't stay selected if globally selected... !!! FIX !!! + // it's because there were extra state variables, the hit* vars... + if (!Global::selectionInProgress) + { + std::vector::iterator i; + int numHovered = 0; + + for(i=document.objects.begin(); i!=document.objects.end(); i++) + { + Object * obj = (Object *)(*i); +// obj->selected = false; + + switch (obj->type) + { + case OTLine: + { + Line * l = (Line *)obj; + +// bool hitPoint1, hitPoint2, hitLine; + l->hitPoint[0] = l->hitPoint[1] = l->hitObject = false; + Vector lineSegment = l->p2 - l->p1; + Vector v1 = point - l->p1; + Vector v2 = point - l->p2; + double t = Geometry::ParameterOfLineAndPoint(l->p1, l->p2, point); + double distance; + + if (t < 0.0) + distance = v1.Magnitude(); + else if (t > 1.0) + distance = v2.Magnitude(); + else + // distance = ?Det?(ls, v1) / |ls| + distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y) + / lineSegment.Magnitude()); + + if ((v1.Magnitude() * Global::zoom) < 8.0) + { + l->hitPoint[0] = true; +// snapPoint = l->p1; +// snapPointIsValid = true; + } + else if ((v2.Magnitude() * Global::zoom) < 8.0) + { + l->hitPoint[1] = true; +// snapPoint = l->p2; +// snapPointIsValid = true; + } + else if ((distance * Global::zoom) < 5.0) + l->hitObject = true; + + bool oldHovered = l->hovered; + l->hovered = (l->hitPoint[0] || l->hitPoint[1] || l->hitObject ? true : false); + + if (oldHovered != l->hovered) + needUpdate = true; + + break; + } + case OTCircle: + { + Circle * c = (Circle *)obj; + + + break; + } + default: + break; + } + } + } // This is used to draw the tool crosshair... oldPoint = point; -#if 1 - if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/) +// if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/) + if (needUpdate || Global::selectionInProgress) update(); -#endif }