Beginning to make the Layer widget functional.

[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:
//
//

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

#include "drawingview.h"

#include <stdint.h>
#include "mathconstants.h"

#include "arc.h"
#include "circle.h"
#include "dimension.h"
#include "line.h"
#include "painter.h"


#define BACKGROUND_MAX_SIZE     512


DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
        // The value in the settings file will override this.
        useAntialiasing(true),
        gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
        scale(1.0), offsetX(-10), offsetY(-10),
        document(Vector(0, 0)),
        /*gridSpacing(12.0),*/ gridPixels(0), collided(false), rotateTool(false),
        rx(150.0), ry(150.0),
//      scrollDrag(false), addLineTool(false), addCircleTool(false),
//      addDimensionTool(false),
        toolAction(NULL)
{
        document.isTopLevelContainer = true;
        setBackgroundRole(QPalette::Base);
        setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

        Object::gridSpacing = 12.0;
//      toolPalette = new ToolWindow();
//      CreateCursors();
//      setCursor(cur[TOOLSelect]);
//      setMouseTracking(true);

        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

/*
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 / Painter::zoom;

Painter::zoom is the zoom factor for the drawing, and all mouse clicks are
translated to Cartesian coordinates through this. (Initially, Painter::zoom is
set to 1.0. SCREEN_ZOOM is set to 1.0/4.0.)

Really, the 100% zoom level can be set at *any* zoom level, it's more of a
convenience function than any measure of absolutes. Doing things that way we
could rid ourselves of the whole SCREEN_ZOOM parameter and all the attendant
shittyness that comes with it.

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. Painter::zoom is simply the ratio of pixels to
base units. What that means is that if you have a 12px grid with a 6" grid size
(& base unit of "inches"), Painter::zoom becomes 12px / 6" = 2.0 px/in.

Dimensions now have a "size" parameter to set their absolute size in relation
to the base unit. ATM, the arrows are drawn in pixels, but also scaled by
Painter::zoom *and* size. Same with the dimension text; it's drawn at 10pt and
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);
}


void DrawingView::SetRotateToolActive(bool state/*= true*/)
{
        rotateTool = state;
        update();
}


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


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;
        Painter::zoom = gridPixels / Object::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::SetCurrentLayer(int layer)
{
        Object::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);
}


#if 0
//
// This looks strange, but it's really quite simple: We want a point that's
// more than half-way to the next grid point to snap there while conversely we
// want a point that's less than half-way to to the next grid point then snap
// to the one before it. So we add half of the grid spacing to the point, then
// divide by it so that we can remove the fractional part, then multiply it
// back to get back to the correct answer.
//
Vector DrawingView::SnapPointToGrid(Vector point)
{
        point += gridSpacing / 2.0;             // *This* adds to Z!!!
        point /= gridSpacing;
        point.x = floor(point.x);//need to fix this for negative numbers...
        point.y = floor(point.y);
        point.z = 0;                                    // Make *sure* Z doesn't go anywhere!!!
        point *= gridSpacing;
        return point;
}
#endif


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

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

//      Painter::screenSize = Vector(size().width(), size().height());
        Object::SetViewportHeight(size().height());

        // Draw coordinate axes

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

        // Draw supplemental (tool related) points
// NOTE that this can be done as an action!
// In that case, we would need access to the document...
// [We can do that by making the document a class object...]
        if (rotateTool)
        {
                painter.SetPen(QPen(QColor(0, 200, 0), 2.0, Qt::SolidLine));
                painter.DrawLine(rx - 10, ry, rx + 10, ry);
                painter.DrawLine(rx, ry - 10, rx, ry + 10);
        }

// Maybe we can make the grid into a background brush instead, and let Qt deal
// with it??? YES!!

        // The top level document takes care of rendering for us...
        document.Draw(&painter);

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

        if (Object::selectionInProgress)
        {
//              painter.SetPen(QPen(Qt::green, 1.0, Qt::SolidLine));
                painter.SetPen(QPen(QColor(255, 127, 0, 255)));
//              painter.SetBrush(QBrush(Qt::NoBrush));
                painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
                painter.DrawRect(Object::selection);
        }
}


void DrawingView::resizeEvent(QResizeEvent * /*event*/)
{
        Painter::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()));

// Problem with this: Can't select stuff very well with the snap grid on.
// Completely screws things up, as sometimes things don't fall on the grid.
/*
So, how to fix this? Have the Object check itself?
Maybe we can fix this by having the initial point not be snapped, but when there's
a drag, we substitute the snapped point 'oldPoint' which the Object keeps track of
internally to know how far it was dragged...

Now we do... :-/
*/
#if 0
                if (Object::snapToGrid)
                        point = Object::SnapPointToGrid(point);
#endif

                collided = document.Collided(point);

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

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

                        toolAction->MouseDown(point);
                }

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

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

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

        // Grid processing...
        if ((event->buttons() & Qt::LeftButton) && Object::snapToGrid)
        {
                point = Object::SnapPointToGrid(point);
        }

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

        if (document.NeedsUpdate() || Object::selectionInProgress)
                update();

        if (toolAction)
        {
                if (Object::snapToGrid)
                {
                        point = Object::SnapPointToGrid(point);
                        oldPoint = point;
                }

                toolAction->MouseMoved(point);
                update();
        }
}


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

//We need to update especially if nothing collided and the state needs to change. !!! FIX !!!
//could set it up to use the document's update function (assumes that all object updates
//are being reported correctly:
//              if (document.NeedsUpdate())
//              if (collided)
                        update();       // Do an update if collided with at least *one* object in the document

                if (toolAction)
                        toolAction->MouseReleased();

                if (Object::selectionInProgress)
                {
                        // Select all the stuff inside of selection
                        Object::selectionInProgress = false;
                }
        }
        else if (event->button() == Qt::MiddleButton)
        {
                scrollDrag = false;
                setCursor(Qt::ArrowCursor);
        }
}


void DrawingView::keyPressEvent(QKeyEvent * event)
{
        if (toolAction)
        {
                bool needUpdate = toolAction->KeyDown(event->key());

                if (needUpdate)
                        update();
        }
}


void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
        if (toolAction)
        {
                bool needUpdate = toolAction->KeyReleased(event->key());

                if (needUpdate)
                        update();
        }
}