// JLH = James Hammons <jlhamm@acm.org>
//
// Who When What
-// --- ---------- -------------------------------------------------------------
+// --- ---------- ------------------------------------------------------------
// JLH 03/22/2011 Created this file
// JLH 09/29/2011 Added middle mouse button panning
//
//
// STILL TO BE DONE:
//
+// - Lots of stuff
+// - Layer locking (hiding works)
//
// Uncomment this for debugging...
#include "drawingview.h"
#include <stdint.h>
+#include "geometry.h"
+#include "global.h"
#include "mathconstants.h"
-
-#include "arc.h"
-#include "circle.h"
-#include "dimension.h"
-#include "line.h"
#include "painter.h"
+#include "structs.h"
+#include "utils.h"
#define BACKGROUND_MAX_SIZE 512
DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
// The value in the settings file will override this.
- useAntialiasing(true),
+ useAntialiasing(true), /*numSelected(0),*/ numHovered(0), shiftDown(false),
+ ctrlDown(false),
gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
- scale(1.0), offsetX(-10), offsetY(-10),
- document(Vector(0, 0)),
- /*gridSpacing(12.0),*/ gridPixels(0), collided(false), rotateTool(false),
- rx(150.0), ry(150.0),
-// scrollDrag(false), addLineTool(false), addCircleTool(false),
-// addDimensionTool(false),
- toolAction(NULL)
-{
- document.isTopLevelContainer = true;
+ scale(1.0), offsetX(-10), offsetY(-10), document(true),
+ gridPixels(0), collided(false), hoveringIntersection(false)
+{
+//wtf? doesn't work except in c++11??? document = { 0 };
setBackgroundRole(QPalette::Base);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- Object::gridSpacing = 12.0;
-// toolPalette = new ToolWindow();
-// CreateCursors();
-// setCursor(cur[TOOLSelect]);
-// setMouseTracking(true);
+ Global::gridSpacing = 12.0; // In base units (inch is default)
+#if 0
Line * line = new Line(Vector(5, 5), Vector(50, 40), &document);
document.Add(line);
document.Add(new Line(Vector(50, 40), Vector(10, 83), &document));
// Alternate way to do the above...
line->SetDimensionOnLine();
#endif
+#else
+ Line * line = new Line;//(Vector(5, 5), Vector(50, 40), &document);
+ line->p[0] = Vector(5, 5);
+ line->p[1] = Vector(50, 40);
+ line->type = OTLine;
+ line->thickness = 2.0;
+ line->style = LSDash;
+ line->color = 0xFF7F00;
+ line->layer = 0;
+ 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(100, 100), 36));
+ document.objects.push_back(new Circle(Vector(50, 150), 49));
+ document.objects.push_back(new Arc(Vector(300, 300), 32, TAU / 8.0, TAU * 0.65)),
+ document.objects.push_back(new Arc(Vector(200, 200), 60, TAU / 4.0, TAU * 0.75));
+ document.objects.push_back(new Dimension(Vector(50, 40), Vector(5, 5)));
+ document.objects.push_back(new Text(Vector(10, 83), "Here is some awesome text!"));
+#endif
/*
Here we set the grid size in pixels--12 in this case. Initially, we have our
The drawing enforces the grid spacing through the drawing->gridSpacing variable.
- drawing->gridSpacing = 12.0 / Painter::zoom;
+ drawing->gridSpacing = 12.0 / Global::zoom;
-Painter::zoom is the zoom factor for the drawing, and all mouse clicks are
-translated to Cartesian coordinates through this. (Initially, Painter::zoom is
+Global::zoom is the zoom factor for the drawing, and all mouse clicks are
+translated to Cartesian coordinates through this. (Initially, Global::zoom is
set to 1.0. SCREEN_ZOOM is set to 1.0/4.0.)
Really, the 100% zoom level can be set at *any* zoom level, it's more of a
convenience function than any measure of absolutes. Doing things that way we
could rid ourselves of the whole SCREEN_ZOOM parameter and all the attendant
-shittyness that comes with it.
+shittiness that comes with it.
However, it seems that SCREEN_ZOOM is used to make text and arrow sizes show up
a certain way, which means we should probably create something else in those
this. Maybe this is the case for having a base unit and basing point sizes off
of that.
-Here's what's been figured out. Painter::zoom is simply the ratio of pixels to
+Here's what's been figured out. Global::zoom is simply the ratio of pixels to
base units. What that means is that if you have a 12px grid with a 6" grid size
-(& base unit of "inches"), Painter::zoom becomes 12px / 6" = 2.0 px/in.
+(& base unit of "inches"), Global::zoom becomes 12px / 6" = 2.0 px/in.
Dimensions now have a "size" parameter to set their absolute size in relation
to the base unit. ATM, the arrows are drawn in pixels, but also scaled by
-Painter::zoom *and* size. Same with the dimension text; it's drawn at 10pt and
+Global::zoom *and* size. Same with the dimension text; it's drawn at 10pt and
scaled the same way as the arrowheads.
Need a way to scale line widths as well. :-/ Shouldn't be too difficult, just
we do! :-)
*/
- SetGridSize(12);
-}
-
-
-void DrawingView::SetRotateToolActive(bool state/*= true*/)
-{
- rotateTool = state;
- update();
-}
-
-
-void DrawingView::SetToolActive(Action * action)
-{
- if (action != NULL)
- {
- toolAction = action;
- connect(toolAction, SIGNAL(ObjectReady(Object *)), this,
- SLOT(AddNewObjectToDocument(Object *)));
- }
+ SetGridSize(12); // This is in pixels
}
pmp.end();
// Set up new BG brush & zoom level (pixels per base unit)
-// Painter::zoom = gridPixels / gridSpacing;
- Painter::zoom = gridPixels / Object::gridSpacing;
+ Global::zoom = gridPixels / Global::gridSpacing;
UpdateGridBackground();
}
}
-void DrawingView::AddNewObjectToDocument(Object * object)
+//
+// Basically, we just make a single pass through the Container. If the layer #
+// is less than the layer # being deleted, then do nothing. If the layer # is
+// equal to the layer # being deleted, then delete the object. If the layer #
+// is greater than the layer # being deleted, then set the layer # to its layer
+// # - 1.
+//
+void DrawingView::DeleteCurrentLayer(int layer)
{
- if (object)
+//printf("DrawingView::DeleteCurrentLayer(): currentLayer = %i\n", layer);
+ std::vector<void *>::iterator i = document.objects.begin();
+
+ while (i != document.objects.end())
{
- object->Reparent(&document);
- document.Add(object);
- update();
+ Object * obj = (Object *)(*i);
+
+ if (obj->layer < layer)
+ i++;
+ else if (obj->layer == layer)
+ {
+ document.objects.erase(i);
+ delete obj;
+ }
+ else
+ {
+ obj->layer--;
+ i++;
+ }
}
-//printf("DrawingView::AddNewObjectToDocument(). object=%08X\n", object);
+
+ // We've just done a destructive action, so update the screen!
+ update();
+}
+
+
+void DrawingView::HandleLayerToggle(void)
+{
+ // A layer's visibility was toggled, so update the screen...
+ update();
}
-void DrawingView::SetCurrentLayer(int layer)
+//
+// A layer was moved up or down in the layer list, so we have to swap the
+// document's object's layer numbers in the layers that were swapped.
+//
+void DrawingView::HandleLayerSwap(int layer1, int layer2)
{
- Object::currentLayer = layer;
-//printf("DrawingView::CurrentLayer = %i\n", layer);
+//printf("DrawingView: Swapping layers %i and %i.\n", layer1, layer2);
+ std::vector<void *>::iterator i;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
+ {
+ Object * obj = (Object *)(*i);
+
+ if (obj->layer == layer1)
+ obj->layer = layer2;
+ else if (obj->layer == layer2)
+ obj->layer = layer1;
+ }
}
QPoint DrawingView::GetAdjustedMousePosition(QMouseEvent * event)
{
- // This is undoing the transform, e.g. going from client coords to local coords.
- // In essence, the height - y is height + (y * -1), the (y * -1) term doing the
- // conversion of the y-axis from increasing bottom to top.
+ // This is undoing the transform, e.g. going from client coords to local
+ // coords. In essence, the height - y is height + (y * -1), the (y * -1)
+ // term doing the conversion of the y-axis from increasing bottom to top.
return QPoint(offsetX + event->x(), offsetY + (size().height() - event->y()));
}
{
// VOODOO ALERT (ON Y COMPONENT!!!!) (eh?)
// No voodoo here, it's just grouped wrong to see it. It should be:
- // -offsetY + (size.height() + (y * -1.0)) <-- this is wrong, offsetY should be positive
+ // -offsetY + (size.height() + (y * -1.0)) <-- this is wrong, offsetY should be positive [why? we use -offsetX after all]
return QPoint(-offsetX + x, (size().height() - (-offsetY + y)) * +1.0);
}
-#if 0
-//
-// This looks strange, but it's really quite simple: We want a point that's
-// more than half-way to the next grid point to snap there while conversely we
-// want a point that's less than half-way to to the next grid point then snap
-// to the one before it. So we add half of the grid spacing to the point, then
-// divide by it so that we can remove the fractional part, then multiply it
-// back to get back to the correct answer.
-//
-Vector DrawingView::SnapPointToGrid(Vector point)
-{
- point += gridSpacing / 2.0; // *This* adds to Z!!!
- point /= gridSpacing;
- point.x = floor(point.x);//need to fix this for negative numbers...
- point.y = floor(point.y);
- point.z = 0; // Make *sure* Z doesn't go anywhere!!!
- point *= gridSpacing;
- return point;
-}
-#endif
-
-
void DrawingView::paintEvent(QPaintEvent * /*event*/)
{
QPainter qtPainter(this);
if (useAntialiasing)
qtPainter.setRenderHint(QPainter::Antialiasing);
-// Painter::screenSize = Vector(size().width(), size().height());
- Object::SetViewportHeight(size().height());
+ Global::viewportHeight = size().height();
// Draw coordinate axes
-
painter.SetPen(QPen(Qt::blue, 1.0, Qt::DotLine));
painter.DrawLine(0, -16384, 0, 16384);
painter.DrawLine(-16384, 0, 16384, 0);
- // Draw supplemental (tool related) points
-// NOTE that this can be done as an action!
-// In that case, we would need access to the document...
-// [We can do that by making the document a class object...]
- if (rotateTool)
+ // Do object rendering...
+ for(int i=0; i<Global::numLayers; i++)
{
- painter.SetPen(QPen(QColor(0, 200, 0), 2.0, Qt::SolidLine));
- painter.DrawLine(rx - 10, ry, rx + 10, ry);
- painter.DrawLine(rx, ry - 10, rx, ry + 10);
+ if (Global::layerHidden[i] == false)
+ RenderObjects(&painter, document.objects, i);
}
-// Maybe we can make the grid into a background brush instead, and let Qt deal
-// with it??? YES!!
-
- // The top level document takes care of rendering for us...
- document.Draw(&painter);
-
- if (toolAction)
+ // Do tool rendering, if any...
+ if (Global::tool)
{
-// painter.SetPen(QPen(Qt::green, 1.0, Qt::DashLine));
painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
painter.DrawCrosshair(oldPoint);
- toolAction->Draw(&painter);
+ ToolDraw(&painter);
}
- if (Object::selectionInProgress)
+ // Do selection rectangle rendering, if any
+ if (Global::selectionInProgress)
{
-// painter.SetPen(QPen(Qt::green, 1.0, Qt::SolidLine));
painter.SetPen(QPen(QColor(255, 127, 0, 255)));
-// painter.SetBrush(QBrush(Qt::NoBrush));
painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
- painter.DrawRect(Object::selection);
+ painter.DrawRect(Global::selection);
+ }
+
+ if (hoveringIntersection)
+ painter.DrawHandle(intersectionPoint);
+
+ if (!informativeText.isEmpty())
+ painter.DrawInformativeText(informativeText);
+}
+
+
+//
+// Renders objects in the passed in vector
+//
+void DrawingView::RenderObjects(Painter * painter, std::vector<void *> & v, int layer, bool ignoreLayer/*= false*/)
+{
+ std::vector<void *>::iterator i;
+
+ for(i=v.begin(); i!=v.end(); i++)
+ {
+ Object * obj = (Object *)(*i);
+ float scaledThickness = Global::scale * obj->thickness;
+
+ // If the object isn't on the current layer being drawn, skip it
+ if (!ignoreLayer && (obj->layer != layer))
+ continue;
+
+ if ((Global::tool == TTRotate) && ctrlDown && obj->selected)
+ {
+ painter->SetPen(0x00FF00, 2.0, LSSolid);
+ }
+ else
+ {
+ painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
+ painter->SetBrush(obj->color);
+
+ if (obj->selected || obj->hitObject)
+ painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash);
+ }
+
+ switch (obj->type)
+ {
+ case OTLine:
+ painter->DrawLine(obj->p[0], obj->p[1]);
+
+ if (obj->hitPoint[0])
+ painter->DrawHandle(obj->p[0]);
+
+ if (obj->hitPoint[1])
+ painter->DrawHandle(obj->p[1]);
+
+ break;
+ case OTCircle:
+ painter->SetBrush(QBrush(Qt::NoBrush));
+ painter->DrawEllipse(obj->p[0], obj->radius[0], obj->radius[0]);
+
+ if (obj->hitPoint[0])
+ painter->DrawHandle(obj->p[0]);
+
+ break;
+ case OTArc:
+ painter->DrawArc(obj->p[0], obj->radius[0], obj->angle[0], obj->angle[1]);
+
+ if (obj->hitPoint[0])
+ painter->DrawHandle(obj->p[0]);
+
+ if (obj->hitPoint[1])
+ painter->DrawHandle(obj->p[0] + (Vector(cos(obj->angle[0]), sin(obj->angle[0])) * obj->radius[0]));
+
+ if (obj->hitPoint[2])
+ painter->DrawHandle(obj->p[0] + (Vector(cos(obj->angle[0] + obj->angle[1]), sin(obj->angle[0] + obj->angle[1])) * obj->radius[0]));
+
+ break;
+ case OTDimension:
+ {
+ Dimension * d = (Dimension *)obj;
+
+ Vector v(d->p[0], d->p[1]);
+ double angle = v.Angle();
+ Vector unit = v.Unit();
+ Vector linePt1 = d->p[0], linePt2 = d->p[1];
+ Vector ortho;
+ double x1, y1, length;
+
+ if (d->subtype == DTLinearVert)
+ {
+ if ((angle < 0) || (angle > HALF_TAU))
+ {
+ x1 = (d->p[0].x > d->p[1].x ? d->p[0].x : d->p[1].x);
+ y1 = (d->p[0].y > d->p[1].y ? d->p[0].y : d->p[1].y);
+ ortho = Vector(1.0, 0);
+ angle = THREE_QTR_TAU;
+ }
+ else
+ {
+ x1 = (d->p[0].x > d->p[1].x ? d->p[1].x : d->p[0].x);
+ y1 = (d->p[0].y > d->p[1].y ? d->p[1].y : d->p[0].y);
+ ortho = Vector(-1.0, 0);
+ angle = QTR_TAU;
+ }
+
+ linePt1.x = linePt2.x = x1;
+ length = fabs(d->p[0].y - d->p[1].y);
+ }
+ else if (d->subtype == DTLinearHorz)
+ {
+ if ((angle < QTR_TAU) || (angle > THREE_QTR_TAU))
+ {
+ x1 = (d->p[0].x > d->p[1].x ? d->p[0].x : d->p[1].x);
+ y1 = (d->p[0].y > d->p[1].y ? d->p[0].y : d->p[1].y);
+ ortho = Vector(0, 1.0);
+ angle = 0;
+ }
+ else
+ {
+ x1 = (d->p[0].x > d->p[1].x ? d->p[1].x : d->p[0].x);
+ y1 = (d->p[0].y > d->p[1].y ? d->p[1].y : d->p[0].y);
+ ortho = Vector(0, -1.0);
+ angle = HALF_TAU;
+ }
+
+ linePt1.y = linePt2.y = y1;
+ length = fabs(d->p[0].x - d->p[1].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->p[0] + (ortho * 4.0 * scaledThickness);
+ Point p6 = d->p[1] + (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));
+
+ // 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);
+
+ 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);
+ }
+
+ painter->DrawAngledText(ctr, angle, dimText, scaledThickness);
+
+ break;
+ }
+ case OTText:
+ {
+ Text * t = (Text *)obj;
+ painter->DrawTextObject(t->p[0], t->s.c_str(), scaledThickness);
+ break;
+ }
+ case OTSpline:
+ {
+ break;
+ }
+ case OTPolygon:
+ {
+ break;
+ }
+ case OTContainer:
+ {
+ // Containers require recursive rendering...
+ Container * c = (Container *)obj;
+ RenderObjects(painter, (*c).objects, layer);
+
+//printf("Container extents: <%lf, %lf>, <%lf, %lf>\nsize: %i\n", r.l, r.t, r.r, r.b, c->objects.size());
+ // Containers also have special indicators showing they are selected
+ if (c->selected || c->hitObject)
+ {
+ Rect r = GetObjectExtents(obj);
+ painter->DrawRectCorners(r);
+ }
+
+ break;
+ }
+ default:
+ break;
+ }
+ }
+}
+
+
+void DrawingView::AddHoveredToSelection(void)
+{
+ std::vector<void *>::iterator i;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
+ {
+ if (((Object *)(*i))->hovered)
+ ((Object *)(*i))->selected = true;
+ }
+}
+
+
+void DrawingView::GetSelection(std::vector<void *> & v)
+{
+ v.clear();
+ std::vector<void *>::iterator i;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
+ {
+ if (((Object *)(*i))->selected)
+ v.push_back(*i);
+ }
+}
+
+
+void DrawingView::GetHovered(std::vector<void *> & v)
+{
+ v.clear();
+ std::vector<void *>::iterator i;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
+ {
+ if (((Object *)(*i))->hovered)
+// {
+//printf("GetHovered: adding object (%X) to hover... hp1=%s, hp2=%s, hl=%s\n", (*i), (((Line *)(*i))->hitPoint[0] ? "true" : "false"), (((Line *)(*i))->hitPoint[1] ? "true" : "false"), (((Line *)(*i))->hitObject ? "true" : "false"));
+ v.push_back(*i);
+// }
}
}
void DrawingView::resizeEvent(QResizeEvent * /*event*/)
{
- Painter::screenSize = Vector(size().width(), size().height());
+ Global::screenSize = Vector(size().width(), size().height());
UpdateGridBackground();
}
-void DrawingView::mousePressEvent(QMouseEvent * event)
+void DrawingView::ToolHandler(int mode, Point p)
{
- if (event->button() == Qt::LeftButton)
+ if (Global::tool == TTLine)
+ LineHandler(mode, p);
+ else if (Global::tool == TTCircle)
+ CircleHandler(mode, p);
+ else if (Global::tool == TTArc)
+ ArcHandler(mode, p);
+ else if (Global::tool == TTRotate)
+ RotateHandler(mode, p);
+ else if (Global::tool == TTMirror)
+ MirrorHandler(mode, p);
+}
+
+
+void DrawingView::ToolDraw(Painter * painter)
+{
+ if (Global::tool == TTLine)
{
- Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
+ if (Global::toolState == TSNone)
+ {
+ painter->DrawHandle(toolPoint[0]);
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ painter->DrawHandle(toolPoint[1]);
+ }
+ else
+ {
+ painter->DrawLine(toolPoint[0], toolPoint[1]);
+ painter->DrawHandle(toolPoint[1]);
+
+ Vector v(toolPoint[0], toolPoint[1]);
+ double absAngle = v.Angle() * RADIANS_TO_DEGREES;
+ double absLength = v.Magnitude();
+ QString text = tr("Length: %1 in.\n") + QChar(0x2221) + tr(": %2");
+ informativeText = text.arg(absLength).arg(absAngle);
+ }
+ }
+ else if (Global::tool == TTCircle)
+ {
+ if (Global::toolState == TSNone)
+ {
+ painter->DrawHandle(toolPoint[0]);
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ painter->DrawHandle(toolPoint[1]);
+ }
+ else
+ {
+ painter->DrawCross(toolPoint[0]);
+ double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+ painter->SetBrush(QBrush(Qt::NoBrush));
+ painter->DrawEllipse(toolPoint[0], length, length);
+ QString text = tr("Radius: %1 in.");
+ informativeText = text.arg(length);
+ }
+ }
+ else if (Global::tool == TTArc)
+ {
+ if (Global::toolState == TSNone)
+ {
+ painter->DrawHandle(toolPoint[0]);
+ }
+ else if (Global::toolState == TSPoint2)
+ {
+ double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+ painter->SetBrush(QBrush(Qt::NoBrush));
+ painter->DrawEllipse(toolPoint[0], length, length);
+ painter->DrawLine(toolPoint[0], toolPoint[1]);
+ painter->DrawHandle(toolPoint[1]);
+ QString text = tr("Radius: %1 in.");
+ informativeText = text.arg(length);
+ }
+ else if (Global::toolState == TSPoint3)
+ {
+ double angle = Vector::Angle(toolPoint[0], toolPoint[2]);
+ painter->DrawLine(toolPoint[0], toolPoint[2]);
+ painter->SetBrush(QBrush(Qt::NoBrush));
+ painter->DrawEllipse(toolPoint[0], toolPoint[1].x, toolPoint[1].x);
+ painter->DrawHandle(toolPoint[0] + (Vector(cos(angle), sin(angle)) * toolPoint[1].x));
+ QString text = tr("Angle start: %1") + QChar(0x00B0);
+ informativeText = text.arg(RADIANS_TO_DEGREES * angle);
+ }
+ else
+ {
+ double angle = Vector::Angle(toolPoint[0], toolPoint[3]);
+ double span = angle - toolPoint[2].x;
+
+ if (span < 0)
+ span += TAU;
+
+ painter->DrawLine(toolPoint[0], toolPoint[3]);
+ painter->SetBrush(QBrush(Qt::NoBrush));
+ painter->DrawEllipse(toolPoint[0], toolPoint[1].x, toolPoint[1].x);
+ painter->SetPen(0xFF00FF, 2.0, LSSolid);
+ painter->DrawArc(toolPoint[0], toolPoint[1].x, toolPoint[2].x, span);
+ painter->DrawHandle(toolPoint[0] + (Vector(cos(angle), sin(angle)) * toolPoint[1].x));
+ QString text = tr("Arc span: %1") + QChar(0x00B0);
+ informativeText = text.arg(RADIANS_TO_DEGREES * span);
+ }
+ }
+ else if (Global::tool == TTRotate)
+ {
+ if ((Global::toolState == TSNone) || (Global::toolState == TSPoint1))
+ painter->DrawHandle(toolPoint[0]);
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ painter->DrawHandle(toolPoint[1]);
+ else
+ {
+ if (toolPoint[0] == toolPoint[1])
+ return;
-// Problem with this: Can't select stuff very well with the snap grid on.
-// Completely screws things up, as sometimes things don't fall on the grid.
-/*
-So, how to fix this? Have the Object check itself?
-Maybe we can fix this by having the initial point not be snapped, but when there's
-a drag, we substitute the snapped point 'oldPoint' which the Object keeps track of
-internally to know how far it was dragged...
+ painter->DrawLine(toolPoint[0], toolPoint[1]);
-Now we do... :-/
-*/
-#if 0
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
-#endif
+ double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
+ QString text = QChar(0x2221) + QObject::tr(": %1");
+ informativeText = text.arg(absAngle);
+
+ if (ctrlDown)
+ informativeText += " (Copy)";
+ }
+ }
+ else if (Global::tool == TTMirror)
+ {
+ if ((Global::toolState == TSNone) || (Global::toolState == TSPoint1))
+ painter->DrawHandle(toolPoint[0]);
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ painter->DrawHandle(toolPoint[1]);
+ else
+ {
+ if (toolPoint[0] == toolPoint[1])
+ return;
+
+ Point mirrorPoint = toolPoint[0] + Vector(toolPoint[1], toolPoint[0]);
+ painter->DrawLine(mirrorPoint, toolPoint[1]);
+
+ double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
- collided = document.Collided(point);
+ if (absAngle > 180.0)
+ absAngle -= 180.0;
- if (collided)
- update(); // Do an update if collided with at least *one* object in the document
+ QString text = QChar(0x2221) + QObject::tr(": %1");
+ informativeText = text.arg(absAngle);
- if (toolAction)
+ if (ctrlDown)
+ informativeText += " (Copy)";
+ }
+ }
+}
+
+
+void DrawingView::LineHandler(int mode, Point p)
+{
+ switch (mode)
+ {
+ case ToolMouseDown:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseMove:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseUp:
+ if (Global::toolState == TSNone)
{
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
+ Global::toolState = TSPoint2;
+ // Prevent spurious line from drawing...
+ toolPoint[1] = toolPoint[0];
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ // Key override is telling us to make a new line, not continue the
+ // previous one.
+ toolPoint[0] = toolPoint[1];
+ }
+ else
+ {
+ Line * l = new Line(toolPoint[0], toolPoint[1]);
+ l->layer = Global::activeLayer;
+ document.objects.push_back(l);
+ toolPoint[0] = toolPoint[1];
+ }
+ }
+}
+
- toolAction->MouseDown(point);
+void DrawingView::CircleHandler(int mode, Point p)
+{
+ switch (mode)
+ {
+ case ToolMouseDown:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseMove:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseUp:
+ if (Global::toolState == TSNone)
+ {
+ Global::toolState = TSPoint2;
+ // Prevent spurious line from drawing...
+ toolPoint[1] = toolPoint[0];
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ // Key override is telling us to make a new line, not continue the
+ // previous one.
+ toolPoint[0] = toolPoint[1];
+ }
+ else
+ {
+ double length = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+ Circle * c = new Circle(toolPoint[0], length);
+ c->layer = Global::activeLayer;
+ document.objects.push_back(c);
+ toolPoint[0] = toolPoint[1];
+ Global::toolState = TSNone;
}
+ }
+}
- // Didn't hit any object and not using a tool, so do a selection rectangle
- if (!(collided || toolAction))
+
+void DrawingView::ArcHandler(int mode, Point p)
+{
+ switch (mode)
+ {
+ case ToolMouseDown:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else if (Global::toolState == TSPoint2)
+ toolPoint[1] = p;
+ else if (Global::toolState == TSPoint3)
+ toolPoint[2] = p;
+ else
+ toolPoint[3] = p;
+
+ break;
+ case ToolMouseMove:
+ if (Global::toolState == TSNone)
+ toolPoint[0] = p;
+ else if (Global::toolState == TSPoint2)
+ toolPoint[1] = p;
+ else if (Global::toolState == TSPoint3)
+ toolPoint[2] = p;
+ else
+ toolPoint[3] = p;
+
+ break;
+ case ToolMouseUp:
+ if (Global::toolState == TSNone)
+ {
+ // Prevent spurious line from drawing...
+ toolPoint[1] = toolPoint[0];
+ Global::toolState = TSPoint2;
+ }
+ else if (Global::toolState == TSPoint2)
+ {
+ if (shiftDown)
+ {
+ // Key override is telling us to start circle at new center, not
+ // continue the current one.
+ toolPoint[0] = toolPoint[1];
+ return;
+ }
+
+ // Set the radius in toolPoint[1].x
+ toolPoint[1].x = Vector::Magnitude(toolPoint[0], toolPoint[1]);
+ Global::toolState = TSPoint3;
+ }
+ else if (Global::toolState == TSPoint3)
+ {
+ // Set the angle in toolPoint[2].x
+ toolPoint[2].x = Vector::Angle(toolPoint[0], toolPoint[2]);
+ Global::toolState = TSPoint4;
+ }
+ else
+ {
+ double endAngle = Vector::Angle(toolPoint[0], toolPoint[3]);
+ double span = endAngle - toolPoint[2].x;
+
+ if (span < 0)
+ span += TAU;
+
+ Arc * arc = new Arc(toolPoint[0], toolPoint[1].x, toolPoint[2].x, span);
+ arc->layer = Global::activeLayer;
+ document.objects.push_back(arc);
+ Global::toolState = TSNone;
+ }
+ }
+}
+
+
+void DrawingView::RotateHandler(int mode, Point p)
+{
+ switch (mode)
+ {
+ case ToolMouseDown:
+ if (Global::toolState == TSNone)
+ {
+ toolPoint[0] = p;
+ SavePointsFrom(select, toolScratch);
+ Global::toolState = TSPoint1;
+ }
+ else if (Global::toolState == TSPoint1)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseMove:
+ if ((Global::toolState == TSPoint1) || (Global::toolState == TSNone))
+ toolPoint[0] = p;
+ else if (Global::toolState == TSPoint2)
+ {
+ toolPoint[1] = p;
+
+ if (shiftDown)
+ return;
+
+ double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+ std::vector<void *>::iterator j = select.begin();
+ std::vector<Object>::iterator i = toolScratch.begin();
+
+ for(; i!=toolScratch.end(); i++, j++)
+ {
+ Object obj = *i;
+ Point p1 = Geometry::RotatePointAroundPoint(obj.p[0], toolPoint[0], angle);
+ Point p2 = Geometry::RotatePointAroundPoint(obj.p[1], toolPoint[0], angle);
+ Object * obj2 = (Object *)(*j);
+ obj2->p[0] = p1;
+ obj2->p[1] = p2;
+
+ if (obj.type == OTArc)
+ {
+ obj2->angle[0] = obj.angle[0] + angle;
+
+ if (obj2->angle[0] > TAU)
+ obj2->angle[0] -= TAU;
+ }
+ }
+ }
+
+ break;
+ case ToolMouseUp:
+ if (Global::toolState == TSPoint1)
+ {
+ Global::toolState = TSPoint2;
+ // Prevent spurious line from drawing...
+ toolPoint[1] = toolPoint[0];
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ // Key override is telling us to make a new line, not continue the
+ // previous one.
+ toolPoint[0] = toolPoint[1];
+ }
+ else
+ {
+ // Either we're finished with our rotate, or we're stamping a copy.
+ if (ctrlDown)
+ {
+ // Stamp a copy of the selection at the current rotation & bail
+ std::vector<void *> temp;
+ CopyObjects(select, temp);
+ ClearSelected(temp);
+ AddObjectsTo(document.objects, temp);
+ RestorePointsTo(select, toolScratch);
+ return;
+ }
+
+ toolPoint[0] = p;
+ Global::toolState = TSPoint1;
+ SavePointsFrom(select, toolScratch);
+ }
+
+ break;
+ case ToolKeyDown:
+ // Reset the selection if shift held down...
+ if (shiftDown)
+ RestorePointsTo(select, toolScratch);
+
+ break;
+ case ToolKeyUp:
+ // Reset selection when key is let up
+ if (!shiftDown)
+ RotateHandler(ToolMouseMove, toolPoint[1]);
+
+ break;
+ case ToolCleanup:
+ RestorePointsTo(select, toolScratch);
+ }
+}
+
+
+void DrawingView::MirrorHandler(int mode, Point p)
+{
+ switch (mode)
+ {
+ case ToolMouseDown:
+ if (Global::toolState == TSNone)
+ {
+ toolPoint[0] = p;
+ SavePointsFrom(select, toolScratch);
+ Global::toolState = TSPoint1;
+ }
+ else if (Global::toolState == TSPoint1)
+ toolPoint[0] = p;
+ else
+ toolPoint[1] = p;
+
+ break;
+ case ToolMouseMove:
+ if ((Global::toolState == TSPoint1) || (Global::toolState == TSNone))
+ toolPoint[0] = p;
+ else if (Global::toolState == TSPoint2)
+ {
+ toolPoint[1] = p;
+
+ if (shiftDown)
+ return;
+
+ double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+ std::vector<void *>::iterator j = select.begin();
+ std::vector<Object>::iterator i = toolScratch.begin();
+
+ for(; i!=toolScratch.end(); i++, j++)
+ {
+ Object obj = *i;
+ Point p1 = Geometry::MirrorPointAroundLine(obj.p[0], toolPoint[0], toolPoint[1]);
+ Point p2 = Geometry::MirrorPointAroundLine(obj.p[1], toolPoint[0], toolPoint[1]);
+ Object * obj2 = (Object *)(*j);
+ obj2->p[0] = p1;
+ obj2->p[1] = p2;
+
+ if (obj.type == OTArc)
+ {
+ // This is 2*mirror angle - obj angle - obj span
+ obj2->angle[0] = (2.0 * angle) - obj.angle[0] - obj.angle[1];
+
+ if (obj2->angle[0] > TAU)
+ obj2->angle[0] -= TAU;
+ }
+ }
+ }
+
+ break;
+ case ToolMouseUp:
+ if (Global::toolState == TSPoint1)
+ {
+ Global::toolState = TSPoint2;
+ // Prevent spurious line from drawing...
+ toolPoint[1] = toolPoint[0];
+ }
+ else if ((Global::toolState == TSPoint2) && shiftDown)
+ {
+ // Key override is telling us to make a new line, not continue the
+ // previous one.
+ toolPoint[0] = toolPoint[1];
+ }
+ else
+ {
+ // Either we're finished with our rotate, or we're stamping a copy.
+ if (ctrlDown)
+ {
+ // Stamp a copy of the selection at the current rotation & bail
+ std::vector<void *> temp;
+ CopyObjects(select, temp);
+ ClearSelected(temp);
+ AddObjectsTo(document.objects, temp);
+ RestorePointsTo(select, toolScratch);
+ return;
+ }
+
+ toolPoint[0] = p;
+ Global::toolState = TSPoint1;
+ SavePointsFrom(select, toolScratch);
+ }
+
+ break;
+ case ToolKeyDown:
+ // Reset the selection if shift held down...
+ if (shiftDown)
+ RestorePointsTo(select, toolScratch);
+
+ break;
+ case ToolKeyUp:
+ // Reset selection when key is let up
+ if (!shiftDown)
+ MirrorHandler(ToolMouseMove, toolPoint[1]);
+
+ break;
+ case ToolCleanup:
+ RestorePointsTo(select, toolScratch);
+ }
+}
+
+
+void DrawingView::mousePressEvent(QMouseEvent * event)
+{
+ if (event->button() == Qt::LeftButton)
+ {
+ Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
+
+ // Handle tool processing, if any
+ if (Global::tool)
{
- Object::selectionInProgress = true;
- Object::selection.setTopLeft(QPointF(point.x, point.y));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ if (hoveringIntersection)
+ point = intersectionPoint;
+ else if (Global::snapToGrid)
+ point = SnapPointToGrid(point);
+
+ //Also, may want to figure out if hovering over a snap point on an object,
+ //snap to grid if not.
+ // Snap to object point if valid...
+// if (Global::snapPointIsValid)
+// point = Global::snapPoint;
+
+ ToolHandler(ToolMouseDown, point);
+ return;
}
+
+ // Clear the selection only if CTRL isn't being held on click
+ if (!ctrlDown)
+ ClearSelected(document.objects);
+// ClearSelection();
+
+ // If any objects are being hovered on click, add them to the selection
+ // & return
+ if (numHovered > 0)
+ {
+ AddHoveredToSelection();
+ update(); // needed??
+ GetHovered(hover); // prolly needed
+
+ // Needed for grab & moving objects
+ // We do it *after*... why? (doesn't seem to confer any advantage...)
+ if (hoveringIntersection)
+ oldPoint = intersectionPoint;
+ else if (Global::snapToGrid)
+ oldPoint = SnapPointToGrid(point);
+
+ return;
+ }
+
+ // Didn't hit any object and not using a tool, so do a selection rectangle
+ Global::selectionInProgress = true;
+ Global::selection.setTopLeft(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
}
else if (event->button() == Qt::MiddleButton)
{
void DrawingView::mouseMoveEvent(QMouseEvent * event)
{
Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
+ // Only needs to be done here, as mouse down is always preceded by movement
+ Global::snapPointIsValid = false;
+ hoveringIntersection = false;
+ // Scrolling...
if (event->buttons() & Qt::MiddleButton)
{
point = Vector(event->x(), event->y());
- // Since we're using Qt coords for scrolling, we have to adjust them here to
- // conform to Cartesian coords, since the origin is using Cartesian. :-)
- Vector delta(point, oldPoint);
- delta /= Painter::zoom;
+ // Since we're using Qt coords for scrolling, we have to adjust them
+ // here to conform to Cartesian coords, since the origin is using
+ // Cartesian. :-)
+ Vector delta(oldPoint, point);
+ delta /= Global::zoom;
delta.y = -delta.y;
- Painter::origin -= delta;
+ Global::origin -= delta;
UpdateGridBackground();
update();
return;
}
- // Grid processing...
- if ((event->buttons() & Qt::LeftButton) && Object::snapToGrid)
+ // If we're doing a selection rect, see if any objects are engulfed by it
+ // (implies left mouse button held down)
+ if (Global::selectionInProgress)
{
- point = Object::SnapPointToGrid(point);
+ CheckObjectBounds();
+ update();
+ return;
}
- oldPoint = point;
-//we should keep track of the last point here and only pass this down *if* the point
-//changed...
- document.PointerMoved(point);
+ // Handle object movement (left button down & over an object)
+ if ((event->buttons() & Qt::LeftButton) && numHovered && !Global::tool)
+ {
+ if (hoveringIntersection)
+ point = intersectionPoint;
+ else if (Global::snapToGrid)
+ point = SnapPointToGrid(point);
- if (document.NeedsUpdate() || Object::selectionInProgress)
+ HandleObjectMovement(point);
update();
+ oldPoint = point;
+ return;
+ }
- if (toolAction)
+ // Do object hit testing...
+ bool needUpdate = HitTestObjects(point);
+
+ // Check for multi-hover...
+ if (numHovered > 1)
{
- if (Object::snapToGrid)
+ GetHovered(hover);
+ Geometry::Intersects((Object *)hover[0], (Object *)hover[1]);
+ int numIntersecting = Global::numIntersectParams;
+ double t = Global::intersectParam[0];
+ double u = Global::intersectParam[1];
+
+ if (numIntersecting > 0)
+ {
+ Vector v1 = Geometry::GetPointForParameter((Object *)hover[0], t);
+ Vector v2 = Geometry::GetPointForParameter((Object *)hover[1], u);
+ QString text = tr("Intersection t=%1 (%3, %4), u=%2 (%5, %6)");
+ informativeText = text.arg(t).arg(u).arg(v1.x).arg(v1.y).arg(v2.x).arg(v2.y);
+
+ hoveringIntersection = true;
+ intersectionPoint = v1;
+ }
+
+ numIntersecting = Global::numIntersectPoints;
+
+ if (numIntersecting > 0)
{
- point = Object::SnapPointToGrid(point);
- oldPoint = point;
+ Vector v1 = Global::intersectPoint[0];
+
+ if (numIntersecting == 2)
+ {
+ Vector v2 = Global::intersectPoint[1];
+
+ if (Vector::Magnitude(v2, point) < Vector::Magnitude(v1, point))
+ v1 = v2;
+ }
+
+ QString text = tr("Intersection <%1, %2>");
+ informativeText = text.arg(v1.x).arg(v1.y);
+ hoveringIntersection = true;
+ intersectionPoint = v1;
}
+ }
- toolAction->MouseMoved(point);
+//this doesn't work down here for some reason... :-P
+//could be because the object being moved is part of the intersection, and this is screwing things up. In which case, we need to exclude the moving object somehow from the hit test function...
+#if 0
+ // Handle object movement (left button down & over an object)
+ if ((event->buttons() & Qt::LeftButton) && numHovered && !Global::tool)
+ {
+ if (hoveringIntersection)
+ point = intersectionPoint;
+ else if (Global::snapToGrid)
+ point = SnapPointToGrid(point);
+
+ HandleObjectMovement(point);
update();
+ oldPoint = point;
+ return;
}
+#endif
+
+ // Do tool handling, if any are active...
+ if (Global::tool)
+ {
+ if (hoveringIntersection)
+ point = intersectionPoint;
+ else if (Global::snapToGrid)
+ point = SnapPointToGrid(point);
+
+ ToolHandler(ToolMouseMove, point);
+ }
+
+ // This is used to draw the tool crosshair...
+ oldPoint = point;
+
+ if (needUpdate || Global::tool)
+ update();
}
{
if (event->button() == Qt::LeftButton)
{
- document.PointerReleased();
-
//We need to update especially if nothing collided and the state needs to change. !!! FIX !!!
-//could set it up to use the document's update function (assumes that all object updates
-//are being reported correctly:
+//could set it up to use the document's update function (assumes that all object
+//updates are being reported correctly:
// if (document.NeedsUpdate())
+ // Do an update if collided with at least *one* object in the document
// if (collided)
- update(); // Do an update if collided with at least *one* object in the document
+ update();
+
+ if (Global::tool)
+ {
+ Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
+ ToolHandler(ToolMouseUp, point);
+ return;
+ }
- if (toolAction)
- toolAction->MouseReleased();
+ if (Global::selectionInProgress)
+ Global::selectionInProgress = false;
- if (Object::selectionInProgress)
+ informativeText.clear();
+// Should we be doing this automagically? Hmm...
+ // Clear our vectors
+ select.clear();
+ hover.clear();
+
+ // Scoop 'em up
+ std::vector<void *>::iterator i;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
{
- // Select all the stuff inside of selection
- Object::selectionInProgress = false;
+ if (((Object *)(*i))->selected)
+ select.push_back(*i);
+
+//hmm, this is no good, too late to do any good :-P
+// if ((*i)->hovered)
+// hover.push_back(*i);
}
}
else if (event->button() == Qt::MiddleButton)
}
+void DrawingView::wheelEvent(QWheelEvent * event)
+{
+ double zoomFactor = 1.25;
+ QSize sizeWin = size();
+ Vector center(sizeWin.width() / 2.0, sizeWin.height() / 2.0);
+ center = Painter::QtToCartesianCoords(center);
+
+ // This is not centering for some reason. Need to figure out why. :-/
+ if (event->delta() > 0)
+ {
+ Vector newOrigin = center - ((center - Global::origin) / zoomFactor);
+ Global::origin = newOrigin;
+ Global::zoom *= zoomFactor;
+ }
+ else
+ {
+ Vector newOrigin = center + ((-center + Global::origin) * zoomFactor);
+ Global::origin = newOrigin;
+ Global::zoom /= zoomFactor;
+ }
+
+// Global::gridSpacing = gridPixels / Painter::zoom;
+// UpdateGridBackground();
+ SetGridSize(Global::gridSpacing * Global::zoom);
+ update();
+// zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+}
+
+
void DrawingView::keyPressEvent(QKeyEvent * event)
{
- if (toolAction)
+ bool oldShift = shiftDown;
+ bool oldCtrl = ctrlDown;
+
+ if (event->key() == Qt::Key_Shift)
+ shiftDown = true;
+ else if (event->key() == Qt::Key_Control)
+ ctrlDown = true;
+
+ if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
{
- bool needUpdate = toolAction->KeyDown(event->key());
+ if (Global::tool)
+ ToolHandler(ToolKeyDown, Point(0, 0));
- if (needUpdate)
- update();
+ update();
}
}
void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
- if (toolAction)
+ bool oldShift = shiftDown;
+ bool oldCtrl = ctrlDown;
+
+ if (event->key() == Qt::Key_Shift)
+ shiftDown = false;
+ else if (event->key() == Qt::Key_Control)
+ ctrlDown = false;
+
+ if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
{
- bool needUpdate = toolAction->KeyReleased(event->key());
+ if (Global::tool)
+ ToolHandler(ToolKeyUp, Point(0, 0));
- if (needUpdate)
- update();
+ update();
+ }
+}
+
+
+//
+// This looks strange, but it's really quite simple: We want a point that's
+// more than half-way to the next grid point to snap there while conversely we
+// want a point that's less than half-way to to the next grid point then snap
+// to the one before it. So we add half of the grid spacing to the point, then
+// divide by it so that we can remove the fractional part, then multiply it
+// back to get back to the correct answer.
+//
+Point DrawingView::SnapPointToGrid(Point point)
+{
+ point += Global::gridSpacing / 2.0; // *This* adds to Z!!!
+ point /= Global::gridSpacing;
+ point.x = floor(point.x);//need to fix this for negative numbers...
+ point.y = floor(point.y);
+ point.z = 0; // Make *sure* Z doesn't go anywhere!!!
+ point *= Global::gridSpacing;
+ return point;
+}
+
+
+Rect DrawingView::GetObjectExtents(Object * obj)
+{
+ // Default to empty rect, if object checks below fail for some reason
+ Rect rect;
+
+ switch (obj->type)
+ {
+ case OTLine:
+ {
+ rect = Rect(obj->p[0], obj->p[1]);
+ break;
+ }
+ case OTCircle:
+ {
+ rect = Rect(obj->p[0], obj->p[0]);
+ rect.Expand(obj->radius[0]);
+ break;
+ }
+ case OTArc:
+ {
+ Arc * a = (Arc *)obj;
+
+ double start = a->angle[0];
+ double end = start + a->angle[1];
+ rect = Rect(Point(cos(start), sin(start)), Point(cos(end), sin(end)));
+
+ // If the end of the arc is before the beginning, add 360 degrees to it
+ if (end < start)
+ end += TAU;
+
+ // Adjust the bounds depending on which axes are crossed
+ if ((start < QTR_TAU) && (end > QTR_TAU))
+ rect.t = 1.0;
+
+ if ((start < HALF_TAU) && (end > HALF_TAU))
+ rect.l = -1.0;
+
+ if ((start < THREE_QTR_TAU) && (end > THREE_QTR_TAU))
+ rect.b = -1.0;
+
+ if ((start < TAU) && (end > TAU))
+ rect.r = 1.0;
+
+ if ((start < (TAU + QTR_TAU)) && (end > (TAU + QTR_TAU)))
+ rect.t = 1.0;
+
+ if ((start < (TAU + HALF_TAU)) && (end > (TAU + HALF_TAU)))
+ rect.l = -1.0;
+
+ if ((start < (TAU + THREE_QTR_TAU)) && (end > (TAU + THREE_QTR_TAU)))
+ rect.b = -1.0;
+
+ rect *= a->radius[0];
+ rect.Translate(a->p[0]);
+
+ break;
+ }
+ case OTContainer:
+ {
+ Container * c = (Container *)obj;
+ std::vector<void *>::iterator i = c->objects.begin();
+ rect = GetObjectExtents((Object *)*i);
+ i++;
+
+ for(; i!=c->objects.end(); i++)
+ rect |= GetObjectExtents((Object *)*i);
+ }
+ default:
+ break;
+ }
+
+ return rect;
+}
+
+
+void DrawingView::CheckObjectBounds(void)
+{
+ std::vector<void *>::iterator i;
+
+ 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;
+
+ if (Global::selection.contains(l->p[0].x, l->p[0].y) && Global::selection.contains(l->p[1].x, l->p[1].y))
+ l->selected = true;
+
+ break;
+ }
+ case OTCircle:
+ {
+ Circle * c = (Circle *)obj;
+
+ if (Global::selection.contains(c->p[0].x - c->radius[0], c->p[0].y - c->radius[0]) && Global::selection.contains(c->p[0].x + c->radius[0], c->p[0].y + c->radius[0]))
+ c->selected = true;
+
+ break;
+ }
+ case OTArc:
+ {
+ Arc * a = (Arc *)obj;
+
+ double start = a->angle[0];
+ double end = start + a->angle[1];
+ 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 += TAU;
+
+ // Adjust the bounds depending on which axes are crossed
+ if ((start < QTR_TAU) && (end > QTR_TAU))
+ bounds.setTop(1.0);
+
+ if ((start < HALF_TAU) && (end > HALF_TAU))
+ bounds.setLeft(-1.0);
+
+ if ((start < THREE_QTR_TAU) && (end > THREE_QTR_TAU))
+ bounds.setBottom(-1.0);
+
+ if ((start < TAU) && (end > TAU))
+ bounds.setRight(1.0);
+
+ if ((start < (TAU + QTR_TAU)) && (end > (TAU + QTR_TAU)))
+ bounds.setTop(1.0);
+
+ if ((start < (TAU + HALF_TAU)) && (end > (TAU + HALF_TAU)))
+ bounds.setLeft(-1.0);
+
+ if ((start < (TAU + THREE_QTR_TAU)) && (end > (TAU + THREE_QTR_TAU)))
+ bounds.setBottom(-1.0);
+
+ bounds.setTopLeft(QPointF(bounds.left() * a->radius[0], bounds.top() * a->radius[0]));
+ bounds.setBottomRight(QPointF(bounds.right() * a->radius[0], bounds.bottom() * a->radius[0]));
+ bounds.translate(a->p[0].x, a->p[0].y);
+
+ if (Global::selection.contains(bounds))
+ a->selected = true;
+
+ break;
+ }
+ default:
+ break;
+ }
+ }
+}
+
+
+bool DrawingView::HitTestObjects(Point point)
+{
+ std::vector<void *>::iterator i;
+ numHovered = 0;
+ bool needUpdate = false;
+
+ for(i=document.objects.begin(); i!=document.objects.end(); i++)
+ {
+ Object * obj = (Object *)(*i);
+
+ if (HitTest(obj, point))
+ needUpdate = true;
+#if 0
+ switch (obj->type)
+ {
+ case OTLine:
+ {
+ bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitPoint[1] = obj->hitObject = false;
+ Vector lineSegment = obj->p[1] - obj->p[0];
+ Vector v1 = point - obj->p[0];
+ Vector v2 = point - obj->p[1];
+ double t = Geometry::ParameterOfLineAndPoint(obj->p[0], obj->p[1], 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)
+ obj->hitPoint[0] = true;
+ else if ((v2.Magnitude() * Global::zoom) < 8.0)
+ obj->hitPoint[1] = true;
+ else if ((distance * Global::zoom) < 5.0)
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitObject ? true : false);
+
+ if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTCircle:
+ {
+ bool oldHP = obj->hitPoint[0], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitObject = false;
+ double length = Vector::Magnitude(obj->p[0], point);
+
+ if ((length * Global::zoom) < 8.0)
+ obj->hitPoint[0] = true;
+ else if ((fabs(length - obj->radius[0]) * Global::zoom) < 2.0)
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitObject ? true : false);
+
+ if ((oldHP != obj->hitPoint[0]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTArc:
+ {
+ bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHP2 = obj->hitPoint[2], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitPoint[1] = obj->hitPoint[2] = obj->hitObject = false;
+ double length = Vector::Magnitude(obj->p[0], point);
+ double angle = Vector::Angle(obj->p[0], point);
+
+ // Make sure we get the angle in the correct spot
+ if (angle < obj->angle[0])
+ angle += TAU;
+
+ // Get the span that we're pointing at...
+ double span = angle - obj->angle[0];
+
+ // N.B.: Still need to hit test the arc start & arc span handles...
+ double spanAngle = obj->angle[0] + obj->angle[1];
+ Point handle1 = obj->p[0] + (Vector(cos(obj->angle[0]), sin(obj->angle[0])) * obj->radius[0]);
+ Point handle2 = obj->p[0] + (Vector(cos(spanAngle), sin(spanAngle)) * obj->radius[0]);
+ double length2 = Vector::Magnitude(point, handle1);
+ double length3 = Vector::Magnitude(point, handle2);
+
+ if ((length * Global::zoom) < 8.0)
+ obj->hitPoint[0] = true;
+ else if ((length2 * Global::zoom) < 8.0)
+ obj->hitPoint[1] = true;
+ else if ((length3 * Global::zoom) < 8.0)
+ obj->hitPoint[2] = true;
+ else if (((fabs(length - obj->radius[0]) * Global::zoom) < 2.0) && (span < obj->angle[1]))
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitPoint[2] || obj->hitObject ? true : false);
+
+ if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHP2 != obj->hitPoint[2]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTContainer:
+ {
+ // Containers must be recursively tested...
+ Container * c = (Container *)obj;
+ std::vector<void *>::iterator i;
+
+ for(i=c->objects.begin(); i!=c->objects.end(); i++)
+ {
+
+ }
+ }
+ default:
+ break;
+ }
+#endif
+
+ if (obj->hovered)
+ {
+ numHovered++;
+//printf("MouseMove: OBJECT HOVERED (numHovered = %i)\n", numHovered);
+ emit(ObjectHovered(obj));
+ }
+ }
+
+ return needUpdate;
+}
+
+
+bool DrawingView::HitTest(Object * obj, Point point)
+{
+ bool needUpdate = false;
+
+ switch (obj->type)
+ {
+ case OTLine:
+ {
+ bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitPoint[1] = obj->hitObject = false;
+ Vector lineSegment = obj->p[1] - obj->p[0];
+ Vector v1 = point - obj->p[0];
+ Vector v2 = point - obj->p[1];
+ double t = Geometry::ParameterOfLineAndPoint(obj->p[0], obj->p[1], 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)
+ obj->hitPoint[0] = true;
+ else if ((v2.Magnitude() * Global::zoom) < 8.0)
+ obj->hitPoint[1] = true;
+ else if ((distance * Global::zoom) < 5.0)
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitObject ? true : false);
+
+ if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTCircle:
+ {
+ bool oldHP = obj->hitPoint[0], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitObject = false;
+ double length = Vector::Magnitude(obj->p[0], point);
+
+ if ((length * Global::zoom) < 8.0)
+ obj->hitPoint[0] = true;
+ else if ((fabs(length - obj->radius[0]) * Global::zoom) < 2.0)
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitObject ? true : false);
+
+ if ((oldHP != obj->hitPoint[0]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTArc:
+ {
+ bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHP2 = obj->hitPoint[2], oldHO = obj->hitObject;
+ obj->hitPoint[0] = obj->hitPoint[1] = obj->hitPoint[2] = obj->hitObject = false;
+ double length = Vector::Magnitude(obj->p[0], point);
+ double angle = Vector::Angle(obj->p[0], point);
+
+ // Make sure we get the angle in the correct spot
+ if (angle < obj->angle[0])
+ angle += TAU;
+
+ // Get the span that we're pointing at...
+ double span = angle - obj->angle[0];
+
+ // N.B.: Still need to hit test the arc start & arc span handles...
+ double spanAngle = obj->angle[0] + obj->angle[1];
+ Point handle1 = obj->p[0] + (Vector(cos(obj->angle[0]), sin(obj->angle[0])) * obj->radius[0]);
+ Point handle2 = obj->p[0] + (Vector(cos(spanAngle), sin(spanAngle)) * obj->radius[0]);
+ double length2 = Vector::Magnitude(point, handle1);
+ double length3 = Vector::Magnitude(point, handle2);
+
+ if ((length * Global::zoom) < 8.0)
+ obj->hitPoint[0] = true;
+ else if ((length2 * Global::zoom) < 8.0)
+ obj->hitPoint[1] = true;
+ else if ((length3 * Global::zoom) < 8.0)
+ obj->hitPoint[2] = true;
+ else if (((fabs(length - obj->radius[0]) * Global::zoom) < 2.0) && (span < obj->angle[1]))
+ obj->hitObject = true;
+
+ obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitPoint[2] || obj->hitObject ? true : false);
+
+ if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHP2 != obj->hitPoint[2]) || (oldHO != obj->hitObject))
+ needUpdate = true;
+
+ break;
+ }
+ case OTContainer:
+ {
+ // Containers must be recursively tested...
+ Container * c = (Container *)obj;
+ c->hitObject = false;
+ c->hovered = false;
+ std::vector<void *>::iterator i;
+
+ for(i=c->objects.begin(); i!=c->objects.end(); i++)
+ {
+ Object * cObj = (Object *)*i;
+
+ if (HitTest(cObj, point))
+ needUpdate = true;
+
+ if (cObj->hitObject == true)
+ c->hitObject = true;
+
+ if (cObj->hovered == true)
+ c->hovered = true;
+ }
+
+ break;
+ }
+ default:
+ break;
+ }
+
+ return needUpdate;
+}
+
+
+void DrawingView::HandleObjectMovement(Point point)
+{
+ Point delta = point - oldPoint;
+//printf("HOM: old = (%f,%f), new = (%f, %f), delta = (%f, %f)\n", oldPoint.x, oldPoint.y, point.x, point.y, delta.x, delta.y);
+ Object * obj = (Object *)hover[0];
+//printf("Object type = %i (size=%i), ", obj->type, hover.size());
+//printf("Object (%X) move: hp1=%s, hp2=%s, hl=%s\n", obj, (obj->hitPoint[0] ? "true" : "false"), (obj->hitPoint[1] ? "true" : "false"), (obj->hitObject ? "true" : "false"));
+
+ switch (obj->type)
+ {
+ case OTLine:
+ if (obj->hitPoint[0])
+ obj->p[0] = point;
+ else if (obj->hitPoint[1])
+ obj->p[1] = point;
+ else if (obj->hitObject)
+ {
+ obj->p[0] += delta;
+ obj->p[1] += delta;
+ }
+
+ break;
+ case OTCircle:
+ if (obj->hitPoint[0])
+ obj->p[0] = point;
+ else if (obj->hitObject)
+ {
+//this doesn't work. we need to save this on mouse down for this to work correctly!
+// double oldRadius = obj->radius[0];
+ obj->radius[0] = Vector::Magnitude(obj->p[0], point);
+
+ QString text = QObject::tr("Radius: %1");//\nScale: %2%");
+ informativeText = text.arg(obj->radius[0], 0, 'd', 4);//.arg(obj->radius[0] / oldRadius * 100.0, 0, 'd', 0);
+ }
+
+ break;
+ case OTArc:
+ if (obj->hitPoint[0])
+ obj->p[0] = point;
+ else if (obj->hitPoint[1])
+ {
+ // Change the Arc's span (handle #1)
+ if (shiftDown)
+ {
+ double angle = Vector::Angle(obj->p[0], point);
+ double delta = angle - obj->angle[0];
+
+ if (delta < 0)
+ delta += TAU;
+
+ obj->angle[1] -= delta;
+ obj->angle[0] = angle;
+
+ if (obj->angle[1] < 0)
+ obj->angle[1] += TAU;
+
+ QString text = QObject::tr("Span: %1") + QChar(0x00B0) + QObject::tr("\n%2") + QChar(0x00B0) + QObject::tr(" - %3") + QChar(0x00B0);
+ informativeText = text.arg(obj->angle[1] * RADIANS_TO_DEGREES, 0, 'd', 4).arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 2).arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 2);
+ return;
+ }
+
+ double angle = Vector::Angle(obj->p[0], point);
+ obj->angle[0] = angle;
+ QString text = QObject::tr("Start angle: %1") + QChar(0x00B0);
+ informativeText = text.arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 4);
+ }
+ else if (obj->hitPoint[2])
+ {
+ // Change the Arc's span (handle #2)
+ if (shiftDown)
+ {
+ double angle = Vector::Angle(obj->p[0], point);
+ obj->angle[1] = angle - obj->angle[0];
+
+ if (obj->angle[1] < 0)
+ obj->angle[1] += TAU;
+
+ QString text = QObject::tr("Span: %1") + QChar(0x00B0) + QObject::tr("\n%2") + QChar(0x00B0) + QObject::tr(" - %3") + QChar(0x00B0);
+ informativeText = text.arg(obj->angle[1] * RADIANS_TO_DEGREES, 0, 'd', 4).arg(obj->angle[0] * RADIANS_TO_DEGREES, 0, 'd', 2).arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 2);
+ return;
+ }
+
+ double angle = Vector::Angle(obj->p[0], point);
+ obj->angle[0] = angle - obj->angle[1];
+
+ if (obj->angle[0] < 0)
+ obj->angle[0] += TAU;
+
+ QString text = QObject::tr("End angle: %1") + QChar(0x00B0);
+ informativeText = text.arg((obj->angle[0] + obj->angle[1]) * RADIANS_TO_DEGREES, 0, 'd', 4);
+ }
+ else if (obj->hitObject)
+ {
+ if (shiftDown)
+ {
+ return;
+ }
+
+ obj->radius[0] = Vector::Magnitude(obj->p[0], point);
+ QString text = QObject::tr("Radius: %1");
+ informativeText = text.arg(obj->radius[0], 0, 'd', 4);
+ }
+
+ break;
+ case OTContainer:
+ // This is shitty, but works for now until I can code up something
+ // nicer :-)
+ TranslateObject(obj, delta);
+
+ break;
+ default:
+ break;
}
}
projects / architektonas / blobdiff