[architektonas] / src / circle.cpp

// circle.cpp: Circle 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  03/28/2011  Created this file
// JLH  09/26/2011  Added hover effects
// JLH  09/26/2011  Major cleanup of this class
//

#include "circle.h"

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


Circle::Circle(Vector p1, double r, Object * p/*= NULL*/): Object(p1, p), radius(r),
        draggingEdge(false), draggingCenter(false), hitCenter(false), hitCircle(false)
{
        type = OTCircle;
}


Circle::~Circle()
{
}


/*virtual*/ void Circle::Draw(Painter * painter)
{
        if (state == OSSelected || hitCircle || hitCenter)
                painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
        else
                painter->SetPen(QPen(Qt::black, 1.0, Qt::SolidLine));

        // Hatch/Fill...
//      QBrush brush(Qt::DiagCrossPattern);
//      brush.setColor(QColor(255, 255, 0));
//      painter->SetBrush(brush);
        painter->SetBrush(QBrush(Qt::NoBrush));

        // Draw the object...
        painter->DrawEllipse(position, radius, radius);

        // & draw handles (if needed)
        if (state == OSSelected || hitCenter)
                painter->DrawHandle(position);

        if (state == OSSelected && draggingEdge && objectWasDragged)
                painter->DrawHandle(dragPoint);
}


/*virtual*/ Vector Circle::Center(void)
{
        return position;
}


/*virtual*/ bool Circle::Collided(Vector point)
{
        // We can assume this, since this is a mouse down event here.
        objectWasDragged = false;
        HitTest(point);

        draggingCenter = hitCenter;
        draggingEdge = hitCircle;

        if (hitCenter || hitCircle)
        {
                dragPoint = point;
                oldState = state;
                state = OSSelected;
                return true;
        }

        // We didn't hit anything, so deselect this object and report failure to hit
        state = OSInactive;
        return false;
}


/*virtual*/ void Circle::PointerMoved(Vector point)
{
        if (selectionInProgress)
        {
                // Check for whether or not the rect contains this circle
                if (selection.normalized().contains(Extents()))
                        state = OSSelected;
                else
                        state = OSInactive;

                return;
        }

        // Hit test tells us what we hit (if anything) through boolean variables. It
        // also tells us whether or not the state changed.
        needUpdate = HitTest(point);
        objectWasDragged = (draggingEdge | draggingCenter);

        if (draggingEdge)
                radius = Vector::Magnitude(point, position);
        else if (draggingCenter)
                position = point;

        // Save this point so the rendering code knows where to draw the handle...
        dragPoint = point;
}


/*virtual*/ void Circle::PointerReleased(void)
{
        // Mouse went up, so our dragging is done (if any *was* done, that is)
        draggingEdge = draggingCenter = false;
        hitCenter = hitCircle = false;

        // If the object was dragged, then revert to the old state.
        // Otherwise, we were probably just clicked, and want to stay in the selected state.
        if (objectWasDragged)
                state = oldState;
}


/*virtual*/ bool Circle::HitTest(Point point)
{
        SaveState();
        hitCenter = hitCircle = false;
        double length = Vector::Magnitude(position, point);
//printf("Circle::length = %lf, radius = %lf\n", length, radius);
//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
/*
Document passes in the correct Cartesian coordinates being pointed to by the mouse.
So all we have to be concerned with is properly scaling our hot zones/handle sizes,
since we generally *don't* want those to scale with the zoom level. ;-)

What is going on here?
If we're zoomed out to, say, 50%, & our radius is 10.0 (absolute), then on screen
the radius will be 5.0. By multiplying the length by the zoom factor, we align our
pointed at length with our on screen length.
*/
        if ((length * Painter::zoom) < 8.0)
                hitCenter = true;
//wrong:        else if ((length < (radius + 2.0)) && (length > (radius - 2.0)))
/*NB: The following should be identical to what we have down below, but it doesn't work out that way... :-P */
//close, but no else if (((length * Painter::zoom) < ((radius * Painter::zoom) + 2.0)) && ((length * Painter::zoom) > ((radius * Painter::zoom) - 2.0)))
//really wrong! else if (((length * Painter::zoom) < (radius + 2.0)) && ((length * Painter::zoom) > (radius - 2.0)))
// close again, but sill no     else if (((length * Painter::zoom) < ((radius + 2.0) * Painter::zoom)) && ((length * Painter::zoom) > ((radius - 2.0) * Painter::zoom)))
        else if ((fabs(length - radius) * Painter::zoom) < 2.0)
                hitCircle = true;

        return StateChanged();
}


/*virtual*/ QRectF Circle::Extents(void)
{
        return QRectF(QPointF(position.x - radius, position.y - radius), QPointF(position.x + radius, position.y + radius));
}


void Circle::SaveState(void)
{
        oldHitCenter = hitCenter;
        oldHitCircle = hitCircle;
}


bool Circle::StateChanged(void)
{
        if ((hitCenter != oldHitCenter) || (hitCircle != oldHitCircle))
                return true;

        return false;
}


/*virtual*/ void Circle::Enumerate(FILE * file)
{
        fprintf(file, "CIRCLE (%lf,%lf) %lf\n", position.x, position.y, radius);
}