Fixed loading code, added "Base Unit" dialog.

[architektonas] / src / dimension.cpp

// dimension.cpp: Dimension object
//
// 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  04/04/2011  Created this file, basic rendering
// JLH  03/14/2013  Updated to new connection system
//

#include "dimension.h"

#include <QtGui>
#include "mathconstants.h"
#include "painter.h"


Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/ ,Object * p/*= NULL*/):
        Object(p1, p), endpoint(p2),
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(p2.Magnitude()), dimensionType(dt), size(0.25), point1(NULL), point2(NULL)
{
        // We set the size to 1/4 base unit. Could be anything.
        type = OTDimension;
}


// This is bad, p1 & p2 could be NULL, causing much consternation...
Dimension::Dimension(Connection p1, Connection p2, DimensionType dt/*= DTLinear*/ , Object * p/*= NULL*/):
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(0), dimensionType(dt), size(0.25), point1(p1), point2(p2)
{
        type = OTDimension;
}


Dimension::~Dimension()
{
}


/*virtual*/ void Dimension::Draw(Painter * painter)
{
        // If there are valid Vector pointers in here, use them to update the internal
        // positions. Otherwise, we just use the internal positions by default.
        if (point1.object)
                position = point1.object->GetPointAtParameter(point1.t);

        if (point2.object)
                endpoint = point2.object->GetPointAtParameter(point2.t);

        if (state == OSSelected)
                painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
        else
//              painter->SetPen(QPen(Qt::blue, 1.0, Qt::SolidLine));
                painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));

        painter->SetBrush(QBrush(QColor(Qt::blue)));

        // Draw an aligned dimension line
        double angle = Vector(endpoint - position).Angle();
        double orthoAngle = angle + (PI / 2.0);
        Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
        Vector unit = Vector(endpoint - position).Unit();

// Arrowhead:
//      Point p1 = head - (unit * 9.0 * size);
//      Point p2 = p1 + (orthogonal * 3.0 * size);
//      Point p3 = p1 - (orthogonal * 3.0 * size);

/*
The numbers hardcoded into here, what are they?
I believe they are pixels.
*/

        // Get our line parallel to our points
        Point p1 = position + (orthogonal * 10.0 * size);
        Point p2 = endpoint + (orthogonal * 10.0 * size);

        Point p3 = position + (orthogonal * 16.0 * size);
        Point p4 = endpoint + (orthogonal * 16.0 * size);
        Point p5 = position + (orthogonal * 4.0 * size);
        Point p6 = endpoint + (orthogonal * 4.0 * size);

        // Draw extension lines
        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 = Vector::Parameter(position, endpoint, endpoint - (unit * 9.0 * size));
//      double t = Vector::Parameter(position, endpoint, position + (unit * 9.0 * size));
        double t = Vector::Parameter(endpoint, position, position + (unit * 9.0 * size));
//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, size);
                painter->DrawArrowhead(p2, p1, size);
        }
        else
        {
                Point p7 = p1 - (unit * 9.0 * size);
                Point p8 = p2 + (unit * 9.0 * size);
                painter->DrawArrowhead(p1, p7, size);
                painter->DrawArrowhead(p2, p8, size);
                painter->DrawLine(p1, p1 - (unit * 14.0 * size));
                painter->DrawLine(p2, p2 + (unit * 14.0 * size));
        }

        // Draw length of dimension line...
        painter->SetFont(QFont("Arial", 8.0 * Painter::zoom * size));
        Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0);
        Point ctr = p2 + v1;
        QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
        painter->DrawAngledText(ctr, angle, dimText, size);
}


/*virtual*/ Vector Dimension::Center(void)
{
        // Technically, this is the midpoint but who are we to quibble? :-)
        Vector v((position.x - endpoint.x) / 2.0, (position.y - endpoint.y) / 2.0);
        return endpoint + v;
}


/*virtual*/ bool Dimension::Collided(Vector /*point*/)
{
#if 0
        objectWasDragged = false;
        Vector lineSegment = endpoint - position;
        Vector v1 = point - position;
        Vector v2 = point - endpoint;
        double parameterizedPoint = lineSegment.Dot(v1) / lineSegment.Magnitude(), distance;

        // Geometric interpretation:
        // pp is the paremeterized point on the vector ls where the perpendicular intersects ls.
        // If pp < 0, then the perpendicular lies beyond the 1st endpoint. If pp > length of ls,
        // then the perpendicular lies beyond the 2nd endpoint.

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

        // If the segment endpoints are s and e, and the point is p, then the test for the perpendicular
        // intercepting the segment is equivalent to insisting that the two dot products {s-e}.{s-p} and
        // {e-s}.{e-p} are both non-negative.  Perpendicular distance from the point to the segment is
        // computed by first computing the area of the triangle the three points form, then dividing by the
        // length of the segment.  Distances are done just by the Pythagorean theorem.  Twice the area of the
        // triangle formed by three points is the determinant of the following matrix:
        //
        // sx sy 1
        // ex ey 1
        // px py 1
        //
        // By translating the start point to the origin, this can be rewritten as:
        // By subtracting row 1 from all rows, you get the following:
        // [because sx = sy = 0. you could leave out the -sx/y terms below. because we subtracted
        // row 1 from all rows (including row 1) row 1 turns out to be zero. duh!]
        //
        // 0         0         0        0  0  0
        // (ex - sx) (ey - sy) 0   ==>  ex ey 0
        // (px - sx) (py - sy) 0        px py 0
        //
        // which greatly simplifies the calculation of the determinant.

        if (state == OSInactive)
        {
//printf("Line: pp = %lf, length = %lf, distance = %lf\n", parameterizedPoint, lineSegment.Magnitude(), distance);
//printf("      v1.Magnitude = %lf, v2.Magnitude = %lf\n", v1.Magnitude(), v2.Magnitude());
//printf("      point = %lf,%lf,%lf; p1 = %lf,%lf,%lf; p2 = %lf,%lf,%lf\n", point.x, point.y, point.z, position.x, position.y, position.z, endpoint.x, endpoint.y, endpoint.z);
//printf("      \n", );
//How to translate this into pixels from Document space???
//Maybe we need to pass a scaling factor in here from the caller? That would make sense, as
//the caller knows about the zoom factor and all that good kinda crap
                if (v1.Magnitude() < 10.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = position; //maybe "position"?
                        draggingHandle1 = true;
                        return true;
                }
                else if (v2.Magnitude() < 10.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = endpoint; //maybe "position"?
                        draggingHandle2 = true;
                        return true;
                }
                else if (distance < 2.0)
                {
                        oldState = state;
                        state = OSSelected;
                        oldPoint = point;
                        dragging = true;
                        return true;
                }
        }
        else if (state == OSSelected)
        {
                // Here we test for collision with handles as well! (SOON!)
/*
Like so:
                if (v1.Magnitude() < 2.0) // Handle #1
                else if (v2.Magnitude() < 2.0) // Handle #2
*/
                if (distance < 2.0)
                {
                        oldState = state;
//                      state = OSInactive;
                        oldPoint = point;
                        dragging = true;
                        return true;
                }
        }
#endif

        state = OSInactive;
        return false;
}


/*virtual*/ void Dimension::PointerMoved(Vector point)
{
        // We know this is true because mouse move messages don't come here unless
        // the object was actually clicked on--therefore we *know* we're being
        // dragged...
        objectWasDragged = true;

        if (dragging)
        {
                // Here we need to check whether or not we're dragging a handle or the object itself...
                Vector delta = point - oldPoint;

                position += delta;
                endpoint += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else if (draggingHandle1)
        {
                Vector delta = point - oldPoint;

                position += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else if (draggingHandle2)
        {
                Vector delta = point - oldPoint;

                endpoint += delta;

                oldPoint = point;
                needUpdate = true;
        }
        else
                needUpdate = false;
}


/*virtual*/ void Dimension::PointerReleased(void)
{
        if (draggingHandle1 || draggingHandle2)
        {
                // Set the length (in case the global state was set to fixed (or not))
                if (Object::fixedLength)
                {

                        if (draggingHandle1)    // startpoint
                        {
                                Vector v = Vector(position - endpoint).Unit() * length;
                                position = endpoint + v;
                        }
                        else                                    // endpoint
                        {
//                              Vector v1 = endpoint - position;
                                Vector v = Vector(endpoint - position).Unit() * length;
                                endpoint = position + v;
                        }
                }
                else
                {
                        // Otherwise, we calculate the new length, just in case on the next move
                        // it turns out to have a fixed length. :-)
                        length = Vector(endpoint - position).Magnitude();
                }
        }

        dragging = false;
        draggingHandle1 = false;
        draggingHandle2 = false;

        // Here we check for just a click: If object was clicked and dragged, then
        // revert to the old state (OSInactive). Otherwise, keep the new state that
        // we set.
/*Maybe it would be better to just check for "object was dragged" state and not have to worry
about keeping track of old states...
*/
        if (objectWasDragged)
                state = oldState;
}


/*virtual*/ void Dimension::Enumerate(FILE * file)
{
        fprintf(file, "DIMENSION (%lf,%lf) (%lf,%lf) %i\n", position.x, position.y, endpoint.x, endpoint.y, type);
}


/*virtual*/ Object * Dimension::Copy(void)
{
#warning "!!! This doesn't take care of attached Dimensions !!!"
/*
This is a real problem. While having a pointer in the Dimension to this line's points
is fast & easy, it creates a huge problem when trying to replicate an object like this.

Maybe a way to fix that then, is to have reference numbers instead of pointers. That
way, if you copy them, ... you might still have problems. Because you can't be sure if
a copy will be persistant or not, you then *definitely* do not want them to have the
same reference number.
*/

        Dimension * d = new Dimension(position, endpoint, dimensionType, parent);
        d->size = size;
        return d;
}


// Dimensions are special: they contain exactly *two* points. Here, we check
// only for zero/non-zero in returning the correct points.
/*virtual*/ Vector Dimension::GetPointAtParameter(double parameter)
{
        if (parameter == 0)
                return position;

        return endpoint;
}


/*virtual*/ void Dimension::Connect(Object * obj, double param)
{
        // There are four possibilities here...
        // The param is only looking for 0 or 1 here.
        if (point1.object == NULL && point2.object == NULL)
        {
                point1.object = obj;
                point1.t = param;
        }
        else if (point1.object == NULL && point2.object != NULL)
        {
                if (point2.t == param)
                        point2.object = obj;
                else
                {
                        point1.object = obj;
                        point1.t = param;
                }
        }
        else if (point1.object != NULL && point2.object == NULL)
        {
                if (point1.t == param)
                        point1.object = obj;
                else
                {
                        point2.object = obj;
                        point2.t = param;
                }
        }
        else if (point1.object != NULL && point2.object != NULL)
        {
                if (point1.t == param)
                        point1.object = obj;
                else
                        point2.object = obj;
        }
}


/*virtual*/ void Dimension::Disconnect(Object * obj, double param)
{
        if (point1.object == obj && point1.t == param)
                point1.object = NULL;
        else if (point2.object == obj && point2.t == param)
                point2.object = NULL;
}


/*virtual*/ void Dimension::DisconnectAll(Object * obj)
{
        if (point1.object == obj)
                point1.object = NULL;

        if (point2.object == obj)
                point2.object = NULL;
}


/*virtual*/ QRectF Dimension::Extents(void)
{
        Point p1 = position;
        Point p2 = endpoint;

        if (point1.object)
                p1 = point1.object->GetPointAtParameter(point1.t);

        if (point2.object)
                p2 = point2.object->GetPointAtParameter(point2.t);

        return QRectF(QPointF(p1.x, p1.y), QPointF(p2.x, p2.y));
}


#if 0
/*virtual*/ ObjectType Dimension::Type(void)
{
        return OTDimension;
}
#endif


void Dimension::FlipSides(void)
{
#if 0
        Vector tmp = position;
        position = endpoint;
        endpoint = tmp;
#else
        Connection tmp = point1;
        point1 = point2;
        point2 = tmp;
//      double tmp = point1.t;
//      point1.t = point2.t;
//      point2.t = tmp;
//      Object * tmp = point1.object;
//      point1.object = point2.object;
//      point2.object = tmp;
#endif
        needUpdate = true;
}