[architektonas] / src / drawingview.cpp

//
// drawingview.cpp
//
// Part of the Architektonas Project
// (C) 2011-2020 Underground Software
// See the README and GPLv3 files for licensing and warranty information
//
// 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
//

// FIXED:
//
// - Redo rendering code to *not* use Qt's transform functions, as they are tied
//   to a left-handed system and we need a right-handed one. [DONE]
// - Fixed length tool doesn't work on lines [DONE]
//
// STILL TO BE DONE:
//
// - Lots of stuff
// - Layer locking (hiding works)
// - Fixed angle tool doesn't work on lines
// - Make it so "dirty" flag reflects drawing state
//

// Uncomment this for debugging...
//#define DEBUG
//#define DEBUGFOO                              // Various tool debugging...
//#define DEBUGTP                               // Toolpalette debugging...

#include "drawingview.h"

#include <stdint.h>
#include "geometry.h"
#include "global.h"
#include "mathconstants.h"
#include "painter.h"
#include "penwidget.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), numHovered(0), shiftDown(false),
        ctrlDown(false), altDown(false),
        gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
        scale(1.0), offsetX(-10), offsetY(-10), supressSelected(false),
        document(true),
        gridPixels(0), collided(false), scrollDrag(false), hoverPointValid(false),
        hoveringIntersection(false), dragged(NULL), draggingObject(false),
        angleSnap(false), dirty(false)
{
//wtf? doesn't work except in c++11???  document = { 0 };
        setBackgroundRole(QPalette::Base);
        setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

        curMarker = QCursor(QPixmap(":/res/cursor-marker.png"), 1, 18);
        curDropper = QCursor(QPixmap(":/res/cursor-dropper.png"), 1, 20);

        Global::gridSpacing = 12.0;             // In base units (inch is default)

        Line * line = new Line(Vector(5, 5), Vector(50, 40), 2.0, 0xFF7F00, LSDash);
        document.Add(line);
        document.Add(new Line(Vector(50, 40), Vector(10, 83)));
        document.Add(new Line(Vector(10, 83), Vector(17, 2)));
        document.Add(new Circle(Vector(100, 100), 36));
        document.Add(new Circle(Vector(50, 150), 49));
        document.Add(new Arc(Vector(300, 300), 32, TAU / 8.0, TAU * 0.65)),
        document.Add(new Arc(Vector(200, 200), 60, TAU / 4.0, TAU * 0.75));
        document.Add(new Text(Vector(10, 83), "Here is some awesome text!"));

        AddDimensionTo(line);

/*
Here we set the grid size in pixels--12 in this case. Initially, we have our
zoom set to make this represent 12 inches at a zoom factor of 25%. (This is
arbitrary.) So, to be able to decouple the grid size from the zoom, we need
to be able to set the size of the background grid (which we do here at an
arbitrary 12 pixels) to anything we want (within reason, of course :-).

The drawing enforces the grid spacing through the drawing->gridSpacing variable.

        drawing->gridSpacing = 12.0 / Global::zoom;

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
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
objects to take its place--like some kind of scale factor. This would seem to
imply that certain point sizes actually *do* tie things like fonts to absolute
sizes on the screen, but not necessarily because you could have an inch scale
with text that is quite small relative to other objects on the screen, which
currently you have to zoom in to see (and which blows up the text). Point sizes
in an application like this are a bit meaningless; even though an inch is an
inch regardless of the zoom level a piece of text can be larger or smaller than
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. 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"), 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
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
need a thickness parameter similar to the "size" param for dimensions. (And now
we do! :-)
*/
}

void DrawingView::DrawBackground(Painter * painter)
{
        Point ul = Painter::QtToCartesianCoords(Vector(0, 0));
        Point br = Painter::QtToCartesianCoords(Vector(Global::screenSize.x, Global::screenSize.y));

        painter->SetBrush(0xF0F0F0);
        painter->SetPen(0xF0F0F0, 1, 1);
        painter->DrawRect(QRectF(QPointF(ul.x, ul.y), QPointF(br.x, br.y)));

        double spacing = Global::gridSpacing;

        if (spacing < 1.0)
                spacing = 1.0;

        double leftx = floor(ul.x / spacing) * spacing;
        double bottomy = floor(br.y / spacing) * spacing;

        double w = (br.x - ul.x) + Global::gridSpacing + 1.0;
        double h = (ul.y - br.y) + Global::gridSpacing + 1.0;

        Vector start(leftx, bottomy), size(w, h);

        if (Global::gridSpacing <= 0.015625)
                DrawSubGrid(painter, 0xFFD2D2, 0.015625, start, size);

        if (Global::gridSpacing <= 0.03125)
                DrawSubGrid(painter, 0xFFD2D2, 0.03125, start, size);

        if (Global::gridSpacing <= 0.0625)
                DrawSubGrid(painter, 0xB8ECFF, 0.0625, start, size);

        if (Global::gridSpacing <= 0.125)
                DrawSubGrid(painter, 0xB8ECFF, 0.125, start, size);

        if (Global::gridSpacing <= 0.25)
                DrawSubGrid(painter, 0xE6E6FF, 0.25, start, size);

        if (Global::gridSpacing <= 0.5)
                DrawSubGrid(painter, 0xE6E6FF, 0.5, start, size);

        painter->SetPen(QPen(QColor(0xE0, 0xE0, 0xFF), 2.0, Qt::SolidLine));

        for(double i=0; i<=w; i+=spacing)
                painter->DrawVLine(leftx + i);

        for(double i=0; i<=h; i+=spacing)
                painter->DrawHLine(bottomy + i);
}

void DrawingView::DrawSubGrid(Painter * painter, uint32_t color, double step, Vector start, Vector size)
{
        painter->SetPen(color, 1, 1);

        for(double i=-step; i<=size.x; i+=step*2.0)
                painter->DrawVLine(start.x + i);

        for(double i=-step; i<=size.y; i+=step*2.0)
                painter->DrawHLine(start.y + i);
}

//
// 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)
{
        VPVectorIter i = document.objects.begin();

        while (i != document.objects.end())
        {
                Object * obj = (Object *)(*i);

                if (obj->layer < layer)
                        i++;
                else if (obj->layer == layer)
                {
                        document.objects.erase(i);
                        delete obj;
                }
                else
                {
                        obj->layer--;
                        i++;
                }
        }

        // 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();
}

//
// 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)
{
        HandleLayerSwap(layer1, layer2, document.objects);
}

/*
We can roll this into the main one above, by having the LayerWidget's emit() call sending NULL for the VPVector, which we can test for and set to document.objects to grab the top layer.  Or, keep it a top level call and a recursive call.  Which is worse?  :-P
*/
void DrawingView::HandleLayerSwap(int layer1, int layer2, VPVector & v)
{
        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->layer == layer1)
                        obj->layer = layer2;
                else if (obj->layer == layer2)
                        obj->layer = layer1;

                if (obj->type == OTContainer)
                        HandleLayerSwap(layer1, layer2, ((Container *)obj)->objects);
        }
}

void DrawingView::HandlePenStamp(QAction * action)
{
        PenWidget * pw = (PenWidget *)action->parentWidget();
        pw->dropperAction->setChecked(false);
        Global::penDropper = false;
        Global::penStamp = action->isChecked();

        if (Global::penStamp)
                setCursor(curMarker);
        else
                setCursor(Qt::ArrowCursor);

        if (Global::penStamp == false)
                ClearSelected(document.objects);

        update();
}

void DrawingView::HandlePenDropper(QAction * action)
{
        PenWidget * pw = (PenWidget *)action->parentWidget();
        pw->stampAction->setChecked(false);
        Global::penStamp = false;
        Global::penDropper = action->isChecked();

        if (Global::penDropper)
                setCursor(curDropper);
        else
                setCursor(Qt::ArrowCursor);

        update();
}

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.
        return QPoint(offsetX + event->x(), offsetY + (size().height() - event->y()));
}

QPoint DrawingView::GetAdjustedClientPosition(int x, int 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 [why? we use -offsetX after all]
        return QPoint(-offsetX + x, (size().height() - (-offsetY + y)) * +1.0);
}

void DrawingView::focusOutEvent(QFocusEvent * /*event*/)
{
        // Make sure all modkeys being held are marked as released when the app
        // loses focus (N.B.: This only works because the app sets the focus policy
        // of this object to something other than Qt::NoFocus)
        shiftDown = ctrlDown = altDown = false;
        scrollDrag = false;
        setCursor(Qt::ArrowCursor);
}

void DrawingView::focusInEvent(QFocusEvent * /*event*/)
{
        if (Global::penStamp)
                setCursor(curMarker);
        else if (Global::penDropper)
                setCursor(curDropper);
}

void DrawingView::paintEvent(QPaintEvent * /*event*/)
{
        QPainter qtPainter(this);
        Painter painter(&qtPainter);

        if (useAntialiasing)
                qtPainter.setRenderHint(QPainter::Antialiasing);

        Global::viewportHeight = size().height();

        DrawBackground(&painter);

        // Draw coordinate axes
        painter.SetPen(QPen(Qt::blue, 1.0, Qt::DotLine));
        painter.DrawLine(0, -16384, 0, 16384);
        painter.DrawLine(-16384, 0, 16384, 0);

        // Do object rendering...
        for(int i=0; i<Global::numLayers; i++)
        {
                if (Global::layerHidden[i] == false)
                        RenderObjects(&painter, document.objects, i);
        }

        // Do tool rendering, if any...
        if (Global::tool)
        {
                if (Global::toolSuppressCrosshair == false)
                {
                        painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
                        painter.DrawCrosshair(oldPoint);
                }

                ToolDraw(&painter);
        }

        // Do selection rectangle rendering, if any
        if (Global::selectionInProgress)
        {
                painter.SetPen(QPen(QColor(0xFF, 0x7F, 0x00, 0xFF)));
                painter.SetBrush(QBrush(QColor(0xFF, 0x7F, 0x00, 0x64)));
                painter.DrawRect(Global::selection);
        }

        if (hoveringIntersection)
                painter.DrawHandle(intersectionPoint);

        if (hoverPointValid)
                painter.DrawHandle(hoverPoint);

        if (!informativeText.isEmpty())
                painter.DrawInformativeText(informativeText);
}

//
// Renders objects in the passed in vector
//
/*
N.B.: Since we have "hoverPointValid" drawing regular object handles above,
      we can probably do away with a lot of them that are being done down below.
      !!! FIX !!!
      [Well, it seems to work OK *except* when you move one of the points, then you get to see nothing. Is it worth fixing there to get rid of problems here? Have to investigate...]
*/
void DrawingView::RenderObjects(Painter * painter, VPVector & v, int layer, bool ignoreLayer/*= false*/)
{
        for(VPVectorIter 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);

                        // penStamp supresses object highlighting, so that changes can be seen.
                        if (supressSelected || Global::penStamp)
                        {
                                if (obj->hitObject)
                                {
                                        painter->SetPen(Global::penColor, Global::zoom * Global::scale * Global::penWidth, Global::penStyle);
                                        painter->SetBrush(Global::penColor);
                                }
                        }
                        else 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]);

                        if (obj->hitObject)
                                painter->DrawSmallHandle(Geometry::Midpoint((Line *)obj));

                        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();
                        d->lp[0] = d->p[0], d->lp[1] = 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;
                                }

                                d->lp[0].x = d->lp[1].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;
                                }

                                d->lp[0].y = d->lp[1].y = y1;
                                length = fabs(d->p[0].x - d->p[1].x);
                        }
                        else if (d->subtype == DTLinear)
                        {
                                angle = Vector(d->lp[0], d->lp[1]).Angle();
                                ortho = Vector::Normal(d->lp[0], d->lp[1]);
                                length = v.Magnitude();
                        }

                        unit = Vector(d->lp[0], d->lp[1]).Unit();

                        Point p1 = d->lp[0] + (ortho * (d->offset + (10.0 * scaledThickness)));
                        Point p2 = d->lp[1] + (ortho * (d->offset + (10.0 * scaledThickness)));
                        Point p3 = d->lp[0] + (ortho * (d->offset + (16.0 * scaledThickness)));
                        Point p4 = d->lp[1] + (ortho * (d->offset + (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(d->lp[0], d->lp[1], d->lp[1] - (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);
                        }

/*
Where is the text offset?  It looks like it's drawing in the center, but obviously it isn't.  It isn't here, it's in Painter::DrawAngledText().
*/
                        painter->DrawAngledText(ctr, angle, dimText, scaledThickness);

                        if (d->hitObject)
                        {
                                Point hp1 = (p1 + p2) / 2.0;
                                Point hp2 = (p1 + hp1) / 2.0;
                                Point hp3 = (hp1 + p2) / 2.0;

                                if (d->hitPoint[2])
                                {
                                        painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
                                        painter->SetBrush(QBrush(QColor(Qt::magenta)));
                                        painter->DrawArrowHandle(hp1, ortho.Angle() + HALF_TAU);
                                        painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
                                }

                                painter->DrawHandle(hp1);
                                painter->SetPen(QPen(Qt::blue, 1.0 * Global::zoom * scaledThickness, Qt::SolidLine));

                                if (d->hitPoint[3])
                                {
                                        painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
                                        painter->SetBrush(QBrush(QColor(Qt::magenta)));
                                        painter->DrawArrowToLineHandle(hp2, (d->subtype == DTLinearVert ? v.Angle() - QTR_TAU : (v.Angle() < HALF_TAU ? HALF_TAU : 0)));
                                        painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
                                }

                                painter->DrawHandle(hp2);
                                painter->SetPen(QPen(Qt::blue, 1.0 * Global::zoom * scaledThickness, Qt::SolidLine));

                                if (d->hitPoint[4])
                                {
                                        painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
                                        painter->SetBrush(QBrush(QColor(Qt::magenta)));
                                        painter->DrawArrowToLineHandle(hp3, (d->subtype == DTLinearHorz ? v.Angle() - QTR_TAU : (v.Angle() > HALF_TAU && v.Angle() < THREE_QTR_TAU ? THREE_QTR_TAU : QTR_TAU)));
                                        painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
                                }

                                painter->DrawHandle(hp3);
                        }

                        if (obj->hitPoint[0])
                                painter->DrawHandle(obj->p[0]);

                        if (obj->hitPoint[1])
                                painter->DrawHandle(obj->p[1]);

                        break;
                }

                case OTText:
                {
                        Text * t = (Text *)obj;

                        if (t->measured == false)
                        {
                                t->extents = painter->MeasureTextObject(t->s.c_str(), scaledThickness);
                                t->measured = true;
                        }

                        painter->DrawTextObject(t->p[0], t->s.c_str(), scaledThickness, t->angle[0]);
                        break;
                }

                case OTSpline:
                {
                        break;
                }

                case OTPolygon:
                {
                        break;
                }

                case OTPolyline:
                {
                        break;
                }

                case OTContainer:
                {
                        // Containers require recursive rendering...
                        Container * c = (Container *)obj;
//printf("About to render container: # objs=%i, layer=%i\n", (*c).objects.size(), layer);
                        RenderObjects(painter, (*c).objects, layer, ignoreLayer);

//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);
                                painter->DrawRectCorners(Rect(c->p[0], c->p[1]));
                        }

                        break;
                }

                default:
                        break;
                }
        }

        supressSelected = false;
}

//
// This toggles the selection being hovered (typically, only 1 object).  We
// toggle because the CTRL key might be held, in which case, we want to
// deselect a selected object.
//
void DrawingView::HandleSelectionClick(VPVector & v)
{
        if (ctrlDown)
        {
                for(VPVectorIter i=v.begin(); i!=v.end(); i++)
                {
                        Object * obj = (Object *)(*i);

                        if (obj->hovered)
                                obj->selected = !obj->selected;
                }

                return;
        }

        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
                ((Object *)(*i))->selected = false;

        // Check if the hover changed, and if so, reset the selection stack
        if (oldHover.size() != v.size())
        {
                oldHover = v;
                currentSelect = 0;
        }
        else
        {
                // Select next object in the stack under the cursor
                currentSelect++;

                if (currentSelect >= v.size())
                        currentSelect = 0;
        }

        dragged = (Object *)v[currentSelect];
        dragged->selected = true;
}

VPVector DrawingView::GetSelection(void)
{
        VPVector v;

        for(VPVectorIter i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                if (((Object *)(*i))->selected)
                        v.push_back(*i);
        }

        return v;
}

//
// When testing for hovered intersections, we need to be able to exclude some
// objects which have funky characteristics or handles; so we allow for that
// here.
//
VPVector DrawingView::GetHovered(bool exclude/*= false*/)
{
        VPVector v;

        for(VPVectorIter i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->hovered)
                {
                        if (exclude
                                && ((obj->type == OTDimension)
                                        || ((obj->type == OTCircle) && (obj->hitPoint[0] == true))
                                        || ((obj->type == OTArc) && (obj->hitPoint[0] == true))
                                        || (draggingObject && (obj == dragged))))
                                continue;

                        v.push_back(*i);
                }
        }

        return v;
}

void DrawingView::MoveSelectedToLayer(int layer)
{
        for(VPVectorIter i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->selected || obj->hovered)
                        obj->layer = layer;
        }
}

void DrawingView::resizeEvent(QResizeEvent * /*event*/)
{
        Global::screenSize = Vector(size().width(), size().height());
}

void DrawingView::ToolHandler(int mode, Point p)
{
        // Drop angle snap until it's needed
        angleSnap = false;

        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);
        else if (Global::tool == TTDimension)
                DimensionHandler(mode, p);
        else if (Global::tool == TTDelete)
                DeleteHandler(mode, p);
        else if (Global::tool == TTTriangulate)
                TriangulateHandler(mode, p);
        else if (Global::tool == TTTrim)
                TrimHandler(mode, p);
        else if (Global::tool == TTParallel)
                ParallelHandler(mode, p);
}

void DrawingView::ToolDraw(Painter * painter)
{
        if (Global::tool == TTLine)
        {
                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;

                        painter->DrawLine(toolPoint[0], toolPoint[1]);

                        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;

                        if (absAngle > 180.0)
                                absAngle -= 180.0;

                        QString text = QChar(0x2221) + QObject::tr(": %1");
                        informativeText = text.arg(absAngle);

                        if (ctrlDown)
                                informativeText += " (Copy)";
                }
        }
        else if (Global::tool == TTDimension)
        {
                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 == TTTrim)
        {
                if (toolObj[0] != NULL)
                {
                        // We're assuming ATM it's just a line...
                        painter->SetPen(0xAF0000, 3.0, LSSolid);
                        painter->DrawLine(toolPoint[0], toolPoint[1]);
//                      QString text = tr("Arc span: %1") + QChar(0x00B0);
//                      informativeText = text.arg(RADIANS_TO_DEGREES * span);
                }
        }
        else if (Global::tool == TTParallel)
        {
                if (Global::toolState == TSPoint1)
                {
                        painter->SetPen(0xFF00FF, 2.0, LSSolid);
                        painter->SetBrush(QBrush(Qt::NoBrush));

                        double length = Vector::Magnitude(toolObj[0]->p[0], toolPoint[0]);
                        bool inside = (length >= toolObj[0]->radius[0] ? false : true);

                        for(int i=1; i<=Global::parallelNum; i++)
                        {
                                if (toolObj[0]->type == OTLine)
                                {
                                        painter->DrawLine(toolObj[0]->p[0] + (toolPoint[0] * Global::parallelDist * (double)i), toolObj[0]->p[1] + (toolPoint[0] * Global::parallelDist * (double)i));
                                }
                                else if ((toolObj[0]->type == OTCircle) || (toolObj[0]->type == OTArc))
                                {
                                        double radius = toolObj[0]->radius[0] + ((double)i * Global::parallelDist * (inside ? -1.0 : 1.0));

                                        if (radius > 0)
                                        {
                                                if (toolObj[0]->type == OTCircle)
                                                        painter->DrawEllipse(toolObj[0]->p[0], radius, radius);
                                                else
                                                        painter->DrawArc(toolObj[0]->p[0], radius, toolObj[0]->angle[0], toolObj[0]->angle[1]);
                                        }
                                }
                        }
                }
        }
}

void DrawingView::LineHandler(int mode, Point p)
{
        switch (mode)
        {
        case ToolMouseDown:
/*              toolObj[0] = NULL;

                // Check to see if we can do a circle tangent snap
                if (numHovered == 1)
                {
                        VPVector hover = GetHovered();
                        Object * obj = (Object *)hover[0];

                        // Save for later if the object clicked was a circle (need to check that it wasn't the center clicked on, because that will fuck up connecting centers of circles with lines... and now we do! :-)
                        if ((obj->type == OTCircle) && (obj->hitPoint[0] == false))
                                toolObj[0] = obj;
                }*/

                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;
/*                      bool isCircle = false;

                        if (numHovered == 1)
                        {
                                VPVector hover = GetHovered();
                                Object * obj = (Object *)hover[0];

                                if ((obj->type == OTCircle) && (obj->hitPoint[0] == false))
                                {
                                        isCircle = true;
                                        toolObj[1] = obj;
                                }
                        }

                        // Adjust initial point if it's on a circle (tangent point)
                        if (toolObj[0] != NULL)
                        {
                                if (isCircle)
                                {
                                        Geometry::FindTangents(toolObj[0], toolObj[1]);

                                        if (Global::numIntersectPoints > 0)
                                        {
                                                toolPoint[0] = Global::intersectPoint[0];
                                                toolPoint[1] = Global::intersectPoint[1];
                                        }
                                }
                                else
                                {
                                        Geometry::FindTangents(toolObj[0], p);

                                        if (Global::numIntersectPoints > 0)
                                                toolPoint[0] = Global::intersectPoint[0];
                                }
                        }
                        else
                        {
                                if (isCircle)
                                {
                                        Geometry::FindTangents(toolObj[1], toolPoint[0]);

                                        if (Global::numIntersectPoints > 0)
                                                toolPoint[1] = Global::intersectPoint[0];
                                }
                        }*/
                }

                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
                {
                        Line * l = new Line(toolPoint[0], toolPoint[1], Global::penWidth, Global::penColor, Global::penStyle);
                        l->layer = Global::activeLayer;
                        document.objects.push_back(l);
                        toolPoint[0] = toolPoint[1];
                }
        }
}

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, Global::penWidth, Global::penColor, Global::penStyle);
                        c->layer = Global::activeLayer;
                        document.objects.push_back(c);
                        toolPoint[0] = toolPoint[1];
                        Global::toolState = TSNone;
                }
        }
}

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;
                        angleSnap = true;
                }
                else
                {
                        toolPoint[3] = p;
                        angleSnap = true;
                }

                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 arc 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, Global::penWidth, Global::penColor, Global::penStyle);
                        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);
                        CopyObjects(select, toolScratch2);
                        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;

                        angleSnap = true;
                        double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
                        VPVectorIter j = select.begin();
//                      std::vector<Object>::iterator i = toolScratch.begin();
                        VPVectorIter i = toolScratch2.begin();

//                      for(; i!=toolScratch.end(); i++, j++)
                        for(; i!=toolScratch2.end(); i++, j++)
                        {
//                              Object objT = *i;
//                              Point p1 = Geometry::RotatePointAroundPoint(objT.p[0], toolPoint[0], angle);
//                              Point p2 = Geometry::RotatePointAroundPoint(objT.p[1], toolPoint[0], angle);
                                Object * objT = (Object *)(*i);
                                Object * objS = (Object *)(*j);

                                Point p1 = Geometry::RotatePointAroundPoint(objT->p[0], toolPoint[0], angle);
                                Point p2 = Geometry::RotatePointAroundPoint(objT->p[1], toolPoint[0], angle);

                                objS->p[0] = p1;
                                objS->p[1] = p2;

//                              if (objT.type == OTArc || objT.type == OTText)
                                if (objT->type == OTArc || objT->type == OTText)
                                {
//                                      objS->angle[0] = objT.angle[0] + angle;
                                        objS->angle[0] = objT->angle[0] + angle;

                                        if (objS->angle[0] > TAU)
                                                objS->angle[0] -= TAU;
                                }
//                              else if (objT.type == OTContainer)
                                else if (objT->type == OTContainer)
                                {
                                        // OK, this doesn't work because toolScratch only has points and nothing in the containers... [ACTUALLY... toolScratch is is a vector of type Object... which DOESN'T have an objects vector in it...]
//                                      Container * c = (Container *)&objT;
                                        Container * c = (Container *)objT;
                                        Container * c2 = (Container *)objS;
                                        VPVectorIter l = c->objects.begin();
                                        // TODO: Rotate items in the container
                                        // TODO: Make this recursive
                                        for(VPVectorIter k=c2->objects.begin(); k!=c2->objects.end(); k++, l++)
                                        {
                                                Object * obj3 = (Object *)(*k);
                                                Object * obj4 = (Object *)(*l);

                                                p1 = Geometry::RotatePointAroundPoint(obj4->p[0], toolPoint[0], angle);
                                                p2 = Geometry::RotatePointAroundPoint(obj4->p[1], toolPoint[0], angle);

                                                obj3->p[0] = p1;
                                                obj3->p[1] = p2;
//                                              obj3->angle[0] = objT.angle[0] + angle;
                                                obj3->angle[0] = obj4->angle[0] + angle;

                                                if (obj3->angle[0] > TAU)
                                                        obj3->angle[0] -= TAU;
                                        }

                                        Rect r = GetObjectExtents(objS);
                                        c2->p[0] = r.TopLeft();
                                        c2->p[1] = r.BottomRight();
                                }
                        }
                }

                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
                                VPVector temp;
                                CopyObjects(select, temp);
                                ClearSelected(temp);
                                AddObjectsTo(document.objects, temp);
//                              RestorePointsTo(select, toolScratch);
                                RestorePointsTo(select, toolScratch2);
                                return;
                        }

                        toolPoint[0] = p;
                        Global::toolState = TSPoint1;
//                      SavePointsFrom(select, toolScratch);
                        DeleteContents(toolScratch2);
                        CopyObjects(select, toolScratch2);
                }

                break;

        case ToolKeyDown:
                // Reset the selection if shift held down...
                if (shiftDown)
//                      RestorePointsTo(select, toolScratch);
                        RestorePointsTo(select, toolScratch2);

                break;

        case ToolKeyUp:
                // Reset selection when key is let up
                if (!shiftDown)
                        RotateHandler(ToolMouseMove, toolPoint[1]);

                break;

        case ToolCleanup:
//              RestorePointsTo(select, toolScratch);
                RestorePointsTo(select, toolScratch2);
                DeleteContents(toolScratch2);
        }
}

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;

                        angleSnap = true;
                        double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
                        VPVectorIter 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;

/*
N.B.: When mirroring an arc thru a horizontal axis, this causes the arc to have
      a negative start angle which makes it impossible to interact with.
      !!! FIX !!!
*/
                                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
                                VPVector 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::DimensionHandler(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
                {
                        Dimension * d = new Dimension(toolPoint[0], toolPoint[1], DTLinear, 0, Global::penWidth);
                        d->layer = Global::activeLayer;
                        document.objects.push_back(d);
                        Global::toolState = TSNone;
                }
        }
}

void DrawingView::DeleteHandler(int mode, Point /*p*/)
{
        switch (mode)
        {
        case ToolMouseDown:
        {
                VPVector hovered = GetHovered();

                RemoveHoveredObjects(document.objects);
                DeleteContents(hovered);
        }
                break;

        case ToolMouseMove:
                break;

        case ToolMouseUp:
                break;

        case ToolKeyDown:
                break;

        case ToolKeyUp:
                break;

        case ToolCleanup:
                break;
        }
}

void DrawingView::TriangulateHandler(int mode, Point /*p*/)
{
        switch (mode)
        {
        case ToolMouseDown:
        {
                // Skip if nothing hovered...
                if (numHovered != 1)
                        break;

                VPVector hover = GetHovered();
                Object * obj = (Object *)hover[0];

                // Skip if it's not a line...
                if (obj->type != OTLine)
                        break;

                if (Global::toolState == TSNone)
                        toolObj[0] = obj;
                else if (Global::toolState == TSPoint2)
                        toolObj[1] = obj;
                else
                        toolObj[2] = obj;

                break;
        }
#if 0
        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;
                        angleSnap = true;
                }
                else
                {
                        toolPoint[3] = p;
                        angleSnap = true;
                }

                break;
#endif
        case ToolMouseUp:
                if (Global::toolState == TSNone)
                {
                        Global::toolState = TSPoint2;
                }
                else if (Global::toolState == TSPoint2)
                {
/*                      if (shiftDown)
                        {
                                // Key override is telling us to start arc at new center, not
                                // continue the current one.
                                toolPoint[0] = toolPoint[1];
                                return;
                        }*/

                        Global::toolState = TSPoint3;
                }
                else
                {
                        double len2 = Vector::Magnitude(toolObj[1]->p[0], toolObj[1]->p[1]);
                        double len3 = Vector::Magnitude(toolObj[2]->p[0], toolObj[2]->p[1]);

                        Circle c1(toolObj[0]->p[0], len2);
                        Circle c2(toolObj[0]->p[1], len3);

                        Geometry::CheckCircleToCircleIntersection((Object *)&c1, (Object *)&c2);

                        // Only move lines if the triangle formed by them is not degenerate
                        if (Global::numIntersectPoints > 0)
                        {
                                toolObj[1]->p[0] = toolObj[0]->p[0];
                                toolObj[1]->p[1] = Global::intersectPoint[0];

                                toolObj[2]->p[0] = Global::intersectPoint[0];
                                toolObj[2]->p[1] = toolObj[0]->p[1];
                        }

                        Global::toolState = TSNone;
                }
        }
}

void DrawingView::TrimHandler(int mode, Point p)
{
        switch (mode)
        {
        case ToolMouseDown:
        {
        }
                break;

        case ToolMouseMove:
        {
                // Bail out if nothing hovered...
                if (numHovered != 1)
                {
                        toolObj[0] = NULL;
                        return;
                }

                VPVector hover = GetHovered();
                Object * obj = (Object *)hover[0];

                // Skip if it's not a line...
                if (obj->type != OTLine)
                {
                        toolObj[0] = NULL;
                        return;
                }

                toolObj[0] = obj;
                double hoveredParam = Geometry::ParameterOfLineAndPoint(obj->p[0], obj->p[1], p);
                double t = 0, u = 1.0;

                // Currently only deal with line against line trimming, can expand to
                // others as well (line/circle, circle/circle, line/arc, etc)
                VPVectorIter i;
                for(i=document.objects.begin(); i!=document.objects.end(); i++)
                {
                        obj = (Object *)(*i);

                        if (obj == toolObj[0])
                                continue;
                        else if (obj->type != OTLine)
                                continue;

                        Geometry::CheckLineToLineIntersection(toolObj[0], obj);

                        if (Global::numIntersectParams > 0)
                        {
                                // Skip endpoint-endpoint intersections
                                if ((Global::numIntersectParams == 2)
                                        && (Global::intersectParam[0] == 0
                                                || Global::intersectParam[0] == 1.0)
                                        && (Global::intersectParam[1] == 0
                                                || Global::intersectParam[1] == 1.0))
                                        continue;

                                // Mark the line segment somehow (the side the mouse is on) so that it can be drawn & trimmed when we hit ToolMouseDown.
                                if ((Global::intersectParam[0] > t) && (Global::intersectParam[0] < hoveredParam))
                                        t = Global::intersectParam[0];

                                if ((Global::intersectParam[0] < u) && (Global::intersectParam[0] > hoveredParam))
                                        u = Global::intersectParam[0];
                        }
                }

                toolParam[0] = t;
                toolParam[1] = u;
                toolPoint[0] = Geometry::GetPointForParameter(toolObj[0], t);
                toolPoint[1] = Geometry::GetPointForParameter(toolObj[0], u);
        }
                break;

        case ToolMouseUp:
        {
                // Bail out if there's no object to trim
                if (toolObj[0] == NULL)
                        return;

                Vector v(toolObj[0]->p[0], toolObj[0]->p[1]);

                // Check to see which case we have.
                if ((toolParam[0] == 0) && (toolParam[1] == 1.0))
                {
                        // There was no intersection, so delete the object
                        toolObj[0]->selected = true;
                        DeleteSelectedObjects(document.objects);
                }
                else if (toolParam[0] == 0)
                {
                        // We delete the end near point #1
                        toolObj[0]->p[0] = toolObj[0]->p[0] + (v * toolParam[1]);
                }
                else if (toolParam[1] == 1.0)
                {
                        // We delete the end near point #2
                        toolObj[0]->p[1] = toolObj[0]->p[0] + (v * toolParam[0]);
                }
                else
                {
                        // We delete the segment in between, and create a new line in the process
                        Point p1 = toolObj[0]->p[0] + (v * toolParam[0]);
                        Point p2 = toolObj[0]->p[0] + (v * toolParam[1]);
                        Point p3 = toolObj[0]->p[1];
                        toolObj[0]->p[1] = p1;
                        Line * l = new Line(p2, p3, toolObj[0]->thickness, toolObj[0]->color, toolObj[0]->style);
                        document.objects.push_back(l);
//                      Global::toolState = TSNone;
                }

                toolObj[0]->hitObject = toolObj[0]->hitPoint[0] = toolObj[0]->hitPoint[1] = false;
                toolObj[0] = NULL;
        }
                break;

        case ToolKeyDown:
                break;

        case ToolKeyUp:
                break;

        case ToolCleanup:
                break;
        }
}

void DrawingView::ParallelHandler(int mode, Point p)
{
        switch (mode)
        {
        case ToolMouseDown:
                if (numHovered == 1)
                {
                        // New selection made...
                        VPVector hover = GetHovered();
                        toolObj[0] = (Object *)hover[0];
                        Global::toolState = TSNone;
                }
                else if ((numHovered == 0) && (toolObj[0] != NULL))
                {
                        double length = Vector::Magnitude(toolObj[0]->p[0], toolPoint[0]);
                        bool inside = (length >= toolObj[0]->radius[0] ? false : true);

                        // Stamp out new parallel object(s)...
                        for(int i=1; i<=Global::parallelNum; i++)
                        {
                                if (toolObj[0]->type == OTLine)
                                {
                                        Line * l = new Line(toolObj[0]->p[0] + (toolPoint[0] * Global::parallelDist * (double)i), toolObj[0]->p[1] + (toolPoint[0] * Global::parallelDist * (double)i), Global::penWidth, Global::penColor, Global::penStyle);
                                        // Should probably have a user selection for this whether it goes into the selected objects layer or the global layer...
                                        l->layer = toolObj[0]->layer;
                                        document.objects.push_back(l);
                                }
                                else if (toolObj[0]->type == OTCircle)
                                {
                                        double radius = toolObj[0]->radius[0] + ((double)i * Global::parallelDist * (inside ?  -1.0 : 1.0));

                                        if (radius > 0)
                                        {
                                                Circle * c = new Circle(toolObj[0]->p[0], radius, Global::penWidth, Global::penColor, Global::penStyle);
                                                c->layer = toolObj[0]->layer;
                                                document.objects.push_back(c);
                                        }
                                }
                                else if (toolObj[0]->type == OTArc)
                                {
                                        double radius = toolObj[0]->radius[0] + ((double)i * Global::parallelDist * (inside ?  -1.0 : 1.0));

                                        if (radius > 0)
                                        {
                                                Arc * a = new Arc(toolObj[0]->p[0], radius, toolObj[0]->angle[0], toolObj[0]->angle[1], Global::penWidth, Global::penColor, Global::penStyle);
                                                a->layer = toolObj[0]->layer;
                                                document.objects.push_back(a);
                                        }
                                }
                        }

                        // Then reset the state
                        toolObj[0]->selected = false;
                        toolObj[0] = NULL;
                        Global::toolState = TSNone;
                }

                break;

        case ToolMouseMove:
                if ((numHovered == 0) && toolObj[0] != NULL)
                        Global::toolState = TSPoint1;
                else
                        Global::toolState = TSNone;

                if (Global::toolState == TSPoint1)
                {
                        // Figure out which side of the object we're on, and draw the preview on that side...
                        if (toolObj[0]->type == OTLine)
                        {
                                Vector normal = Geometry::GetNormalOfPointAndLine(p, (Line *)toolObj[0]);
                                toolPoint[0] = normal;
                        }
                        else if ((toolObj[0]->type == OTCircle) || (toolObj[0]->type == OTArc))
                        {
                                toolPoint[0] = p;
                        }
                }

                break;

        case ToolMouseUp:
                break;

        case ToolKeyDown:
                break;

        case ToolKeyUp:
                break;

        case ToolCleanup:
                break;
        }
}

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)
                {
                        if (hoveringIntersection)
                                point = intersectionPoint;
                        else if (hoverPointValid)
                                point = hoverPoint;
                        else if (Global::snapToGrid)
                                point = SnapPointToGrid(point);

                        ToolHandler(ToolMouseDown, point);
                        return;
                }

                // Clear the selection only if CTRL isn't being held on click
                if (!ctrlDown)
                        ClearSelected(document.objects);

                // If any objects are being hovered on click, deal with 'em
                if (numHovered > 0)
                {
                        VPVector hover2 = GetHovered();
                        dragged = (Object *)hover2[0];

                        // Alert the pen widget
                        if (Global::penDropper)
                        {
                                Global::penColor = dragged->color;
                                Global::penWidth = dragged->thickness;
                                Global::penStyle = dragged->style;
                                emit ObjectSelected(dragged);
                                return;
                        }
                        else if (Global::penStamp)
                        {
                                dragged->color = Global::penColor;
                                dragged->thickness = Global::penWidth;
                                dragged->style = Global::penStyle;
                                return;
                        }
                        // See if anything is using just a straight click on a custom
                        // object handle (like Dimension objects)
                        else if (HandleObjectClicked())
                        {
                                update();
                                return;
                        }

                        draggingObject = true;
                        HandleSelectionClick(hover2);
                        update();       // needed??

                        // Needed for grab & moving objects
                        // We do it *after*... why? (doesn't seem to confer any advantage...)
                        if (hoveringIntersection)
                                oldPoint = intersectionPoint;
                        else if (hoverPointValid)
                                oldPoint = hoverPoint;
                        else if (Global::snapToGrid)
                                oldPoint = SnapPointToGrid(point);

                        // Needed for fixed length handling
                        if (Global::fixedLength)
                        {
                                if (dragged->type == OTLine)
                                        dragged->length = ((Line *)dragged)->Length();
                        }

                        // Needed for fixed angle handling
                        if (Global::fixedAngle)
                        {
                                if (dragged->type == OTLine)
                                        dragged->p[2] = ((Line *)dragged)->Unit();
                        }

                        if (dragged->type == OTCircle)
                        {
                                // Save for informative text, uh, er, informing
                                dragged->length = dragged->radius[0];
                        }

                        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));
                select = GetSelection();
        }
        else if (event->button() == Qt::MiddleButton)
        {
                scrollDrag = true;
                oldPoint = Vector(event->x(), event->y());
                // Should also change the mouse pointer as well...
                setCursor(Qt::SizeAllCursor);
        }
}

void DrawingView::mouseMoveEvent(QMouseEvent * event)
{
        // It seems that wheelEvent() triggers this for some reason...
        if (scrollWheelSeen)
        {
                scrollWheelSeen = false;
                return;
        }

        Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->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;
        oldScrollPoint = Vector(event->x(), event->y());

        // Scrolling...
        if ((event->buttons() & Qt::MiddleButton) || scrollDrag)
        {
                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(oldPoint, point);
                delta /= Global::zoom;
                delta.y = -delta.y;
                Global::origin -= delta;

//              UpdateGridBackground();
                update();
                oldPoint = point;
                return;
        }

        // If we're doing a selection rect, see if any objects are engulfed by it
        // (implies left mouse button held down)
        if (Global::selectionInProgress)
        {
                CheckObjectBounds();

                // Make sure previously selected objects stay selected (CTRL held)
                for(VPVectorIter i=select.begin(); i!=select.end(); i++)
                {
                        // Make sure *not* to select items on hidden layers
                        if (Global::layerHidden[((Object *)(*i))->layer] == false)
                                ((Object *)(*i))->selected = true;
                }

                update();
                return;
        }

        // Do object hit testing...
        bool needUpdate = HitTestObjects(point);
        VPVector hover2 = GetHovered(true); // Exclude dimension objects and circle centers (probably need to add arc centers too) from hover (also dragged objects...)
#if 0
{
if (needUpdate)
{
        printf("mouseMoveEvent:: numHovered=%li, hover2.size()=%li\n", numHovered, hover2.size());

        if (hover2.size() > 0)
                printf("                 (hover2[0]=$%llX, type=%s)\n", hover2[0], objName[((Object *)hover2[0])->type]);
}
}
#endif

        // Check for multi-hover...
        if (hover2.size() > 1)
        {
//need to check for case where hover is over 2 circles and a 3rd's center (no longer a problem, I think)...
                Object * obj1 = (Object *)hover2[0], * obj2 = (Object *)hover2[1];

                Geometry::Intersects(obj1, obj2);
                int numIntersecting = Global::numIntersectParams;
                double t = Global::intersectParam[0];
                double u = Global::intersectParam[1];

                if (numIntersecting > 0)
                {
                        Vector v1 = Geometry::GetPointForParameter(obj1, t);
                        Vector v2 = Geometry::GetPointForParameter(obj2, 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)
                {
                        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;
                }
        }
        else if (hover2.size() == 1)
        {
                Object * obj = (Object *)hover2[0];

                if (obj->type == OTLine)
                {
/*
Not sure that this is the best way to handle this, but it works(TM)...
*/
                        Point midpoint = Geometry::Midpoint((Line *)obj);
                        Vector v1 = Vector::Magnitude(midpoint, point);

                        if ((v1.Magnitude() * Global::zoom) < 8.0)
                        {
                                QString text = tr("Midpoint <%1, %2>");
                                informativeText = text.arg(midpoint.x).arg(midpoint.y);
                                hoverPointValid = true;
                                hoverPoint = midpoint;
                                needUpdate = true;
                        }
                }
                else if (obj->type == OTCircle)
                {
                        if ((draggingObject && (dragged->type == OTLine)) && (dragged->hitPoint[0] || dragged->hitPoint[1]))
                        {
                                Point p = (dragged->hitPoint[0] ? dragged->p[1] : dragged->p[0]);
                                Geometry::FindTangents(obj, p);

                                if (Global::numIntersectPoints > 0)
                                {
                                        hoveringIntersection = true;
                                        intersectionPoint = Geometry::NearestTo(point, Global::intersectPoint[0], Global::intersectPoint[1]);
                                }
                        }
                        else if ((Global::tool == TTLine) && (Global::toolState == TSPoint2))
                        {
                                Geometry::FindTangents(obj, toolPoint[0]);

                                if (Global::numIntersectPoints > 0)
                                {
                                        hoveringIntersection = true;
                                        intersectionPoint = Geometry::NearestTo(point, Global::intersectPoint[0], Global::intersectPoint[1]);
                                }
                        }
                }
        }

        // Handle object movement (left button down & over an object)
        if ((event->buttons() & Qt::LeftButton) && draggingObject && !Global::tool)
        {
                if (hoveringIntersection)
                        point = intersectionPoint;
                else if (hoverPointValid)
                        point = hoverPoint;
                else if (Global::snapToGrid)
                        point = SnapPointToGrid(point);

                HandleObjectMovement(point);
                update();
                oldPoint = point;
                return;
        }

        // Do tool handling, if any are active...
        if (Global::tool)
        {
                if (hoveringIntersection)
                        point = intersectionPoint;
                else if (hoverPointValid)
                        point = hoverPoint;
                else if (Global::snapToGrid)
                {
                        if (angleSnap)
                                point = SnapPointToAngle(point);
                        else
                                point = SnapPointToGrid(point);
                }

                ToolHandler(ToolMouseMove, point);
        }

        // This is used to draw the tool crosshair...
        oldPoint = point;

        if (needUpdate || Global::tool)
                update();
}

void DrawingView::mouseReleaseEvent(QMouseEvent * event)
{
        if (event->button() == Qt::LeftButton)
        {
//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:
//              if (document.NeedsUpdate())
                // Do an update if collided with at least *one* object in the document
//              if (collided)
                        update();

                if (Global::tool)
                {
                        Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
                        ToolHandler(ToolMouseUp, point);
                        return;
                }

                Global::selectionInProgress = false;
                informativeText.clear();

// Should we be doing this automagically? Hmm...
                // Clear our vectors
//              select.clear();
////            hover.clear();

                // Scoop 'em up (do we need to??? Seems we do, because keyboard movement uses it.  Also, tools use it too.  But we can move it out of here [where to???])
                select = GetSelection();

                draggingObject = false;
        }
        else if (event->button() == Qt::MiddleButton)
        {
                scrollDrag = false;

                if (Global::penStamp)
                        setCursor(curMarker);
                else if (Global::penDropper)
                        setCursor(curDropper);
                else
                        setCursor(Qt::ArrowCursor);

                // Need to convert this, since it's in Qt coordinates (for wheelEvent)
                oldPoint = Painter::QtToCartesianCoords(oldPoint);
        }
}

void DrawingView::wheelEvent(QWheelEvent * event)
{
        double zoomFactor = 1.20;
        scrollWheelSeen = true;

        if (event->angleDelta().y() < 0)
        {
                if (Global::zoom > 400.0)
                        return;

                Global::zoom *= zoomFactor;
        }
        else
        {
                if (Global::zoom < 0.125)
                        return;

                Global::zoom /= zoomFactor;
        }

        Point np = Painter::QtToCartesianCoords(oldScrollPoint);
        Global::origin += (oldPoint - np);

        emit(NeedZoomUpdate());
}

void DrawingView::keyPressEvent(QKeyEvent * event)
{
        bool oldShift = shiftDown;
        bool oldCtrl = ctrlDown;
        bool oldAlt = altDown;

        if (event->key() == Qt::Key_Shift)
                shiftDown = true;
        else if (event->key() == Qt::Key_Control)
                ctrlDown = true;
        else if (event->key() == Qt::Key_Alt)
                altDown = true;

        // If there's a change in any of the modifier key states, pass it on to
        // the current tool's handler
        if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
        {
                if (Global::tool)
                        ToolHandler(ToolKeyDown, Point(0, 0));

                update();
        }

        if (oldAlt != altDown)
        {
                scrollDrag = true;
                setCursor(Qt::SizeAllCursor);
                oldPoint = oldScrollPoint;
        }

        if (select.size() > 0)
        {
                if (event->key() == Qt::Key_Up)
                {
                        TranslateObjects(select, Point(0, +1.0));
                        update();
                }
                else if (event->key() == Qt::Key_Down)
                {
                        TranslateObjects(select, Point(0, -1.0));
                        update();
                }
                else if (event->key() == Qt::Key_Right)
                {
                        TranslateObjects(select, Point(+1.0, 0));
                        update();
                }
                else if (event->key() == Qt::Key_Left)
                {
                        TranslateObjects(select, Point(-1.0, 0));
                        update();
                }
        }
}

void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
        bool oldShift = shiftDown;
        bool oldCtrl = ctrlDown;
        bool oldAlt = altDown;

        if (event->key() == Qt::Key_Shift)
                shiftDown = false;
        else if (event->key() == Qt::Key_Control)
                ctrlDown = false;
        else if (event->key() == Qt::Key_Alt)
                altDown = false;

        if ((oldShift != shiftDown) || (oldCtrl != ctrlDown))
        {
                if (Global::tool)
                        ToolHandler(ToolKeyUp, Point(0, 0));

                update();
        }

        if (oldAlt != altDown)
        {
                scrollDrag = false;

                if (Global::penStamp)
                        setCursor(curMarker);
                else if (Global::penDropper)
                        setCursor(curDropper);
                else
                        setCursor(Qt::ArrowCursor);
        }
}

//
// 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;
}

Point DrawingView::SnapPointToAngle(Point point)
{
        // Snap to a single digit angle (using toolpoint #1 as the center)
        double angle = Vector::Angle(toolPoint[0], point);
        double length = Vector::Magnitude(toolPoint[0], point);

        // Convert from radians to degrees
        double degAngle = angle * RADIANS_TO_DEGREES;
        double snapAngle = (double)((int)(degAngle + 0.5));

        Vector v;
        v.SetAngleAndLength(snapAngle * DEGREES_TO_RADIANS, length);
        point = toolPoint[0] + v;

        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:
        case OTDimension:
        {
                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 OTText:
        {
                Text * t = (Text *)obj;
                rect = Rect(t->p[0], Point(t->p[0].x + t->extents.Width(), t->p[0].y - t->extents.Height()));
                break;
        }

        case OTContainer:
        {
                Container * c = (Container *)obj;
                VPVectorIter 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)
{
        VPVectorIter i;

        for(i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                Object * obj = (Object *)(*i);
                obj->selected = false;

                switch (obj->type)
                {
                case OTLine:
                case OTDimension: // N.B.: We don't check this properly...
                {
                        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;
                }

                case OTText:
                {
                        Text * t = (Text *)obj;
                        Rect r(obj->p[0], Point(t->p[0].x + t->extents.Width(), t->p[0].y - t->extents.Height()));

                        if (Global::selection.contains(r.l, r.t) && Global::selection.contains(r.r, r.b))
                                t->selected = true;

                        break;
                }

                case OTContainer:
                {
                        Container * c = (Container *)obj;

                        if (Global::selection.contains(c->p[0].x, c->p[0].y) && Global::selection.contains(c->p[1].x, c->p[1].y))
                                c->selected = true;

                        break;
                }

//              default:
//                      break;
                }
        }
}

bool DrawingView::HitTestObjects(Point point)
{
        VPVectorIter i;
        numHovered = 0;
        bool needUpdate = false;
        hoverPointValid = false;

        for(i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                Object * obj = (Object *)(*i);

                // If we're seeing the object we're dragging, skip it
                if (draggingObject && (obj == dragged))
                        continue;

                if (HitTest(obj, point) == true)
                        needUpdate = true;

                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;
                        hoverPoint = obj->p[0];
                        hoverPointValid = true;
                }
                else if ((v2.Magnitude() * Global::zoom) < 8.0)
                {
                        obj->hitPoint[1] = true;
                        hoverPoint = obj->p[1];
                        hoverPointValid = 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;
                        hoverPoint = obj->p[0];
                        hoverPointValid = 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;
                        hoverPoint = obj->p[0];
                        hoverPointValid = true;
                }
                else if ((length2 * Global::zoom) < 8.0)
                {
                        obj->hitPoint[1] = true;
                        hoverPoint = handle1;
                        hoverPointValid = true;
                }
                else if ((length3 * Global::zoom) < 8.0)
                {
                        obj->hitPoint[2] = true;
                        hoverPoint = handle2;
                        hoverPointValid = 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 OTDimension:
        {
                bool oldHP0 = obj->hitPoint[0], oldHP1 = obj->hitPoint[1], oldHP2 = obj->hitPoint[2], oldHP3 = obj->hitPoint[3], oldHP4 = obj->hitPoint[4], oldHO = obj->hitObject;
                obj->hitPoint[0] = obj->hitPoint[1] = obj->hitPoint[2] = obj->hitPoint[3] = obj->hitPoint[4] = obj->hitObject = false;

                Dimension * d = (Dimension *)obj;

                Vector orthogonal = Vector::Normal(d->lp[0], d->lp[1]);
                // Get our line parallel to our points
                float scaledThickness = Global::scale * obj->thickness;
#if 1
                Point p1 = d->lp[0] + (orthogonal * (d->offset + (10.0 * scaledThickness)));
                Point p2 = d->lp[1] + (orthogonal * (d->offset + (10.0 * scaledThickness)));
#else
                Point p1 = d->lp[0] + (orthogonal * (10.0 + d->offset) * scaledThickness);
                Point p2 = d->lp[1] + (orthogonal * (10.0 + d->offset) * scaledThickness);
#endif
                Point p3(p1, point);

                Vector v1(d->p[0], point);
                Vector v2(d->p[1], point);
                Vector lineSegment(p1, p2);
                double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
                double distance;
                Point midpoint = (p1 + p2) / 2.0;
                Point hFSPoint = Point(midpoint, point);
                Point hCS1Point = Point((p1 + midpoint) / 2.0, point);
                Point hCS2Point = Point((midpoint + p2) / 2.0, point);

                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 * p3.y - p3.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;

                if ((hFSPoint.Magnitude() * Global::zoom) < 8.0)
                        obj->hitPoint[2] = true;
                else if ((hCS1Point.Magnitude() * Global::zoom) < 8.0)
                        obj->hitPoint[3] = true;
                else if ((hCS2Point.Magnitude() * Global::zoom) < 8.0)
                        obj->hitPoint[4] = true;

                obj->hovered = (obj->hitPoint[0] || obj->hitPoint[1] || obj->hitPoint[2] || obj->hitPoint[3] || obj->hitPoint[4] || obj->hitObject ? true : false);

                if ((oldHP0 != obj->hitPoint[0]) || (oldHP1 != obj->hitPoint[1]) || (oldHP2 != obj->hitPoint[2]) || (oldHP3 != obj->hitPoint[3]) || (oldHP4 != obj->hitPoint[4]) || (oldHO != obj->hitObject))
                        needUpdate = true;

                break;
        }

        case OTText:
        {
                Text * t = (Text *)obj;
                bool oldHO = obj->hitObject;
                obj->hitObject = false;

                Rect r(obj->p[0], Point(obj->p[0].x + t->extents.Width(), obj->p[0].y - t->extents.Height()));
//printf("Text: p=<%lf, %lf>, w/h=%lf, %lf [lrtb=%lf, %lf, %lf, %lf]\n", obj->p[0].x, obj->p[0].y, t->extents.Width(), t->extents.Height(), t->extents.l, t->extents.r, t->extents.t, t->extents.b);

                if (r.Contains(point))
                        obj->hitObject = true;

                obj->hovered = (obj->hitObject ? true : false);

                if (oldHO != obj->hitObject)
                        needUpdate = true;

                break;
        }

        case OTContainer:
        {
                // Containers must be recursively tested...  Or do they???
/*
So the idea here is to flatten the structure, *then* test the objects within.  Flattening includes the Containers as well; we can do this because it's pointers all the way down.
*/
//              bool oldHitObj = c->hitObject, oldHovered = c->hovered;
//              Object * oldClicked = c->clicked;
/*
still need to compare old state to new state, and set things up based upon that...
likely we can just rely on the object itself and steal its state like we have in the commented out portion below; can prolly rewrite the HitTest() portion to be one line: needUpdate = HitTest(cObj, point);
Well, you could if there was only one object in the Container.  But since there isn't, we have to keep the if HitTest() == true then needUpdate = true bit.  Because otherwise, a false result anywhere will kill the needed update elsewhere.
*/
                Container * c = (Container *)obj;
                c->hitObject = false;
                c->hovered = false;
                c->clicked = NULL;

                VPVector flat = Flatten(c);

//printf("HitTest::OTContainer (size=%li)\n", flat.size());
                for(VPVectorIter i=flat.begin(); i!=flat.end(); i++)
                {
                        Object * cObj = (Object *)(*i);

                        // Skip the flattened containers (if any)...
                        if (cObj->type == OTContainer)
                                continue;

                        // We do it this way instead of needUpdate = HitTest() because we
                        // are checking more than one object, and that way of doing will
                        // not return consistent results.
                        if (HitTest(cObj, point) == true)
//                      {
//printf("HitTest::OTContainer, subobj ($%llX) hit!\n", cObj);
                                needUpdate = true;
//                              c->hitObject = true;
//                              c->clicked = cObj;
//                              c->hovered = true;
//                      }

                        // Same reasons for doing it this way here apply.
                        if (cObj->hitObject == true)
                        {
//printf("HitTest::cObj->hitObject == true! ($%llX)\n", cObj);
                                c->hitObject = true;
                                c->clicked = cObj;
                        }//*/

                        if (cObj->hitPoint[0] == true)
                        {
//printf("HitTest::cObj->hitObject == true! ($%llX)\n", cObj);
                                c->hitPoint[0] = true;
                                c->clicked = cObj;
                        }//*/

                        if (cObj->hitPoint[1] == true)
                        {
//printf("HitTest::cObj->hitObject == true! ($%llX)\n", cObj);
                                c->hitPoint[1] = true;
                                c->clicked = cObj;
                        }//*/

                        if (cObj->hitPoint[2] == true)
                        {
//printf("HitTest::cObj->hitObject == true! ($%llX)\n", cObj);
                                c->hitPoint[2] = true;
                                c->clicked = cObj;
                        }//*/

                        if (cObj->hovered == true)
                                c->hovered = true;//*/
                }

                break;
        }

        default:
                break;
        }

        return needUpdate;
}

bool DrawingView::HandleObjectClicked(void)
{
        if (dragged->type == OTDimension)
        {
                Dimension * d = (Dimension *)dragged;

                if (d->hitPoint[2])
                {
                        // Hit the "flip sides" switch, so flip 'em
                        Point temp = d->p[0];
                        d->p[0] = d->p[1];
                        d->p[1] = temp;
                        return true;
                }
                else if (d->hitPoint[3])
                {
                        // There are three cases here: aligned, horizontal, & vertical.
                        // Aligned and horizontal do the same thing, vertical goes back to
                        // linear.
                        if (d->subtype == DTLinearVert)
                                d->subtype = DTLinear;
                        else
                                d->subtype = DTLinearVert;

                        return true;
                }
                else if (d->hitPoint[4])
                {
                        // There are three cases here: aligned, horizontal, & vertical.
                        // Aligned and vertical do the same thing, horizontal goes back to
                        // linear.
                        if (d->subtype == DTLinearHorz)
                                d->subtype = DTLinear;
                        else
                                d->subtype = DTLinearHorz;

                        return true;
                }
        }

        return false;
}

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];
        Object * obj = dragged;
//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])
                {
/*
N.B.: Mixing fixed length with fixed angle (and in this order) is probably *not* going to work out in any meaningful way, and we should probably make the GUI force these to be mutually exclusive.  Besides, this combined effect already works by dragging the line segment by clicking on it.  :-P
*/
                        if (Global::fixedLength)
                        {
                                Vector unit = Vector::Unit(obj->p[1], point);
                                point = obj->p[1] + (unit * obj->length);
                        }

                        if (Global::fixedAngle)
                        {
                                // Calculate the component of the current vector along the
                                // fixed angle: A_compB = (A • Bu) * Bu  (p[2] has the unit
                                // vector "Bu".)
                                double magnitudeAlongB = Vector::Dot(Vector(point - obj->p[1]), obj->p[2]);
                                point = obj->p[1] + (obj->p[2] * magnitudeAlongB);
                        }

                        obj->p[0] = point;
                }
                else if (obj->hitPoint[1])
                {
                        if (Global::fixedLength)
                        {
                                Vector unit = Vector::Unit(obj->p[0], point);
                                point = obj->p[0] + (unit * obj->length);
                        }

                        if (Global::fixedAngle)
                        {
                                double magnitudeAlongB = Vector::Dot(Vector(point - obj->p[0]), obj->p[2]);
                                point = obj->p[0] + (obj->p[2] * magnitudeAlongB);
                        }

                        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)
                {
                        double oldRadius = obj->length;
                        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 OTDimension:
                if (obj->hitPoint[0])
                        obj->p[0] = point;
                else if (obj->hitPoint[1])
                        obj->p[1] = point;
                else if (obj->hitObject)
                {
                        // Move measurement lines in/out
                        if (shiftDown)
                        {
                                Dimension * d = (Dimension *)obj;
                                double dist = Geometry::DistanceToLineFromPoint(d->lp[0], d->lp[1], point);
                                float scaledThickness = Global::scale * obj->thickness;
                                // Looks like offset is 0 to +MAX, but line is at 10.0.  So
                                // anything less than 10.0 should set the offset to 0.
                                d->offset = 0;

                                if (dist > (10.0 * scaledThickness))
                                        d->offset = dist - (10.0 * scaledThickness);
                        }
                        else
                        {
                                obj->p[0] += delta;
                                obj->p[1] += delta;
                        }
                }

                break;

        case OTText:
                if (obj->hitObject)
                        obj->p[0] += delta;

                break;

        case OTContainer:
                // This is shitty, but works for now until I can code up something
                // nicer :-)
/*
The idea is to make it so whichever point on the object in question is being dragged becomes the snap point for the container; shouldn't be too difficult to figure out how to do this.
*/
//              TranslateObject(obj, delta);
                TranslateContainer((Container *)obj, point, delta);

                break;
        default:
                break;
        }
}

void DrawingView::AddDimensionTo(void * o)
{
        Object * obj = (Object *)o;

        switch (obj->type)
        {
        case OTLine:
                document.Add(new Dimension(obj->p[0], obj->p[1]));
                break;
        case OTCircle:
                break;
        case OTEllipse:
                break;
        case OTArc:
                break;
        case OTSpline:
                break;
        }
}