[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 "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), /*numSelected(0),*/ numHovered(0), shiftDown(false),
        ctrlDown(false), altDown(false),
        gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
        scale(1.0), offsetX(-10), offsetY(-10), 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);

        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! :-)

*/
        SetGridSize(12);        // This is in pixels
}


void DrawingView::SetGridSize(uint32_t size)
{
        // Sanity check
        if (size == gridPixels)
                return;

        // Recreate the background bitmap
        gridPixels = size;
        QPainter pmp(&gridBackground);
        pmp.fillRect(0, 0, BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE, QColor(240, 240, 240));
        pmp.setPen(QPen(QColor(210, 210, 255), 2.0, Qt::SolidLine));

        for(int i=0; i<(BACKGROUND_MAX_SIZE-1); i+=gridPixels)
        {
                pmp.drawLine(i, 0, i, BACKGROUND_MAX_SIZE - 1);
                pmp.drawLine(0, i, BACKGROUND_MAX_SIZE - 1, i);
        }

        pmp.end();

        // Set up new BG brush & zoom level (pixels per base unit)
        Global::zoom = gridPixels / Global::gridSpacing;
        UpdateGridBackground();
}


void DrawingView::UpdateGridBackground(void)
{
        // Transform the origin to Qt coordinates
        Vector pixmapOrigin = Painter::CartesianToQtCoords(Vector());
        int x = (int)pixmapOrigin.x;
        int y = (int)pixmapOrigin.y;
        // Use mod arithmetic to grab the correct swatch of background
/*
Negative numbers still screw it up... Need to think about what we're
trying to do here. The fact that it worked with 72 seems to have been pure luck.
It seems the problem is negative numbers: We can't let that happen.
When taking away the zero, it pops over 1 px at zero, then goes about 1/2 a
grid at x<0.

The bitmap looks like this:

+---+---+---+---+---
|   |   |   |   |
|   |   |   |   |
+---+---+---+---+---
|   |   |   |   |
|   |   |   |   |
|   |   |   |   |

@ x = 1, we want it to look like:

-+---+---+---+---+---
 |   |   |   |   |
 |   |   |   |   |
-+---+---+---+---+---
 |   |   |   |   |
 |   |   |   |   |
 |   |   |   |   |

Which means we need to grab the sample from x = 3. @ x = -1:

---+---+---+---+---
   |   |   |   |
   |   |   |   |
---+---+---+---+---
   |   |   |   |
   |   |   |   |
   |   |   |   |

Which means we need to grab the sample from x = 1. Which means we have to take
the mirror of the modulus of gridPixels.

Doing a mod of a negative number is problematic: 1st, the compiler converts the
negative number to an unsigned int, then it does the mod. Gets you wrong answers
most of the time, unless you use a power of 2. :-P So what we do here is just
take the modulus of the negation, which means we don't have to worry about
mirroring it later.

The positive case looks gruesome (and it is) but it boils down to this: We take
the modulus of the X coordinate, then mirror it by subtraction from the
maximum (in this case, gridPixels). This gives us a number in the range of 1 to
gridPixels. But we need the case where the result equalling gridPixels to be
zero; so we do another modulus operation on the result to achieve this.
*/
        if (x < 0)
                x = -x % gridPixels;
        else
                x = (gridPixels - (x % gridPixels)) % gridPixels;

        if (y < 0)
                y = -y % gridPixels;
        else
                y = (gridPixels - (y % gridPixels)) % gridPixels;

        // Here we grab a section of the bigger pixmap, so that the background
        // *looks* like it's scrolling...
        QPixmap pm = gridBackground.copy(x, y, gridPixels, gridPixels);
        QPalette pal = palette();
        pal.setBrush(backgroundRole(), QBrush(pm));
        setAutoFillBackground(true);
        setPalette(pal);
}


//
// 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)
{
//printf("DrawingView::DeleteCurrentLayer(): currentLayer = %i\n", layer);
        std::vector<void *>::iterator 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)
{
//printf("DrawingView: Swapping layers %i and %i.\n", layer1, layer2);
        std::vector<void *>::iterator i;

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

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


void DrawingView::HandlePenWidth(float width)
{
        std::vector<void *>::iterator i = select.begin();

        for(; i!=select.end(); i++)
        {
                Object * obj = (Object *)(*i);
                obj->thickness = width;
        }
}


void DrawingView::HandlePenStyle(int style)
{
        std::vector<void *>::iterator i = select.begin();

        for(; i!=select.end(); i++)
        {
                Object * obj = (Object *)(*i);
                obj->style = style;
        }
}


void DrawingView::HandlePenColor(uint32_t color)
{
        std::vector<void *>::iterator i = select.begin();

        for(; i!=select.end(); i++)
        {
                Object * obj = (Object *)(*i);
                obj->color = color;
        }
}


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*/)
{
//      printf("DrawingView::focusOutEvent()...\n");
        // 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::paintEvent(QPaintEvent * /*event*/)
{
        QPainter qtPainter(this);
        Painter painter(&qtPainter);

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

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

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

        // 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)
        {
                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(255, 127, 0, 255)));
                painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
                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, std::vector<void *> & v, int layer, bool ignoreLayer/*= false*/)
{
        std::vector<void *>::iterator i;

        for(i=v.begin(); i!=v.end(); i++)
        {
                Object * obj = (Object *)(*i);
                float scaledThickness = Global::scale * obj->thickness;

                // If the object isn't on the current layer being drawn, skip it
                if (!ignoreLayer && (obj->layer != layer))
                        continue;

                if ((Global::tool == TTRotate) && ctrlDown && obj->selected)
                {
                        painter->SetPen(0x00FF00, 2.0, LSSolid);
                }
                else
                {
                        painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
                        painter->SetBrush(obj->color);

                        if (obj->selected || obj->hitObject)
                                painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash);
                }

                switch (obj->type)
                {
                case OTLine:
                        painter->DrawLine(obj->p[0], obj->p[1]);

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

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

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

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


void DrawingView::AddHoveredToSelection(void)
{
        std::vector<void *>::iterator i;

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


void DrawingView::GetSelection(std::vector<void *> & v)
{
        v.clear();
        std::vector<void *>::iterator i;

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


#if 0
void DrawingView::GetHovered(std::vector<void *> & v)
{
        v.clear();
        std::vector<void *>::iterator i;

        for(i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                if (((Object *)(*i))->hovered)
//              {
//printf("GetHovered: adding object (%X) to hover... hp1=%s, hp2=%s, hl=%s\n", (*i), (((Line *)(*i))->hitPoint[0] ? "true" : "false"), (((Line *)(*i))->hitPoint[1] ? "true" : "false"), (((Line *)(*i))->hitObject ? "true" : "false"));
                        v.push_back(*i);
//              }
        }
}
#endif


std::vector<void *> DrawingView::GetHovered(void)
{
        std::vector<void *> v;
        std::vector<void *>::iterator i;

        for(i=document.objects.begin(); i!=document.objects.end(); i++)
        {
                if (((Object *)(*i))->hovered)
//              {
//printf("GetHovered: adding object (%X) to hover... hp1=%s, hp2=%s, hl=%s\n", (*i), (((Line *)(*i))->hitPoint[0] ? "true" : "false"), (((Line *)(*i))->hitPoint[1] ? "true" : "false"), (((Line *)(*i))->hitObject ? "true" : "false"));
                        v.push_back(*i);
//              }
        }

        return v;
}


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


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 == 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)";
                }
        }
        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);
                }
        }
}


void DrawingView::LineHandler(int mode, Point p)
{
        switch (mode)
        {
        case ToolMouseDown:
                if (Global::toolState == TSNone)
                        toolPoint[0] = p;
                else
                        toolPoint[1] = p;

                break;

        case ToolMouseMove:
                if (Global::toolState == TSNone)
                        toolPoint[0] = p;
                else
                        toolPoint[1] = p;

                break;

        case ToolMouseUp:
                if (Global::toolState == TSNone)
                {
                        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();
                        std::vector<void *>::iterator j = select.begin();
//                      std::vector<Object>::iterator i = toolScratch.begin();
                        std::vector<void *>::iterator 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;
                                        std::vector<void *>::iterator l = c->objects.begin();
                                        // TODO: Rotate items in the container
                                        // TODO: Make this recursive
                                        for(std::vector<void *>::iterator 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
                                std::vector<void *> 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();
                        std::vector<void *>::iterator j = select.begin();
                        std::vector<Object>::iterator i = toolScratch.begin();

                        for(; i!=toolScratch.end(); i++, j++)
                        {
                                Object obj = *i;
                                Point p1 = Geometry::MirrorPointAroundLine(obj.p[0], toolPoint[0], toolPoint[1]);
                                Point p2 = Geometry::MirrorPointAroundLine(obj.p[1], toolPoint[0], toolPoint[1]);
                                Object * obj2 = (Object *)(*j);
                                obj2->p[0] = p1;
                                obj2->p[1] = p2;

/*
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
                                std::vector<void *> temp;
                                CopyObjects(select, temp);
                                ClearSelected(temp);
                                AddObjectsTo(document.objects, temp);
                                RestorePointsTo(select, toolScratch);
                                return;
                        }

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

                break;

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

                break;

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

                break;

        case ToolCleanup:
                RestorePointsTo(select, toolScratch);
        }
}


void DrawingView::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);
                        d->layer = Global::activeLayer;
                        document.objects.push_back(d);
                        Global::toolState = TSNone;
                }
        }
}


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

                std::vector<void *> 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)
{
/*
n.b.: this code is lifted straight out of the old oo code.  needs to be updated.
*/
        switch (mode)
        {
        case ToolMouseDown:
        {
#if 0
                Object * toTrim = doc->lastObjectHovered;

                if (toTrim == NULL)
                        return;

                Vector v(((Line *)toTrim)->position, ((Line *)toTrim)->endpoint);

                // Check to see which case we have...
                // We're trimming point #1...
                if (t == 0)
                {
                        ((Line *)toTrim)->position = ((Line *)toTrim)->position + (v * u);
                }
                else if (u == 1.0)
                {
                        ((Line *)toTrim)->endpoint = ((Line *)toTrim)->position + (v * t);
                }
                else
                {
                        Point p1 = ((Line *)toTrim)->position + (v * t);
                        Point p2 = ((Line *)toTrim)->position + (v * u);
                        Point p3 = ((Line *)toTrim)->endpoint;
                        ((Line *)toTrim)->endpoint = p1;
                        Line * line = new Line(p2, p3);
                        emit ObjectReady(line);
                }

                doc->lastObjectHovered = NULL;
#endif
        }
                break;

        case ToolMouseMove:
        {
#if 0
                Object * toTrim = doc->lastObjectHovered;
                t = 0, u = 1.0;

                if (toTrim == NULL)
                        return;

                if (toTrim->type != OTLine)
                        return;

                double pointHoveredT = Geometry::ParameterOfLineAndPoint(((Line *)toTrim)->position, ((Line *)toTrim)->endpoint, point);

                std::vector<Object *>::iterator i;

                for(i=doc->objects.begin(); i!=doc->objects.end(); i++)
                {
                        // Can't trim against yourself... :-P
                        if (*i == toTrim)
                                continue;

                        Object * trimAgainst = *i;
                        double t1;//, u1;

                        if ((toTrim->type != OTLine) || (trimAgainst->type != OTLine))
                                continue;

                        int intersects = Geometry::Intersects((Line *)toTrim, (Line *)trimAgainst, &t1);//, &u1);

                        if (intersects)
                        {
                                // Now what? We don't know which side to trim!
                                // ... now we do, we know which side of the Line we're on!
                                if ((t1 > t) && (t1 < pointHoveredT))
                                        t = t1;

                                if ((t1 < u) && (t1 > pointHoveredT))
                                        u = t1;
                        }
                }
#endif
                // Bail out if nothing hovered...
                if (numHovered != 1)
                {
                        toolObj[0] = NULL;
                        return;
                }

                std::vector<void *> 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);

                // Currently only deal with line against line trimming, can expand to
                // others as well (line/circle, circle/circle, line/arc, etc)
                std::vector<void *>::iterator 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)
                        {
                                // Mark the line segment somehow (the side the mouse is on) so that it can be drawn & trimmed when we hit ToolMouseDown.
                        }
                }
        }
                break;

        case ToolMouseUp:
                break;

        case ToolKeyDown:
                break;

        case ToolKeyUp:
                break;

        case ToolCleanup:
                break;
        }
}


void DrawingView::ParallelHandler(int mode, Point /*p*/)
{
        switch (mode)
        {
        case ToolMouseDown:
                break;

        case ToolMouseMove:
                break;

        case ToolMouseUp:
                break;

        case ToolKeyDown:
                break;

        case ToolKeyUp:
                break;

        case ToolCleanup:
                break;
        }
}


void DrawingView::mousePressEvent(QMouseEvent * event)
{
        if (event->button() == Qt::LeftButton)
        {
printf("mousePressEvent::Qt::LeftButton numHovered=%li\n", numHovered);
                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);

                        //Also, may want to figure out if hovering over a snap point on an
                        //object, snap to grid if not.
                        // Snap to object point if valid...
//                      if (Global::snapPointIsValid)
//                              point = Global::snapPoint;

                        ToolHandler(ToolMouseDown, point);
                        return;
                }

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

                // If any objects are being hovered on click, add them to the selection
                // & return
                if (numHovered > 0)
                {
                        AddHoveredToSelection();
                        update();       // needed??
//                      GetHovered(hover);      // prolly needed
                        std::vector<void *> hover2 = GetHovered();
                        dragged = (Object *)hover2[0];
                        draggingObject = true;
printf("mousePressEvent::numHovered > 0 (hover2[0]=$%llx, type=%s)\n", dragged, objName[dragged->type]);

                        // Alert the pen widget
                        emit ObjectSelected(dragged);

                        // See if anything is using just a straight click on a handle
                        if (HandleObjectClicked())
                        {
                                draggingObject = false;
                                update();
                                return;
                        }

                        // 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 = Vector::Magnitude(dragged->p[0], dragged->p[1]);
                                }
                        }

                        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));
        }
        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)
{
        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();
                update();
                return;
        }

        // Do object hit testing...
        bool needUpdate = HitTestObjects(point);
//      GetHovered(hover);
        std::vector<void *> hover2 = GetHovered();
{
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]);
}
}

        // Check for multi-hover...
        if (numHovered > 1)
        {
//need to check for case where hover is over 2 circles and a 3rd's center...
                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 (numHovered == 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)...
Except when lines are overlapping, then it doesn't work... !!! FIX !!!
*/
                        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;
                        }
                }
        }

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

                if (Global::selectionInProgress)
                        Global::selectionInProgress = false;

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

                // Scoop 'em up
                std::vector<void *>::iterator i;

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

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


void DrawingView::wheelEvent(QWheelEvent * event)
{
        double zoomFactor = 1.25;
        QSize sizeWin = size();
        Vector center(sizeWin.width() / 2.0, sizeWin.height() / 2.0);
        center = Painter::QtToCartesianCoords(center);

        // This is not centering for some reason. Need to figure out why. :-/
        if (event->delta() > 0)
        {
                Vector newOrigin = center - ((center - Global::origin) / zoomFactor);
                Global::origin = newOrigin;
                Global::zoom *= zoomFactor;
        }
        else
        {
                Vector newOrigin = center + ((-center + Global::origin) * zoomFactor);
                Global::origin = newOrigin;
                Global::zoom /= zoomFactor;
        }

//      Global::gridSpacing = gridPixels / Painter::zoom;
//      UpdateGridBackground();
        SetGridSize(Global::gridSpacing * Global::zoom);
        update();
//      zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
}


void DrawingView::keyPressEvent(QKeyEvent * event)
{
        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 ((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;
                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;
                std::vector<void *>::iterator i = c->objects.begin();
                rect = GetObjectExtents((Object *)*i);
                i++;

                for(; i!=c->objects.end(); i++)
                        rect |= GetObjectExtents((Object *)*i);
        }

        default:
                break;
        }

        return rect;
}


void DrawingView::CheckObjectBounds(void)
{
        std::vector<void *>::iterator i;

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

                switch (obj->type)
                {
                case OTLine:
                case OTDimension:
                {
                        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)
{
        std::vector<void *>::iterator 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;
                Point p1 = d->lp[0] + (orthogonal * (10.0 + d->offset) * scaledThickness);
                Point p2 = d->lp[1] + (orthogonal * (10.0 + d->offset) * scaledThickness);
                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;

                std::vector<void *> flat = Flatten(c);

//printf("HitTest::OTContainer (size=%li)\n", flat.size());
                for(std::vector<void *>::iterator 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->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])
                {
                        if (Global::fixedLength)
                        {
                                Vector line = point - obj->p[1];
                                Vector unit = line.Unit();
                                point = obj->p[1] + (unit * obj->length);
                        }

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

                        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)
                {
                        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;
        }
}