Added new triangulation tool, ability to snap to endpoints/intersections.

[architektonas] / src / object.cpp

//
// object.cpp: Base class for all CAD objects
//
// 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  04/01/2011  Added constructor to allow derived objects to have empty
//                  constructor bodies, added state querying
// JLH  04/02/2001  Added static methods for global states (fixed angle, etc)
//

#include "object.h"
#include <stdlib.h>
#include <math.h>

// Initialize static variables
bool Object::fixedAngle = false;
bool Object::fixedLength = false;
QFont * Object::font = 0;
int Object::viewportHeight = 0;
bool Object::deleteActive = false;
bool Object::dimensionActive = false;
bool Object::snapToGrid = true;
//snapToPoints all well here?
bool Object::ignoreClicks = false;
bool Object::dontMove = false;
bool Object::selectionInProgress = false;
QRectF Object::selection;
double Object::gridSpacing;
int Object::currentLayer = 0;
Point Object::snapPoint;
bool Object::snapPointIsValid = false;


Object::Object(): position(Vector(0, 0)), parent(0), type(OTObject),
        state(OSInactive), layer(0), oldState(OSInactive), needUpdate(false)
        //, attachedDimension(0)
{
}


Object::Object(Vector v,  Object * passedInParent/*= 0*/): position(v),
        parent(passedInParent), state(OSInactive), layer(0), oldState(OSInactive),
        needUpdate(false)//, attachedDimension(0)
{
}


Object::~Object()
{
printf("Object: Destroyed!\n");
        for(uint i=0; i<connected.size(); i++)
                connected[i].object->DisconnectAll(this);
}


/*virtual*/ void Object::Draw(Painter *)
{
}


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


/*virtual*/ bool Object::Collided(Vector)
{
        return false;
}


/*virtual*/ bool Object::PointerMoved(Vector)
{
        return false;
}


/*virtual*/ void Object::PointerReleased(void)
{
}


/*virtual*/ bool Object::NeedsUpdate(void)
{
        return needUpdate;
}


/*virtual*/ bool Object::HitTest(Point)
{
        return false;
}


// This is intended to be overridden by the Container class, for object morphing
/*virtual*/ void Object::Transmute(Object *, Object *)
{
}


/*virtual*/ Object * Object::GetParent(void)
{
        return parent;
}


/*virtual*/ void Object::Add(Object *)
{
}


// This returns a pointer to the point passed in, if it coincides. Otherwise returns NULL.
/*virtual*/ Vector * Object::GetPointAt(Vector)
{
        return 0;
}


// This is meant for writing object data to a file.
/*virtual*/ void Object::Enumerate(FILE *)
{
}


/*virtual*/ Object * Object::Copy(void)
{
        return new Object(position, parent);
}


// This returns a point on the object at 'parameter', which is between 0 and 1.
// Default is to return the object's position.
/*virtual*/ Vector Object::GetPointAtParameter(double)
{
        return position;
}


// Since these functions are pretty much non-object specific, we can implement
// them here. :-)
/*virtual*/ void Object::Connect(Object * obj, double parameter)
{
        // Check to see if this connection is already in our list...
        Connection c(obj, parameter);
        std::vector<Connection>::iterator i;

        for(i=connected.begin(); i!=connected.end(); i++)
        {
                // Bail out if this connection is already present...
                if (*i == c)
                        return;
        }

        // Connection is a new one, add it in...
        connected.push_back(c);
}


/*virtual*/ void Object::Disconnect(Object * obj, double parameter)
{
        std::vector<Connection>::iterator i;

        for(i=connected.begin(); i!=connected.end(); i++)
        {
                if (((*i).object == obj) && ((*i).t == parameter))
                {
                        connected.erase(i);
                        return;
                }
        }
}


/*virtual*/ void Object::DisconnectAll(Object * obj)
{
        std::vector<Connection>::iterator i;

        for(i=connected.begin(); i!=connected.end(); )
        {
                if ((*i).object == obj)
                        connected.erase(i);
                else
                        i++;
        }
}


/*virtual*/ QRectF Object::Extents(void)
{
        // Generic object returns an empty rect...
        return QRectF();
}


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


/*virtual*/ void Object::Translate(Vector amount)
{
        position += amount;
}


/*virtual*/ void Object::Rotate(Point, double)
{
}


/*virtual*/ void Object::Scale(Point, double)
{
}


/*virtual*/ void Object::Mirror(Point, Point)
{
}


/*virtual*/ void Object::Save(void)
{
        oldPosition = position;
}


/*virtual*/ void Object::Restore(void)
{
        position = oldPosition;
}


ObjectState Object::GetState(void)
{
        return state;
}


void Object::Reparent(Object * newParent)
{
        parent = newParent;
}


/*Dimension * Object::GetAttachedDimension(void)
{
        return attachedDimension;
}*/


// Class methods...

void Object::SetFixedAngle(bool state/*= true*/)
{
        fixedAngle = state;
}


void Object::SetFixedLength(bool state/*= true*/)
{
        fixedLength = state;
}


void Object::SetFont(QFont * f)
{
        font = f;
}


void Object::SetViewportHeight(int height)
{
        viewportHeight = height;
}


void Object::SetDeleteActive(bool state/*= true*/)
{
        deleteActive = state;
}


void Object::SetDimensionActive(bool state/*= true*/)
{
        dimensionActive = state;
}


void Object::SetSnapMode(bool state/*= true*/)
{
        snapToGrid = state;
}


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