#include "drawingview.h"
#include <stdint.h>
+#include "geometry.h"
#include "global.h"
#include "mathconstants.h"
#include "painter.h"
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)));
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
/*
}
-void DrawingView::RenderObjects(Painter * p, Container * c)
+void DrawingView::RenderObjects(Painter * painter, Container * c)
{
std::vector<void *>::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:
}
#endif
+ // Do checking here to see if object can be selected or not
+ if (Global::selectionInProgress)
+ {
+ std::vector<void *>::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...
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<void *>::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
}
#include "global.h"
#include "vector.h"
-enum ObjectType { OTNone, OTObject, OTLine, OTCircle, OTArc, OTDimension, OTEllipse, OTContainer, OTSpline };
+enum ObjectType { OTNone, OTLine, OTCircle, OTEllipse, OTArc, OTDimension, OTSpline, OTText, OTContainer };
+
+enum DimensionType { DTLinear, DTLinearVert, DTLinearHorz, DTRadial, DTDiametric, DTCircumferential, DTAngular, DTLeader };
+
#define OBJECT_COMMON \
int type; \
uint32_t color; \
float thickness; \
int style; \
- bool selected;
+ bool selected; \
+ bool hovered; \
+ bool hitPoint[4]; \
+ bool hitObject;
struct Line {
OBJECT_COMMON;
Point p2;
Line(): type(OTLine), id(Global::objectID++) {}
- Line(Vector pt1, Vector pt2, float th = 1.0, uint32_t c = 0, int l = 0):
- type(OTLine), id(Global::objectID++), layer(l), color(c), thickness(th),
- style(0), selected(false), p1(pt1), p2(pt2) {}
+ Line(Vector pt1, Vector pt2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+ type(OTLine), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(l), selected(false), hovered(false), p1(pt1), p2(pt2) {}
};
struct Circle {
Point p1;
double radius;
- Circle(Vector pt1, double r, float th = 1.0, uint32_t c = 0, int l = 0):
- type(OTCircle), id(Global::objectID++), layer(l), color(c), thickness(th),
- style(0), selected(false), p1(pt1), radius(r) {}
+ Circle(Vector pt1, double r, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+ type(OTCircle), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(l), selected(false), hovered(false), p1(pt1), radius(r) {}
+};
+
+struct Ellipse {
+ OBJECT_COMMON;
+ Point p1;
+ Point p2;
+ double radius1;
+ double radius2;
+
+ Ellipse(Vector pt1, Vector pt2, double r1, double r2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+ type(OTEllipse), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(l), selected(false), hovered(false), p1(pt1), p2(pt2), radius1(r1), radius2(r2) {}
};
struct Arc {
double angle1;
double angle2;
- Arc(Vector pt1, double r, double a1, double a2, float th = 1.0, uint32_t c = 0, int l = 0):
- type(OTArc), id(Global::objectID++), layer(l), color(c), thickness(th),
- style(0), selected(false), p1(pt1), radius(r), angle1(a1), angle2(a2) {}
+ Arc(Vector pt1, double r, double a1, double a2, float th = 1.0, uint32_t c = 0, int l = LSSolid):
+ type(OTArc), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(l), selected(false), hovered(false), p1(pt1), radius(r), angle1(a1), angle2(a2) {}
+};
+
+struct Dimension {
+ OBJECT_COMMON;
+ int subtype;
+ Point p1;
+ Point p2;
+ double offset;
+
+ Dimension(Vector pt1, Vector pt2, DimensionType dt = DTLinear, float th = 1.0, uint32_t c = 0x0000FF, int l = LSSolid):
+ type(OTDimension), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(l), selected(false), hovered(false), subtype(dt), p1(pt1), p2(pt2) {}
};
struct Text {
OBJECT_COMMON;
Point p1;
std::string s;
+
+ Text(Vector pt, char * str, float th = 10.0, uint32_t c = 0):
+ type(OTText), id(Global::objectID++), layer(0), color(c), thickness(th),
+ style(LSSolid), selected(false), hovered(false), p1(pt), s(str) {}
};
struct Container {
std::vector<void *> objects;
double angle;
double scale;
-};
-struct Dimension {
- OBJECT_COMMON;
- int subtype;
- Point p1;
- Point p2;
- double offset;
+ Container(): type(OTContainer), id(Global::objectID++), selected(false), hovered(false) {}
};
struct Object {
projects / architektonas / commitdiff