[architektonas] / src / utils.cpp

// utils.cpp: Stuff that's useful to have kicking around, in one spot
//
// Part of the Architektonas Project
// (C) 2020 Underground Software
// See the README and GPLv3 files for licensing and warranty information
//
// JLH = James Hammons <jlhamm@acm.org>
//
// Who  When        What
// ---  ----------  ------------------------------------------------------------
// JLH  05/01/2015  Created this file
//

#include "utils.h"
#include <math.h>
#include <string.h>             // For memcpy()
#include "geometry.h"

//
// Copy objects in one vector to another, creating copies and placing them in
// the other vector. Clearing & etc. of vectors is responsibility of the caller!
//
void CopyObjects(VPVector & from, VPVector & to)
{
        for(VPVectorIter i=from.begin(); i!=from.end(); i++)
        {
                Object * obj = (Object *)(*i);
                Object * newObject = CopyObject(obj);
                to.push_back(newObject);
        }
}

VPVector CopyObjects(VPVector & src)
{
        VPVector copy;

        for(VPVectorIter i=src.begin(); i!=src.end(); i++)
        {
                Object * newObject = CopyObject2((Object *)(*i));
                copy.push_back(newObject);
        }

        return copy;
}

//
// Create a copy of the passed in object.
//
Object * CopyObject(Object * obj)
{
        void * newObject = NULL;

        switch (obj->type)
        {
        case OTLine:
                newObject = new Line();
                memcpy(newObject, obj, sizeof(Line));
                break;
        case OTCircle:
                newObject = new Circle();
                memcpy(newObject, obj, sizeof(Circle));
                break;
        case OTEllipse:
                newObject = new Ellipse();
                memcpy(newObject, obj, sizeof(Ellipse));
                break;
        case OTArc:
                newObject = new Arc();
                memcpy(newObject, obj, sizeof(Arc));
                break;
        case OTDimension:
                newObject = new Dimension();
                memcpy(newObject, obj, sizeof(Dimension));
                break;
        case OTSpline:
                newObject = new Spline();
                memcpy(newObject, obj, sizeof(Spline));
                break;
        case OTText:
                newObject = new Text();
                memcpy(newObject, obj, sizeof(Text));
                ((Text *)newObject)->s = ((Text *)obj)->s;
                break;
        case OTContainer:
                newObject = new Container();
//this won't work...
//              memcpy(newObject, obj, sizeof(Line));
                ((Container *)newObject)->p[0] = obj->p[0];
                ((Container *)newObject)->p[1] = obj->p[1];
                ((Container *)newObject)->layer = obj->layer;
                CopyObjects(((Container *)obj)->objects, ((Container *)newObject)->objects);
                break;
        default:
                break;
        }

        // Fix objectID
        if (newObject && (((Object *)newObject)->type != OTContainer))
                ((Object *)newObject)->id = Global::objectID++;

        return (Object *)newObject;
}

//
// Create a copy of the passed in object.  This version calls the second
// version of CopyObjects() (with one parameter and a vector return value).
//
Object * CopyObject2(Object * obj)
{
        void * newObject = NULL;

        switch (obj->type)
        {
        case OTLine:
                newObject = new Line();
                memcpy(newObject, obj, sizeof(Line));
                break;

        case OTCircle:
                newObject = new Circle();
                memcpy(newObject, obj, sizeof(Circle));
                break;

        case OTEllipse:
                newObject = new Ellipse();
                memcpy(newObject, obj, sizeof(Ellipse));
                break;

        case OTArc:
                newObject = new Arc();
                memcpy(newObject, obj, sizeof(Arc));
                break;

        case OTDimension:
                newObject = new Dimension();
                memcpy(newObject, obj, sizeof(Dimension));
                break;

        case OTSpline:
                newObject = new Spline();
                memcpy(newObject, obj, sizeof(Spline));
                break;

        case OTText:
                newObject = new Text();
                memcpy(newObject, obj, sizeof(Text));
                ((Text *)newObject)->s = ((Text *)obj)->s;
                break;

        case OTContainer:
                newObject = new Container();
                ((Container *)newObject)->p[0] = obj->p[0];
                ((Container *)newObject)->p[1] = obj->p[1];
                ((Container *)newObject)->layer = obj->layer;
                ((Container *)newObject)->objects = CopyObjects(((Container *)obj)->objects);
                break;
        }

        // Fix objectID
        if (newObject && (((Object *)newObject)->type != OTContainer))
                ((Object *)newObject)->id = Global::objectID++;

        return (Object *)newObject;
}

void MoveSelectedObjectsTo(VPVector & dest, VPVector & from)
{
        VPVectorIter i = from.begin();

        while (i != from.end())
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                {
                        dest.push_back(*i);
                        from.erase(i);
                }
                else
                        i++;
        }
}

VPVector MoveSelectedObjectsFrom(VPVector & from)
{
        VPVector objects;
        VPVectorIter i = from.begin();

        while (i != from.end())
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                {
                        objects.push_back(*i);
                        from.erase(i);
                }
                else
                        i++;
        }

        return objects;
}

//hmm, this won't work, as these are just pointers...
//[should work now]
void CopySelectedObjectsTo(VPVector & dest, VPVector & from)
{
        for(VPVectorIter i=from.begin(); i!=from.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                        dest.push_back(CopyObject2(obj));
        }
}

VPVector CopySelectedObjects(VPVector & src)
{
        VPVector copy;

        for(VPVectorIter i=src.begin(); i!=src.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                        copy.push_back(CopyObject2(obj));
        }

        return copy;
}

void AddObjectsTo(VPVector & dest, VPVector & from)
{
        for(VPVectorIter i=from.begin(); i!=from.end(); i++)
                dest.push_back(*i);
}

void ClearSelected(VPVector & v)
{
        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
                ((Object *)(*i))->selected = false;
}

//
// Select all *visible* objects.  If an object's layer is invisible, skip it.
//
void SelectAll(VPVector & v)
{
        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
        {
                Object * obj = (Object *)(*i);
                bool visible = !Global::layerHidden[obj->layer];
                obj->selected = visible;
        }
}

//
// Recursively go down thru the Container's vectors, deleting all the objects
// contained therein.  Once that is done, the main Container can be deleted.
// We don't have to worry about the underlying std::vectors, as they have their
// own destructors--plus they don't take ownership of objects, which is why we
// have to keep track of that stuff ourselves.  :-P  Believe it or not, this is
// a Good Thing(TM).  ;-)
//
void DeleteContents(VPVector & v)
{
        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
        {
                Object * obj = (Object *)(*i);

                if (obj->type == OTContainer)
                        DeleteContents(((Container *)obj)->objects);

                delete obj;
        }

        v.clear();
}

void DeleteSelectedObjects(VPVector & v)
{
        VPVectorIter i = v.begin();

        while (i != v.end())
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                {
                        delete obj;
                        v.erase(i);
                }
                else
                        i++;
        }
}

//
// This is used to remove selected objects from one container in order to move
// them to a different container.
//
void RemoveSelectedObjects(VPVector & v)
{
        VPVectorIter i = v.begin();

        while (i != v.end())
        {
                Object * obj = (Object *)(*i);

                if (obj->selected)
                        v.erase(i);
                else
                        i++;
        }
}

void SavePointsFrom(VPVector & v, std::vector<Object> & save)
{
        save.clear();
        Object o;

        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
        {
                memcpy(&o, (Object *)(*i), sizeof(Object));
                save.push_back(o);
        }
}

void RestorePointsTo(VPVector & v, std::vector<Object> & s)
{
        std::vector<Object>::iterator i;
        VPVectorIter j;

        for(i=s.begin(), j=v.begin(); i!=s.end(); i++, j++)
        {
                Object * obj2 = (Object *)(*j);
                obj2->p[0] = (*i).p[0];
                obj2->p[1] = (*i).p[1];
                obj2->angle[0] = (*i).angle[0];
                obj2->angle[1] = (*i).angle[1];
//we don't do this because we want to keep selected & friends from changing
//              memcpy(obj2, *j, sizeof(Object));
        }
}

void RestorePointsTo(VPVector & v, VPVector & s)
{
        for(VPVectorIter i=s.begin(), j=v.begin(); i!=s.end(); i++, j++)
        {
                Object * objS = (Object *)(*i);
                Object * objV = (Object *)(*j);

                if (objV->type == OTContainer)
                {
                        RestorePointsTo(((Container *)objV)->objects, ((Container *)objS)->objects);
                        return;
                }

                objV->p[0] = objS->p[0];
                objV->p[1] = objS->p[1];
                objV->angle[0] = objS->angle[0];
                objV->angle[1] = objS->angle[1];
//we don't do this because we want to keep selected & friends from changing
//              memcpy(obj2, *j, sizeof(Object));
        }
}

//
// Translate a single object; it it's a Container, translate all its contents,
// including subcontainers.
//
void TranslateObject(Object * obj, Point delta)
{
        if (obj->type == OTContainer)
        {
                Container * c = (Container *)obj;

                for(VPVectorIter i=c->objects.begin(); i!=c->objects.end(); i++)
                        TranslateObject((Object *)*i, delta);
        }

        obj->p[0] += delta;
        obj->p[1] += delta;
}

/*
So we need to make it so that we pick the container's point clicked on, and translate all the other parts *not* clicked on.
*/
void TranslateContainer(Container * c, Point point, Point delta)
{
        if (c->clicked == NULL)
//      {
//              TranslateObject((Object *)c, delta);
                return;
//      }

//static int i=0;
//printf("TranslateContainer: boop (%i)\n", i++);
//we can set this to "point" and it won't move...
//do it *this* way, and non-enumerated clicks will do the right thing
        Point clickedPoint = point - delta;

        switch (c->clicked->type)
        {
        case OTLine:
                if (c->clicked->hitPoint[0])
                        clickedPoint = c->clicked->p[0];
                else if (c->clicked->hitPoint[1])
                        clickedPoint = c->clicked->p[1];
                else if (c->clicked->hitObject)
//Weirdness: some lines get a midpoint, some don't...
                        clickedPoint = Geometry::Midpoint((Line *)(c->clicked));

                break;

        case OTCircle:
                if (c->clicked->hitPoint[0])
                        clickedPoint = c->clicked->p[0];
//              else if (c->clicked->hitObject)
//                      clickedPoint = point - delta;

                break;

        case OTArc:
                if (c->clicked->hitPoint[0])
                        clickedPoint = c->clicked->p[0];
                else if (c->clicked->hitPoint[1])
                        clickedPoint = c->clicked->p[0] + (Vector(cos(c->clicked->angle[0]), sin(c->clicked->angle[0])) * c->clicked->radius[0]);
                else if (c->clicked->hitPoint[2])
                        clickedPoint = c->clicked->p[0] + (Vector(cos(c->clicked->angle[0] + c->clicked->angle[1]), sin(c->clicked->angle[0] + c->clicked->angle[1])) * c->clicked->radius[0]);
//              else if (c->clicked->hitObject)
//                      clickedPoint = point - delta;

                break;

        case OTDimension:
                break;

        case OTText:
                break;
        }

        Point clickedDelta = point - clickedPoint;
        TranslateObject((Object *)c, clickedDelta);
}

//
// Translate all objects in the passed in vector, including Containers and all
// the objects they contain.
//
void TranslateObjects(VPVector & v, Point delta)
{
        for(VPVectorIter i=v.begin(); i!=v.end(); i++)
        {
                Object * obj = (Object *)(*i);
                obj->p[0] += delta;
                obj->p[1] += delta;

                if (obj->type == OTContainer)
                {
                        Container * c = (Container *)obj;
                        TranslateObjects(c->objects, delta);
                }
        }
}

//
// This does not *copy* the objects, it simply flattens out the pointers in the
// Container and all sub-Containers.
//
VPVector Flatten(Container * src)
{
        VPVector flat;

        for(VPVectorIter i=src->objects.begin(); i!=src->objects.end(); i++)
        {
                flat.push_back(*i);
                Object * obj = (Object *)(*i);

                // Recursively add objects to the flat vector, if necessary
                if (obj->type == OTContainer)
                {
                        VPVector sub = Flatten((Container *)obj);
                        flat.insert(flat.end(), sub.begin(), sub.end());
                }
        }

        return flat;
}

//
// This does not *copy* the objects, it simply flattens out the pointers in the
// vector and all sub-Containers in the vector.
//
VPVector Flatten(VPVector src)
{
        VPVector flat;

        for(VPVectorIter i=src.begin(); i!=src.end(); i++)
        {
                flat.push_back(*i);
                Object * obj = (Object *)(*i);

                // Recursively add objects to the flat vector, if necessary
                if (obj->type == OTContainer)
                {
                        VPVector sub = Flatten(((Container *)obj)->objects);
                        flat.insert(flat.end(), sub.begin(), sub.end());
                }
        }

        return flat;
}