Added layer attribute to load/save code.

[architektonas] / src / container.cpp

// container.cpp: Container 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/30/2011  Created this file
// JLH  06/02/2011  Added code to delete objects in this container when they go
//                  out of scope
//

#include "container.h"

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


Container::Container(Vector p1, Object * p/*= NULL*/): Object(p1, p),
        isTopLevelContainer(false),
        dragging(false), draggingHandle1(false), draggingHandle2(false)//, needUpdate(false)
{
        type = OTContainer;
        state = OSInactive;
}


// Copy constructor
Container::Container(const Container & copy): Object(copy.position, copy.parent)
{
        // Use overloaded assignment operator
        *this = copy;
        type = OTContainer;
        state = OSInactive;
}


Container::~Container()
{
        Clear();
}


// Assignment operator
Container & Container::operator=(const Container & from)
{
        // Take care of self-assignment
        if (this == &from)
                return *this;

        Clear();

        // Small problem with this approach: if the copied object goes out of scope,
        // all of the objects we copied in here will be deleted. D'oh!
        // For this COPY constructor to be meaningful, we have to actually COPY the
        // objects in this Container, not just MOVE a copy of the POINTER! D-:
        std::vector<Object *>::const_iterator i;

//      for(uint i=0; i<from.objects.size(); i++)
        for(i=from.objects.begin(); i!=from.objects.end(); i++)
        {
//              Object * object = from.objects[i];
                Object * object = (*i)->Copy();

                // Need to actually COPY the object here, not copy the pointer only!!
                // (which we do now, above :-P)

                objects.push_back(object);
        }

        return *this;
}


/*virtual*/ void Container::Draw(Painter * painter)
{
        QRectF boundary;

//int a=1;
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
//printf("Containter::Draw item #%i [%X]...\n", a++, *i);
                (*i)->Draw(painter);
                boundary = boundary.united((*i)->Extents());
        }

        if ((state == OSSelected) || hit)
        {
                if (hit)
                        painter->SetPen(QPen(Qt::magenta, 1.0, Qt::DashLine));
                else
                        painter->SetPen(QPen(Qt::blue, 2.0, Qt::DashLine));

                painter->SetBrush(QBrush(Qt::NoBrush));
                painter->DrawPaddedRect(boundary);
        }
}


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


/*
 We need at least *three* handles for this object:
 - one for moving
 - one for resizing
 - one for rotation

We need to think about the intuitive way (if there is any) to grab and
manipulate a complex object like this... Need to think, "What should happen when
I click here and drag there?"

Also: should put the snap logic into the Object base class (as a static method)...
*/


// Need to add checking here for clicking on a member of a group (Container),
// and checking for if it's a top level container (the DrawingView's document).
/*
One approach is to check for the parent of the container: If it's NULL, then it's
the DrawingView's document. It might be better, though, to set a boolean like
isTopLevelContainer so that we can do things like edit members of a group without
having to ungroup them first (like Inkscape).
*/
/*virtual*/ bool Container::Collided(Vector point)
{
        objectWasDragged = false;
//      Vector v1 = position - point;

        bool collision = false;

        // NOTE that this deletes the object on mouse down instead of mouse up. Have to
        // check to see how it feels to do it that way...
        if (deleteActive)
        {
                for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end();)
                {
                        if ((*i)->Collided(point))
                        {
printf("Container::Collided: Deleting object ($%X)\n", *i);
                                Object * objectToDelete = *i;
                                objects.erase(i);
                                delete objectToDelete;
                        }
                        else
                                i++;
                }
        }
        else
        {
                for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
                {
                        if ((*i)->Collided(point))
                                collision = true;
                }
        }

        if (snapToGrid)
                point = SnapPointToGrid(point);

        // We check to see if the container we're trying to access is the
        // DrawingView's document. If so, we ignore the state of the container.
        // Otherwise, we care about the state of the container. :-)
        if (isTopLevelContainer)
                state = OSInactive;
        else
        {
                state = (collision ? OSSelected : OSInactive);

                if (state == OSSelected)
                {
                        DeselectAll();
                        dragging = true;
                        oldPoint = point;
                }
        }

        return collision;
}

/*
What we need to do is check for whether or not we're a top level container,
and override the passing of stuff into the objects held. So here, if we're *NOT*
a top level container, instead of passing PointerMoved to our contained objects,
we check to see if our bounds are met (for selection rectangle, e.g.).

Also, for things like being able to split point's hot spots we need to be able
to check for that crap in the top level container. Which means that objects can
still know how to move themselves, but they can also defer to their container
as well. Which also means that things like HitTest() need to be in the Object
class so that we can leverage that stuff here as well.
*/

// The TLC is passing all mouse movement here, so we're doing the same here.
// Need to adjust all other objects to handle things correctly.

// One optimization that will need to be done eventually is to subdivide the screen
// into parts and keep subdividing until an acceptable number of objects lie within
// the slice. This way, the GUI will still be responsive and *not* have to test
// every object for collision.
/*virtual*/ void Container::PointerMoved(Vector point)
{
        std::vector<Object *>::iterator i;

        if (!isTopLevelContainer)
        {
                // check for selection rectangle too
                if (selectionInProgress)
                {
                        if (selection.contains(Extents()))
                                state = OSSelected;
                        else
                                state = OSInactive;

                        return;
                }

                // No need to do any checking if we're already selected...
//              if (state == OSSelected)
//                      return;

//              oldState = state;
//              needUpdate = true;
//              if (dragging &&
                bool oldHit = hit;
                hit = false;

                for(i=objects.begin(); i!=objects.end(); i++)
                {
                        if ((*i)->HitTest(point))
                        {
//                              state = OSSelected;
//                              return;
                                hit = true;
                                break;
                        }
                }

                needUpdate = (oldHit != hit ? true : false);
//              state = oldState;

                if (dragging)
                {
                        Vector delta = point - oldPoint;

                        for(i=objects.begin(); i!=objects.end(); i++)
                                (*i)->Translate(delta);

                        oldPoint = point;
                        needUpdate = true;
                }

                return;
        }

        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
//              if (objects[i]->GetState() == OSSelected)
                (*i)->PointerMoved(point);
        }

        // Generic container doesn't need this???
//      needUpdate = false;
}


/*virtual*/ void Container::PointerReleased(void)
{
        if (!isTopLevelContainer)
        {
                dragging = false;
                return;
        }
#if 0
        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;
//Note that the preceeding is unnecessary for a generic container!
#endif

//      for(int i=0; i<(int)objects.size(); i++)
//              objects[i]->PointerReleased();
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
                (*i)->PointerReleased();
}


/*virtual*/ bool Container::NeedsUpdate(void)
{
        // If this is *not* a top level container, then we treat it as an
        // aggregate object.
        if (!isTopLevelContainer)
        {
                return needUpdate;
        }

        // Search through objects for one that needs an update; if one is found,
        // return immediately.
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
                if ((*i)->NeedsUpdate())
                        return true;
        }

        return false;
}


/*virtual*/ void Container::Add(Object * object)
{
        objects.push_back(object);
printf("Container: Added object (=$%X). size = %li\n", object, objects.size());
}


/*virtual*/ QRectF Container::Extents(void)
{
        QRectF bounds;

        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
                bounds = bounds.united((*i)->Extents());

        return bounds;
}


void Container::Delete(Object * objectToDelete)
{
        std::vector<Object *>::iterator i = objects.begin();

        while (i != objects.end())
        {
                if (*i == objectToDelete)
                {
                        objects.erase(i);
                        delete objectToDelete;
                        return;
                }

                i++;
        }
}


void Container::DeleteSelectedItems(void)
{
        std::vector<Object *>::iterator i = objects.begin();

        while (i != objects.end())
        {
                if ((*i)->state == OSSelected)
                {
                        delete *i;
                        objects.erase(i);
                }
                else
                        i++;
        }
}


void Container::Clear(void)
{
        std::vector<Object *>::iterator i = objects.begin();

        while (i != objects.end())
        {
printf("Container: Deleting object ($%X)...\n", *i);
                delete (*i);
                objects.erase(i);
        }
}


void Container::SelectAll(void)
{
        for(unsigned int i=0; i<objects.size(); i++)
                objects[i]->state = OSSelected;
}


void Container::DeselectAll(void)
{
        for(unsigned int i=0; i<objects.size(); i++)
                objects[i]->state = OSInactive;
}


int Container::ItemsSelected(void)
{
        int selected = 0;

        for(uint i=0; i<objects.size(); i++)
                if (objects[i]->state == OSSelected)
                        selected++;

        return selected;
}


Object * Container::SelectedItem(unsigned int index)
{
        unsigned int selectedIndex = 0;

        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
                if ((*i)->state == OSSelected)
                {
                        if (selectedIndex == index)
                                return *i;
                        else
                                selectedIndex++;
                }
        }

        return NULL;
}


void Container::MoveContentsTo(Container * newContainer)
{
        // Sanity check
        if (newContainer == NULL)
                return;

        // Shuffle the contents of this container to the new one
//      for(unsigned int i=0; i<objects.size(); i++)
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
                newContainer->Add(*i);
                (*i)->Reparent(newContainer);
        }

        // & clear our vector
        objects.clear();
}


void Container::MoveSelectedContentsTo(Container * newContainer)
{
        // Sanity check
        if (newContainer == NULL)
                return;

        // Shuffle the contents of this container to the new one
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end();)
        {
                if ((*i)->state != OSSelected)
                {
                        i++;
                        continue;
                }

                newContainer->Add(*i);
                (*i)->Reparent(newContainer);
                objects.erase(i);
        }
}


void Container::ResizeAllDimensions(double newSize)
{
        for(std::vector<Object *>::iterator i=objects.begin(); i!=objects.end(); i++)
        {
                if ((*i)->type == OTDimension)
                        ((Dimension *)(*i))->size = newSize;
                if ((*i)->type == OTContainer)
                        ((Container *)(*i))->ResizeAllDimensions(newSize);
        }
}


/*virtual*/ void Container::Enumerate(FILE * file)
{
        // Only put "CONTAINER" markers if *not* the top level container
//      if (parent != NULL)
        if (!isTopLevelContainer)
                fprintf(file, "CONTAINER %i\n", layer);

        for(uint i=0; i<objects.size(); i++)
                objects[i]->Enumerate(file);

//      if (parent != NULL)
        if (!isTopLevelContainer)
                fprintf(file, "ENDCONTAINER\n");
}


/*virtual*/ Object * Container::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.
*/
        Container * c = new Container(position, parent);
        *c = *this;
        return c;
}