[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 L. Hammons <jlhamm@acm.org>
//
// WHO  WHEN        WHAT
// ---  ----------  ------------------------------------------------------------
// JLH  04/04/2011  Created this file, basic rendering
//

#include "dimension.h"

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


Dimension::Dimension(Vector p1, Vector p2, Object * p/*= NULL*/): Object(p1, p), endpoint(p2),
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(p2.Magnitude()), point1(NULL), point2(NULL)
{
}

// This is bad, p1 & p2 could be NULL, causing much consternation...
Dimension::Dimension(Vector * p1, Vector * p2, Object * p/*= NULL*/): Object(*p1, p), endpoint(*p2),
        dragging(false), draggingHandle1(false), draggingHandle2(false),
        length(p2->Magnitude()), point1(p1), point2(p2)
{
}

Dimension::~Dimension()
{
}

/*virtual*/ void Dimension::Draw(QPainter * 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)
                position = *point1;

        if (point2)
                endpoint = *point2;

        if (state == OSSelected)
                painter->setPen(QPen(Qt::red, 2.0, Qt::DotLine));
        else
                painter->setPen(QPen(Qt::blue, 1.0, Qt::SolidLine));

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

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

        // Draw main dimension line
        painter->drawLine(QPointF(p1.x, p1.y), QPointF(p2.x, p2.y));

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

        // Draw extension lines
        painter->drawLine(QPointF(p3.x, p3.y), QPointF(p5.x, p5.y));
        painter->drawLine(QPointF(p4.x, p4.y), QPointF(p6.x, p6.y));

        // Draw length of dimension line...
        painter->setFont(QFont("Arial", 10));
        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());
        int textWidth = QFontMetrics(painter->font()).width(dimText);
        int textHeight = QFontMetrics(painter->font()).height();
//We have to do transformation voodoo to make the text come out readable and in correct orientation...
//Some things to note here: if angle > 90 degrees, then we need to take the negative of the angle
//for our text.
painter->save();
painter->translate(ctr.x, ctr.y);
int yOffset = -8;
//16 : printf("textHeight: %d\n", textHeight);

//Fix text so it isn't upside down...
if ((angle > PI * 0.5) && (angle < PI * 1.5))
{
        angle += PI;
        yOffset = 18;
}

painter->rotate(angle * RADIANS_TO_DEGREES);
painter->scale(1.0, -1.0);
//painter->translate(-textWidth / 2, -24);
//      painter->drawText(0, 0, textWidth, 20, Qt::AlignCenter, dimText);
        // This version draws the y-coord from the baseline of the font
        painter->drawText(-textWidth / 2, yOffset, dimText);
//painter->setPen(QPen(QColor(0xFF, 0x20, 0x20), 1.0, Qt::SolidLine));
//painter->drawLine(20, 0, -20, 0);
//painter->drawLine(0, 20, 0, -20);
painter->restore();

/*
All of the preceeding makes me think that rather than try to compensate for Qt's unbelieveably
AWFUL decision to go with a wrong-handed graphics subsystem, it may be better to just stuff
all of that crap into some kind of subclass that handles all the nastiness behind the scenes.
I mean, really, all this crap just to get some proplerly rendered text on the screen? How
retarded is that? :-/
*/
}

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

void Dimension::SetPoint1(Vector * v)
{
        point1 = v;
        needUpdate = true;
}

void Dimension::SetPoint2(Vector * v)
{
        point2 = v;
        needUpdate = true;
}

void Dimension::FlipSides(void)
{
#if 0
        Vector tmp = position;
        position = endpoint;
        endpoint = tmp;
#else
        Vector * tmp = point1;
        point1 = point2;
        point2 = tmp;
#endif
        needUpdate = true;
}