Initial commit of GUEmap v3.

[guemap] / src / undo.cpp

//
// GUEmap
// Copyright 1997-2007 by Christopher J. Madsen
// (C) 2019 James Hammons
//
// GUEmap is licensed under either version 2 of the GPL, or (at your option)
// any later version.  See LICENSE file for details.
//
// Implementation of UndoRec and its derived classes
//

#include "undo.h"
#include "mapdoc.h"


//
// Class UndoRec:
//
// UndoRec is the virtual base class for all undo records.
//
// Member Variables:
//   oldModified:
//     The modification state of the document before the change that
//     this undo record applies to was made.
//

UndoRec::UndoRec(bool modified): oldModified(modified)
{
}


UndoRec::~UndoRec()
{
}


//
// Get the type of undo record:
//
// Returns:
//   The name of this undo operation (The XXX in "Undo XXX")
//
// char * UndoRec::getName() const
//
//--------------------------------------------------------------------
// Undo:
//
// Undo the change that this undo record applies to.  This is the main entry
// point; it calls undoChange to actually do the work.
//
// If the document was not modified before the original change, and is
// modified now, then it is marked as unmodified.  Otherwise, it is marked as
// modified.  This should cause the modification flag to agree with the actual
// state of the document in memory vs. the file on disk.
//
// Input:
//   doc:  The MapDoc to change
//
// Returns:
//   A pointer to the "redo" record
//   NULL if the operation cannot be redone
//
// Note:
//   undo is a one time function.  After calling undo, you cannot call any
//   other member functions; you must delete the object immediately.
//
UndoRec * UndoRec::undo(MapDoc & doc)
{
        bool newModified = doc.isDirty;

        UndoRec * redo = undoChange(doc);

        doc.isDirty = (!oldModified && newModified ? false : true);

        if (redo)
                redo->oldModified = newModified;

        return redo;
}


//
// Class UndoAdd:
//
// UndoAdd undoes the addition of 1 or more rooms and/or edges.  Since
// edges are always added at the end of the list, we only need to know
// how many were added.
//
// Member Variables:
//   edges:    The number of edges that were added
//   pageNums: The numbers of the pages that were added
//   roomNums: The numbers of the rooms that were added
//--------------------------------------------------------------------
// Constructor for the redo record for UndoDelete:
//
// Input:
//   modified:  The modification state of the document
//   edgeCount: The number of edges being added
//   rns:       The numbers of the rooms being added
//   pns:       The numbers of the pages being added
//
UndoAdd::UndoAdd(bool modified, int edgeCount, RoomNumVec & rns, PageNumVec & pns): UndoRec(modified), edges(edgeCount)
{
        pageNums.swap(pns);
        roomNums.swap(rns);
}


//
// Constructor for a one-room addition:
//
// Input:
//   modified:  The modification state of the document
//   roomNum:   The number of the room being added
//   edgeCount: The number of edges being added
//
UndoAdd::UndoAdd(bool modified, RoomNum roomNum, int edgeCount): UndoRec(modified), edges(edgeCount)
{
        roomNums.push_back(roomNum);
}


//
// Constructor for a one-page addition:
//
// Input:
//   modified: The modification state of the document
//   pageNum:  The number of the page being added
//
UndoAdd::UndoAdd(bool modified, short pageNum): UndoRec(modified), edges(0)
{
        pageNums.push_back(pageNum);
}


//
// Constructor for a one-edge addition:
//
// Input:
//   modified:   The modification state of the document
//
UndoAdd::UndoAdd(bool modified): UndoRec(modified), edges(1)
{
}


const char * UndoAdd::getName() const
{
        return "Add";
}


//
// Undo the addition of rooms, edges, and/or pages:
//
UndoRec * UndoAdd::undoChange(MapDoc & doc)
{
        UndoRec * redo = new UndoDelete(doc, edges, roomNums, pageNums);
        int e = edges;

        for(int i=doc.edge.size()-1; e; e--)
                doc.deleteEdge(i--);

        RNConstItr r = roomNums.end();

        while (r != roomNums.begin())
                doc.deleteRoom(*(--r));

        PNConstItr p = pageNums.end();

        while (p != pageNums.begin())
                doc.deletePage(*(--p));

        return redo;
}


//
// Class UndoChangeEdge:
//
// UndoChangeEdge is used when an existing connection is changed.
// Since edges are changed by being deleted and re-added, it assumes
// that the edge is the last one in the list.  (N.B.: This is bad, but we'll roll with it for now.)
//
// Member Variables:
//   edge:  The original edge
//--------------------------------------------------------------------
// Constructor:
//
// Input:
//   modified:  The modification state of the document
//   theEdge:   The original edge
//
UndoChangeEdge::UndoChangeEdge(bool modified, const MapEdge & theEdge): UndoRec(modified), edge(theEdge)
{
}


const char * UndoChangeEdge::getName() const
{
        return "Reconnection";
}


//
// Undo a change to a connection:
//
UndoRec * UndoChangeEdge::undoChange(MapDoc & doc)
{
        const int edgeNum = doc.edge.size() - 1;
        UndoRec * redo = new UndoChangeEdge(true, doc.edge[edgeNum]);

        doc.deleteEdge(edgeNum);
        doc.addEdge(edge);

        return redo;
}


//
// Class UndoChanges:
//
// UndoChanges combines both UndoAdd & UndoDelete in one record.
//--------------------------------------------------------------------
// Constructor for adding one room & deleting one edge:
//
// Input:
//   modified:   The modification state of the document
//   roomNum:    The number of the room being added
//   edgeCount:  The number of edges being added
//   edge:       The edge being deleted
//
UndoChanges::UndoChanges(bool modified, RoomNum roomNum, int edgeCount, const MapEdge & edge): UndoRec(modified), add(new UndoAdd(modified, roomNum, edgeCount)), del(new UndoDelete(modified, edge))
{
}


//
// Constructor for adding one room & deleting one edge:
//
// Input:
//   modified:   The modification state of the document
//   roomNum:    The number of the room being added (-1 if no room added)
//   edgeCount:  The number of edges being added
//   edges:      The edges being deleted
//
// Output:
//   edges:      The vector is emptied
//
UndoChanges::UndoChanges(bool modified, int roomNum, int edgeCount, EdgeVec & edges): UndoRec(modified), del(new UndoDelete(modified, edges))
{
        if (roomNum >= 0)
                add = new UndoAdd(modified, roomNum, edgeCount);
        else
                add = new UndoAdd(modified);
}


//
// Constructor for removing a corner:
//
// Input:
//   modified:   The modification state of the document
//   roomNum:    The number of the room being deleted
//   room:       The room being deleted
//   edges:      The edges being deleted
//
// Output:
//   edges:  The vector is emptied
//
UndoChanges::UndoChanges(bool modified, RoomNum roomNum, MapRoom * room, EdgeVec & edges): UndoRec(modified), add(new UndoAdd(modified)),/* Adding 1 edge */ del(new UndoDelete(modified, edges))
{
        static_cast<UndoDelete *>(del)->addRooms(1);
        static_cast<UndoDelete *>(del)->addRoom(0, roomNum, room);
}


const char * UndoChanges::getName() const
{
        return "Change";          // FIXME better name
}


UndoRec * UndoChanges::undoChange(MapDoc & doc)
{
        UndoRec * redo = NULL;

        UndoRec * newDel = add->undoChange(doc);
        delete add;

        add = del->undoChange(doc);
        delete del;
        del = newDel;

        if (add && del)
                redo = this;

        return redo;
}


//
// Class UndoDelete:
//
// UndoDelete undoes the deletion of 1 or more rooms and/or edges.  Edges are
// restored to the end of the list, but rooms regain their original numbers.
//
// Member Variables:
//   edges:
//     The edges that were deleted.
//     They are stored with the original room numbers.
//   pages:
//     The pages that were deleted.
//   pageNums:
//     The numbers of the pages that were deleted.
//   rooms:
//     The rooms that were deleted.
//   roomNums:
//     The numbers of the rooms that were deleted.
//--------------------------------------------------------------------
// Constructor used when deleting the selection:
//
// Builds a list of the selected rooms and all edges which connect to them.
//
// Input:
//   doc:              The document we're working with
//   numSelected:      The number of selected rooms
//   selectedRooms:    TRUE means the room is selected
//   numSelectedPages: The number of selected pages
//   selectedPages:    TRUE means the page is selected
//
UndoDelete::UndoDelete(const MapDoc & doc, int numSelected, const ByteVec & selectedRooms, int numSelectedPages, const ByteVec & selectedPages): UndoRec(doc.isDirty)
{
        int i;
        addRooms(numSelected);
        EdgeConstItr edge = doc.edge.begin();

        for(i=doc.edge.size()-1; i>=0; edge++, i--)
        {
                if (selectedRooms[edge->room1] || selectedRooms[edge->room2])
                        edges.push_back(*edge);
        }

        pages.resize(numSelectedPages);
        pageNums.resize(numSelectedPages);
        PageConstItr page = doc.page.begin();
        PageItr p = pages.begin();
        PNItr pn = pageNums.begin();

        for(i=0; numSelectedPages; i++)
        {
                if (selectedPages[i])
                {
                        numSelectedPages--;
                        *(p++) = page[i];
                        *(pn++) = i;
                }
        }
}


//
// Constructor used for the redo record for UndoAdd:
//
// Input:
//   doc:          The document we're working with
//   numEdges:     The number of edges being deleted
//   theRoomNums:  The numbers of the rooms being deleted
//   thePageNums:  The numbers of the pages being deleted
//
UndoDelete::UndoDelete(const MapDoc & doc, int numEdges, const RoomNumVec & theRoomNums, const PageNumVec & thePageNums): UndoRec(doc.isDirty), pageNums(thePageNums), roomNums(theRoomNums)
{
        edges.insert(edges.begin(), doc.edge.end() - numEdges, doc.edge.end());

        RoomConstItr  room = doc.room.getVector().begin();
        rooms.reserve(roomNums.size());

        for(RNConstItr r=roomNums.begin(); r!=roomNums.end(); ++r)
                rooms.append(new MapRoom(*room[*r]));

        PageConstItr page = doc.page.begin();
        pages.reserve(pageNums.size());

        for(PNConstItr p=pageNums.begin(); p!=pageNums.end(); ++p)
                pages.push_back(page[*p]);
}


//
// Constructor used when deleting one edge:
//
// Input:
//   modified:  The modification state of the document
//   edge:      The edge that was deleted
//
UndoDelete::UndoDelete(bool modified, const MapEdge & edge): UndoRec(modified)
{
        edges.push_back(edge);
}


void UndoDelete::addRoom(VecSize pos, RoomNum n, MapRoom * r)
{
        roomNums[pos] = n;
        rooms.getVector()[pos] = r;
}


void UndoDelete::addRooms(VecSize n)
{
        rooms.resize(n);
        roomNums.resize(n);
}


//
// Constructor used when deleting several edges:
//
// Input:
//   modified:  The modification state of the document
//   theEdges:  The edges that were deleted
//
// Output:
//   theEdges:  The vector is emptied
//
UndoDelete::UndoDelete(bool modified, EdgeVec & theEdges): UndoRec(modified)
{
        edges.swap(theEdges);
}


const char * UndoDelete::getName() const
{
        return "Deletion";
}


//
// Undo the deletion of rooms and/or edges:
//
UndoRec * UndoDelete::undoChange(MapDoc & doc)
{
        ASSERT(rooms.size() == roomNums.size());
        doc.addRooms(rooms.size());
        RoomItr r = rooms.getVector().begin();

        for(RNConstItr rn=roomNums.begin(); rn!=roomNums.end(); r++, rn++)
        {
                doc.addRoom(*rn, *r);
                *r = NULL;
        }

        doc.addEdges(edges.size());

        for(EdgeConstItr e=edges.begin(); e!=edges.end(); ++e)
                doc.addEdge(*e);

        ASSERT(pages.size() == pageNums.size());
        doc.addPages(pages.size());
        PageConstItr p = pages.begin();

        for(PNConstItr pn=pageNums.begin(); pn!=pageNums.end(); p++, pn++)
                doc.addPage(*pn, *p);

        return new UndoAdd(true, edges.size(), roomNums, pageNums);
}


//
// Class UndoMove:
//
// UndoMove undoes room movement.
//
// Member Variables:
//   offset:    The amount the rooms were moved
//   pageNums:  The numbers of the pages that were moved
//   roomNums:  The numbers of the rooms that were moved
//--------------------------------------------------------------------
// Constructor used after dragging the selection:
//
// Input:
//   modified:          The modification state of the document
//   moved:             The distance the rooms were moved
//   numSelected:       The number of selected rooms
//   selectedRooms:     TRUE means the room is selected
//   numSelectedPages:  The number of selected pages
//   selectedPages:     TRUE means the page is selected
//
UndoMove::UndoMove(bool modified, const QSize & moved, int numSelected, const ByteVec & selectedRooms, int numSelectedPages, const ByteVec & selectedPages): UndoRec(modified), offset(moved)
{
        int i, j;
        pageNums.resize(numSelectedPages);

        for(i=0, j=0; i<numSelectedPages; j++)
        {
                if (selectedPages[j])
                        pageNums[i++] = j;
        }

        roomNums.resize(numSelected);

        for(i=0, j=0; i<numSelected; j++)
        {
                if (selectedRooms[j])
                        roomNums[i++] = j;
        }
}


//
// Constructor used for the redo record:
//
// Input:
//   modified:  The modification state of the document
//   moved:     The distance the rooms were moved
//   rooms:     The numbers of the rooms being moved
//   pages:     The numbers of the pages being moved
//
// Output:
//   rooms & pages:  Empty
//
UndoMove::UndoMove(bool modified, const QSize & moved, RoomNumVec & rooms, PageNumVec & pages): UndoRec(modified), offset(moved)
{
        pageNums.swap(pages);
        roomNums.swap(rooms);
}


const char * UndoMove::getName() const
{
        return "Move";
}


//
// Undo room movement
//
UndoRec * UndoMove::undoChange(MapDoc & doc)
{
        offset *= -1;

        for(PNConstItr p=pageNums.begin(); p!=pageNums.end(); p++)
                doc.movePage(*p, offset);

        for(RNConstItr r=roomNums.begin(); r!=roomNums.end(); r++)
                doc.moveRoom(*r, offset);

        return new UndoMove(false, offset, roomNums, pageNums);
}


//
// Class UndoPaginate:
//
// UndoPaginate undoes a repagination.
//
// Member Variables:
//   pages:  The old pages
//--------------------------------------------------------------------
// Constructor:
//
// This removes the pages from the document.
//
// Input:
//   doc:  The document we're working with
//
UndoPaginate::UndoPaginate(MapDoc & doc): UndoRec(doc.isDirty)
{
        pages.swap(doc.page);
}


const PageVec & UndoPaginate::getPages() const
{
        return pages;
}


const char * UndoPaginate::getName() const
{
        return "Page Layout";
}


//
// Undo the deletion of rooms and/or edges:
//
UndoRec * UndoPaginate::undoChange(MapDoc & doc)
{
        UndoRec * redo = new UndoPaginate(doc);
        pages.swap(doc.page);
        doc.UpdateAllViews(NULL, dupPageCount, NULL);

        return redo;
}


//
// Class UndoRoomInfo:
//
// UndoRoomInfo undoes changes made in the Room Properties dialog.
// Currently, this is only the room name.
//
// Member Variables:
//   num:   The number of the room that was modified
//   room:  The room information
//--------------------------------------------------------------------
// Constructor:
//
// Input:
//   doc:      The document we're working with
//   roomNum:  The number of the room being modified
//
UndoRoomInfo::UndoRoomInfo(const MapDoc & doc, RoomNum roomNum): UndoRec(doc.isDirty), num(roomNum), room(doc.room[roomNum])
{
}


const char * UndoRoomInfo::getName() const
{
        return "Room Information";
}


//
// Undo a change in room information:
//
UndoRec * UndoRoomInfo::undoChange(MapDoc & doc)
{
        UndoRec * redo = new UndoRoomInfo(doc, num);

        doc.setRoomName(num, room.name.c_str());
        doc.setRoomNote(num, room.note.c_str());

        return redo;
}