Added 'delete selected objects' functionality back.

[architektonas] / src / drawingview.cpp

// drawingview.cpp
//
// Part of the Architektonas Project
// (C) 2011 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]
//
// STILL TO BE DONE:
//
// - Lots of stuff
//

// 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"


#define BACKGROUND_MAX_SIZE     512

// Class variable
//Container DrawingView::document(Vector(0, 0));


DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
        // The value in the settings file will override this.
        useAntialiasing(true), numSelected(0),
        gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
        scale(1.0), offsetX(-10), offsetY(-10),// document(Vector(0, 0)),
        gridPixels(0), collided(false)//, toolAction(NULL)
{
//      document.isTopLevelContainer = true;
//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)

#if 0
        Line * line = new Line(Vector(5, 5), Vector(50, 40), &document);
        document.Add(line);
        document.Add(new Line(Vector(50, 40), Vector(10, 83), &document));
        document.Add(new Line(Vector(10, 83), Vector(17, 2), &document));
        document.Add(new Circle(Vector(100, 100), 36, &document));
        document.Add(new Circle(Vector(50, 150), 49, &document));
        document.Add(new Arc(Vector(300, 300), 32, PI / 4.0, PI * 1.3, &document)),
        document.Add(new Arc(Vector(200, 200), 60, PI / 2.0, PI * 1.5, &document));
#if 1
        Dimension * dimension = new Dimension(Vector(0, 0), Vector(0, 0), DTLinear, &document);
        line->SetDimensionOnLine(dimension);
        document.Add(dimension);
#else
        // Alternate way to do the above...
        line->SetDimensionOnLine();
#endif
#else
        Line * line = new Line;//(Vector(5, 5), Vector(50, 40), &document);
        line->p1 = Vector(5, 5);
        line->p2 = Vector(50, 40);
        line->type = OTLine;
        line->thickness = 2.0;
        line->style = LSDash;
        line->color = 0xFF7F00;
        document.objects.push_back(line);
        document.objects.push_back(new Line(Vector(50, 40), Vector(10, 83)));
        document.objects.push_back(new Line(Vector(10, 83), Vector(17, 2)));
        document.objects.push_back(new Circle(Vector(100, 100), 36));
        document.objects.push_back(new Circle(Vector(50, 150), 49));
        document.objects.push_back(new Arc(Vector(300, 300), 32, PI / 4.0, PI * 1.3)),
        document.objects.push_back(new Arc(Vector(200, 200), 60, PI / 2.0, PI * 1.5));
        document.objects.push_back(new Dimension(Vector(50, 40), Vector(5, 5)));
        document.objects.push_back(new Text(Vector(10, 83), "Here is some awesome text!"));
#endif

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


#if 0
void DrawingView::SetToolActive(Action * action)
{
        if (action != NULL)
        {
                toolAction = action;
                connect(toolAction, SIGNAL(ObjectReady(Object *)), this,
                        SLOT(AddNewObjectToDocument(Object *)));
                connect(toolAction, SIGNAL(NeedRefresh()), this, SLOT(HandleActionUpdate()));
        }
}
#endif


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)
//      Painter::zoom = gridPixels / gridSpacing;
        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);
}


void DrawingView::AddNewObjectToDocument(Object * object)
{
        if (object)
        {
//              object->Reparent(&document);
//              document.Add(object);
                update();
        }
//printf("DrawingView::AddNewObjectToDocument(). object=%08X\n", object);
}


void DrawingView::HandleActionUpdate(void)
{
        update();
}


void DrawingView::SetCurrentLayer(int layer)
{
        Global::currentLayer = layer;
//printf("DrawingView::CurrentLayer = %i\n", layer);
}


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


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

        // The top level document takes care of rendering for us...
//      document.Draw(&painter);
        // Not any more it doesn't...
        RenderObjects(&painter, &document);

#if 0
        if (toolAction)
        {
                painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
                painter.DrawCrosshair(oldPoint);
                toolAction->Draw(&painter);
        }
#endif

#if 1
        if (Global::selectionInProgress)
        {
                painter.SetPen(QPen(QColor(255, 127, 0, 255)));
                painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
                painter.DrawRect(Global::selection);
        }
#endif
}


void DrawingView::RenderObjects(Painter * painter, Container * c)
{
        std::vector<void *>::iterator i;

        for(i=c->objects.begin(); i!=c->objects.end(); i++)
        {
                Object * obj = (Object *)(*i);
                float scaledThickness = Global::scale * obj->thickness;
                painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
                painter->SetBrush(obj->color);

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

                switch (obj->type)
                {
                case OTLine:
                {
                        Line * l = (Line *)obj;
                        painter->DrawLine(l->p1, l->p2);
                        break;
                }
                case OTCircle:
                {
                        Circle * ci = (Circle *)obj;
                        painter->SetBrush(QBrush(Qt::NoBrush));
                        painter->DrawEllipse(ci->p1, ci->radius, ci->radius);
                        break;
                }
                case OTArc:
                {
                        Arc * a = (Arc *)obj;
                        painter->DrawArc(a->p1, a->radius, a->angle1, a->angle2);
                        break;
                }
                case OTDimension:
                {
                        Dimension * d = (Dimension *)obj;

                        Vector v(d->p1, d->p2);
                        double angle = v.Angle();
                        Vector unit = v.Unit();
                        Vector linePt1 = d->p1, linePt2 = d->p2;
                        Vector ortho;
                        double x1, y1, length;

                        if (d->subtype == DTLinearVert)
                        {
                                if ((angle < 0) || (angle > PI))
                                {
                                        x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x);
                                        y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y);
                                        ortho = Vector(1.0, 0);
                                        angle = PI3_OVER_2;
                                }
                                else
                                {
                                        x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x);
                                        y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y);
                                        ortho = Vector(-1.0, 0);
                                        angle = PI_OVER_2;
                                }

                                linePt1.x = linePt2.x = x1;
                                length = fabs(d->p1.y - d->p2.y);
                        }
                        else if (d->subtype == DTLinearHorz)
                        {
                                if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
                                {
                                        x1 = (d->p1.x > d->p2.x ? d->p1.x : d->p2.x);
                                        y1 = (d->p1.y > d->p2.y ? d->p1.y : d->p2.y);
                                        ortho = Vector(0, 1.0);
                                        angle = 0;
                                }
                                else
                                {
                                        x1 = (d->p1.x > d->p2.x ? d->p2.x : d->p1.x);
                                        y1 = (d->p1.y > d->p2.y ? d->p2.y : d->p1.y);
                                        ortho = Vector(0, -1.0);
                                        angle = PI;
                                }

                                linePt1.y = linePt2.y = y1;
                                length = fabs(d->p1.x - d->p2.x);
                        }
                        else if (d->subtype == DTLinear)
                        {
                                angle = Vector(linePt1, linePt2).Angle();
                                ortho = Vector::Normal(linePt1, linePt2);
                                length = v.Magnitude();
                        }

                        unit = Vector(linePt1, linePt2).Unit();

                        Point p1 = linePt1 + (ortho * 10.0 * scaledThickness);
                        Point p2 = linePt2 + (ortho * 10.0 * scaledThickness);
                        Point p3 = linePt1 + (ortho * 16.0 * scaledThickness);
                        Point p4 = linePt2 + (ortho * 16.0 * scaledThickness);
                        Point p5 = d->p1 + (ortho * 4.0 * scaledThickness);
                        Point p6 = d->p2 + (ortho * 4.0 * scaledThickness);

                /*
                The numbers hardcoded into here, what are they?
                I believe they are pixels.
                */
                        // Draw extension lines (if certain type)
                        painter->DrawLine(p3, p5);
                        painter->DrawLine(p4, p6);

                        // Calculate whether or not the arrowheads are too crowded to put inside
                        // the extension lines. 9.0 is the length of the arrowhead.
                        double t = Geometry::ParameterOfLineAndPoint(linePt1, linePt2, linePt2 - (unit * 9.0 * scaledThickness));
                //printf("Dimension::Draw(): t = %lf\n", t);

                // On the screen, it's acting like this is actually 58%...
                // This is correct, we want it to happen at > 50%
                        if (t > 0.58)
                        {
                                // Draw main dimension line + arrowheads
                                painter->DrawLine(p1, p2);
                                painter->DrawArrowhead(p1, p2, scaledThickness);
                                painter->DrawArrowhead(p2, p1, scaledThickness);
                        }
                        else
                        {
                                // Draw outside arrowheads
                                Point p7 = p1 - (unit * 9.0 * scaledThickness);
                                Point p8 = p2 + (unit * 9.0 * scaledThickness);
                                painter->DrawArrowhead(p1, p7, scaledThickness);
                                painter->DrawArrowhead(p2, p8, scaledThickness);
                                painter->DrawLine(p1, p1 - (unit * 14.0 * scaledThickness));
                                painter->DrawLine(p2, p2 + (unit * 14.0 * scaledThickness));
                        }

                        // Draw length of dimension line...
                        painter->SetFont(QFont("Arial", 8.0 * Global::zoom * scaledThickness));
                        Point ctr = p2 + (Vector(p2, p1) / 2.0);

                #if 0
                        QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
                #else
                        QString dimText;

                        if (length < 12.0)
                                dimText = QString("%1\"").arg(length);
                        else
                        {
                                double feet = (double)((int)length / 12);
                                double inches = length - (feet * 12.0);

                                if (inches == 0)
                                        dimText = QString("%1'").arg(feet);
                                else
                                        dimText = QString("%1' %2\"").arg(feet).arg(inches);
                        }
                #endif

                        painter->DrawAngledText(ctr, angle, dimText, scaledThickness);

                        break;
                }
                case OTText:
                {
                        Text * t = (Text *)obj;
                        painter->DrawTextObject(t->p1, t->s.c_str(), scaledThickness);
                        break;
                }
                default:
                        break;
                }
        }
}


void DrawingView::DeleteSelectedItems(void)
{
        std::vector<void *>::iterator i = document.objects.begin();

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

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


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


void DrawingView::mousePressEvent(QMouseEvent * event)
{
        if (event->button() == Qt::LeftButton)
        {
                Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
//              collided = document.Collided(point);
                collided = false;

                // Do an update if collided with at least *one* object in the document
//              if (collided)
//                      update();

#if 0
                if (toolAction)
                {
                        if (Global::snapToGrid)
                                point = Global::SnapPointToGrid(point);

                        // We always snap to object points, and they take precendence over
                        // grid points...
                        if (Global::snapPointIsValid)
                                point = Global::snapPoint;

                        toolAction->MouseDown(point);
                }
#endif

#if 1
                // Didn't hit any object and not using a tool, so do a selection rectangle
                if (!(collided))// || toolAction))
                {
                        Global::selectionInProgress = true;
                        Global::selection.setTopLeft(QPointF(point.x, point.y));
                        Global::selection.setBottomRight(QPointF(point.x, point.y));
                }
#endif
        }
        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;

        // Scrolling...
        if (event->buttons() & Qt::MiddleButton)
        {
                point = Vector(event->x(), event->y());
                // Since we're using Qt coords for scrolling, we have to adjust them here to
                // conform to Cartesian coords, since the origin is using Cartesian. :-)
                Vector delta(oldPoint, point);
                delta /= Global::zoom;
                delta.y = -delta.y;
                Global::origin -= delta;

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

#if 1
        // Grid processing... (only snap here is left button is down)
        if ((event->buttons() & Qt::LeftButton) && Global::snapToGrid)
        {
                point = SnapPointToGrid(point);
        }

        // Snap points on objects always take precedence over the grid, whether
        // dragging an object or not...
//thisnowok
        if (Global::snapPointIsValid)
        {
// Uncommenting this causes the cursor to become unresponsive after the first
// object is added.
//              point = Global::snapPoint;
        }
#endif

        // Do checking here to see if object can be selected or not
        if (Global::selectionInProgress)
        {
                std::vector<void *>::iterator i;
//              QRectF bounds;
                numSelected = 0;

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

                        switch (obj->type)
                        {
                        case OTLine:
                        {
                                Line * l = (Line *)obj;

                                if (Global::selection.contains(l->p1.x, l->p1.y) && Global::selection.contains(l->p2.x, l->p2.y))
                                        l->selected = true;

                                break;
                        }
                        case OTCircle:
                        {
                                Circle * c = (Circle *)obj;

                                if (Global::selection.contains(c->p1.x - c->radius, c->p1.y - c->radius) && Global::selection.contains(c->p1.x + c->radius, c->p1.y + c->radius))
                                        c->selected = true;

                                break;
                        }
                        case OTArc:
                        {
                                Arc * a = (Arc *)obj;

        double start = a->angle1;
        double end = start + a->angle2;
        QPointF p1(cos(start), sin(start));
        QPointF p2(cos(end), sin(end));
        QRectF bounds(p1, p2);

#if 1
        // Swap X/Y coordinates if they're backwards...
        if (bounds.left() > bounds.right())
        {
                double temp = bounds.left();
                bounds.setLeft(bounds.right());
                bounds.setRight(temp);
        }

        if (bounds.bottom() > bounds.top())
        {
                double temp = bounds.bottom();
                bounds.setBottom(bounds.top());
                bounds.setTop(temp);
        }
#else
        // Doesn't work as advertised! For shame!
        bounds = bounds.normalized();
#endif

        // If the end of the arc is before the beginning, add 360 degrees to it
        if (end < start)
                end += 2.0 * PI;

        // Adjust the bounds depending on which axes are crossed
        if ((start < PI_OVER_2) && (end > PI_OVER_2))
                bounds.setTop(1.0);

        if ((start < PI) && (end > PI))
                bounds.setLeft(-1.0);

        if ((start < (PI + PI_OVER_2)) && (end > (PI + PI_OVER_2)))
                bounds.setBottom(-1.0);

        if ((start < (2.0 * PI)) && (end > (2.0 * PI)))
                bounds.setRight(1.0);

        if ((start < ((2.0 * PI) + PI_OVER_2)) && (end > ((2.0 * PI) + PI_OVER_2)))
                bounds.setTop(1.0);

        if ((start < (3.0 * PI)) && (end > (3.0 * PI)))
                bounds.setLeft(-1.0);

        if ((start < ((3.0 * PI) + PI_OVER_2)) && (end > ((3.0 * PI) + PI_OVER_2)))
                bounds.setBottom(-1.0);

        bounds.setTopLeft(QPointF(bounds.left() * a->radius, bounds.top() * a->radius));
        bounds.setBottomRight(QPointF(bounds.right() * a->radius, bounds.bottom() * a->radius));
        bounds.translate(a->p1.x, a->p1.y);

                                if (Global::selection.contains(bounds))
                                        a->selected = true;

                                break;
                        }
                        default:
                                break;
                        }

                        if (obj->selected)
                                numSelected++;
                }
        }

//      oldPoint = point;
//we should keep track of the last point here and only pass this down *if* the point
//changed...

#if 0
        // This returns true if we've moved over an object...
        if (document.PointerMoved(point))
        {
/*
Now objects handle mouse move snapping as well. The code below mainly works only
for tools; we need to fix it so that objects work as well...

There's a problem with the object point snapping in that it's dependent on the
order of the objects in the document. Most likely this is because it counts the
selected object last and thus fucks up the algorithm. Need to fix this...


*/
                // Do object snapping here. Grid snapping on mouse down is done in the
                // objects themselves, only because we have to hit test the raw point,
                // not the snapped point. There has to be a better way...!
                if (document.penultimateObjectHovered)
                {
                        // Two objects are hovered, see if we have an intersection point
                        if ((document.lastObjectHovered->type == OTLine) && (document.penultimateObjectHovered->type == OTLine))
                        {
                                double t;
                                int n = Geometry::Intersects((Line *)document.lastObjectHovered, (Line *)document.penultimateObjectHovered, &t);

                                if (n == 1)
                                {
                                        Global::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
                                        Global::snapPointIsValid = true;
                                }
                        }
                        else if ((document.lastObjectHovered->type == OTCircle) && (document.penultimateObjectHovered->type == OTCircle))
                        {
                                Point p1, p2;
                                int n = Geometry::Intersects((Circle *)document.lastObjectHovered, (Circle *)document.penultimateObjectHovered, 0, 0, 0, 0, &p1, &p2);

                                if (n == 1)
                                {
                                        Global::snapPoint = p1;
                                        Global::snapPointIsValid = true;
                                }
                                else if (n == 2)
                                {
                                        double d1 = Vector(point, p1).Magnitude();
                                        double d2 = Vector(point, p2).Magnitude();

                                        if (d1 < d2)
                                                Global::snapPoint = p1;
                                        else
                                                Global::snapPoint = p2;

                                        Global::snapPointIsValid = true;
                                }
                        }
                }
//              else
//              {
                        // Otherwise, it was a single object hovered...
//              }
        }

        if (toolAction)
        {
                if (Global::snapToGrid)
                        point = Global::SnapPointToGrid(point);

                // We always snap to object points, and they take precendence over
                // grid points...
                if (Global::snapPointIsValid)
                        point = Global::snapPoint;

                toolAction->MouseMoved(point);
        }
#endif
        bool needUpdate = false;

        // Don't do this kind of checking unless we're not doing a selection rectangle!
        // Hmm, lines don't stay selected if globally selected... !!! FIX !!!
        // it's because there were extra state variables, the hit* vars...
        if (!Global::selectionInProgress)
        {
        std::vector<void *>::iterator i;
        int numHovered = 0;

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

                switch (obj->type)
                {
                case OTLine:
                {
                        Line * l = (Line *)obj;

//      bool hitPoint1, hitPoint2, hitLine;
        l->hitPoint[0] = l->hitPoint[1] = l->hitObject = false;
        Vector lineSegment = l->p2 - l->p1;
        Vector v1 = point - l->p1;
        Vector v2 = point - l->p2;
        double t = Geometry::ParameterOfLineAndPoint(l->p1, l->p2, point);
        double distance;

        if (t < 0.0)
                distance = v1.Magnitude();
        else if (t > 1.0)
                distance = v2.Magnitude();
        else
                // distance = ?Det?(ls, v1) / |ls|
                distance = fabs((lineSegment.x * v1.y - v1.x * lineSegment.y)
                        / lineSegment.Magnitude());

        if ((v1.Magnitude() * Global::zoom) < 8.0)
        {
                l->hitPoint[0] = true;
//              snapPoint = l->p1;
//              snapPointIsValid = true;
        }
        else if ((v2.Magnitude() * Global::zoom) < 8.0)
        {
                l->hitPoint[1] = true;
//              snapPoint = l->p2;
//              snapPointIsValid = true;
        }
        else if ((distance * Global::zoom) < 5.0)
                l->hitObject = true;

        bool oldHovered = l->hovered;
        l->hovered = (l->hitPoint[0] || l->hitPoint[1] || l->hitObject ? true : false);

        if (oldHovered != l->hovered)
                needUpdate = true;

                        break;
                }
                case OTCircle:
                {
                        Circle * c = (Circle *)obj;


                        break;
                }
                default:
                        break;
                }
        }
        }

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

//      if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
        if (needUpdate || Global::selectionInProgress)
                update();
}


void DrawingView::mouseReleaseEvent(QMouseEvent * event)
{
        if (event->button() == Qt::LeftButton)
        {
#if 0
                document.PointerReleased();
#endif

//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())
//              if (collided)
                        update();       // Do an update if collided with at least *one* object in the document

#if 0
                if (toolAction)
                        toolAction->MouseReleased();
#endif

                if (Global::selectionInProgress)
                {
                        // Select all the stuff inside of selection
                        Global::selectionInProgress = 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;
        }

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


void DrawingView::keyPressEvent(QKeyEvent * event)
{
#if 0
        if (toolAction)
                toolAction->KeyDown(event->key());
#endif
}


void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
#if 0
        if (toolAction)
                toolAction->KeyReleased(event->key());
#endif
}

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