mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-11 21:40:49 +00:00
9a95a2a1cf
Editor also seems to start, didn't test much further. Only tested 32bit Windows, I fear the editor code isn't 64bit clean.. I hope I haven't broken anything elsewhere..
909 lines
21 KiB
C++
909 lines
21 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "tools/edit_gui_common.h"
|
|
|
|
|
|
#include "qe3.h"
|
|
#include "Radiant.h"
|
|
|
|
/*
|
|
|
|
QERadiant Undo/Redo
|
|
|
|
|
|
basic setup:
|
|
|
|
<-g_undolist---------g_lastundo> <---map data---> <-g_lastredo---------g_redolist->
|
|
|
|
|
|
undo/redo on the world_entity is special, only the epair changes are remembered
|
|
and the world entity never gets deleted.
|
|
|
|
FIXME: maybe reset the Undo system at map load
|
|
maybe also reset the entityId at map load
|
|
*/
|
|
|
|
typedef struct undo_s
|
|
{
|
|
double time; //time operation was performed
|
|
int id; //every undo has an unique id
|
|
int done; //true when undo is build
|
|
char *operation; //name of the operation
|
|
brush_t brushlist; //deleted brushes
|
|
entity_t entitylist; //deleted entities
|
|
struct undo_s *prev, *next; //next and prev undo in list
|
|
} undo_t;
|
|
|
|
undo_t *g_undolist; //first undo in the list
|
|
undo_t *g_lastundo; //last undo in the list
|
|
undo_t *g_redolist; //first redo in the list
|
|
undo_t *g_lastredo; //last undo in list
|
|
int g_undoMaxSize = 64; //maximum number of undos
|
|
int g_undoSize = 0; //number of undos in the list
|
|
int g_undoMaxMemorySize = 2*1024*1024; //maximum undo memory (default 2 MB)
|
|
int g_undoMemorySize = 0; //memory size of undo buffer
|
|
int g_undoId = 1; //current undo ID (zero is invalid id)
|
|
int g_redoId = 1; //current redo ID (zero is invalid id)
|
|
|
|
|
|
/*
|
|
=============
|
|
Undo_MemorySize
|
|
=============
|
|
*/
|
|
int Undo_MemorySize(void)
|
|
{
|
|
/*
|
|
int size;
|
|
undo_t *undo;
|
|
brush_t *pBrush;
|
|
entity_t *pEntity;
|
|
|
|
size = 0;
|
|
for (undo = g_undolist; undo; undo = undo->next)
|
|
{
|
|
for (pBrush = undo->brushlist.next ; pBrush != NULL && pBrush != &undo->brushlist ; pBrush = pBrush->next)
|
|
{
|
|
size += Brush_MemorySize(pBrush);
|
|
}
|
|
for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = pEntity->next)
|
|
{
|
|
size += Entity_MemorySize(pEntity);
|
|
}
|
|
size += sizeof(undo_t);
|
|
}
|
|
return size;
|
|
*/
|
|
return g_undoMemorySize;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_ClearRedo
|
|
=============
|
|
*/
|
|
void Undo_ClearRedo(void)
|
|
{
|
|
undo_t *redo, *nextredo;
|
|
brush_t *pBrush, *pNextBrush;
|
|
entity_t *pEntity, *pNextEntity;
|
|
|
|
for (redo = g_redolist; redo; redo = nextredo)
|
|
{
|
|
nextredo = redo->next;
|
|
for (pBrush = redo->brushlist.next ; pBrush != NULL && pBrush != &redo->brushlist ; pBrush = pNextBrush)
|
|
{
|
|
pNextBrush = pBrush->next;
|
|
Brush_Free(pBrush);
|
|
}
|
|
for (pEntity = redo->entitylist.next; pEntity != NULL && pEntity != &redo->entitylist; pEntity = pNextEntity)
|
|
{
|
|
pNextEntity = pEntity->next;
|
|
Entity_Free(pEntity);
|
|
}
|
|
Mem_Free(redo);
|
|
}
|
|
g_redolist = NULL;
|
|
g_lastredo = NULL;
|
|
g_redoId = 1;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_Clear
|
|
|
|
Clears the undo buffer.
|
|
=============
|
|
*/
|
|
void Undo_Clear(void)
|
|
{
|
|
undo_t *undo, *nextundo;
|
|
brush_t *pBrush, *pNextBrush;
|
|
entity_t *pEntity, *pNextEntity;
|
|
|
|
Undo_ClearRedo();
|
|
for (undo = g_undolist; undo; undo = nextundo)
|
|
{
|
|
nextundo = undo->next;
|
|
for (pBrush = undo->brushlist.next ; pBrush != NULL && pBrush != &undo->brushlist ; pBrush = pNextBrush)
|
|
{
|
|
pNextBrush = pBrush->next;
|
|
g_undoMemorySize -= Brush_MemorySize(pBrush);
|
|
Brush_Free(pBrush);
|
|
}
|
|
for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = pNextEntity)
|
|
{
|
|
pNextEntity = pEntity->next;
|
|
g_undoMemorySize -= Entity_MemorySize(pEntity);
|
|
Entity_Free(pEntity);
|
|
}
|
|
g_undoMemorySize -= sizeof(undo_t);
|
|
Mem_Free(undo);
|
|
}
|
|
g_undolist = NULL;
|
|
g_lastundo = NULL;
|
|
g_undoSize = 0;
|
|
g_undoMemorySize = 0;
|
|
g_undoId = 1;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_SetMaxSize
|
|
=============
|
|
*/
|
|
void Undo_SetMaxSize(int size)
|
|
{
|
|
Undo_Clear();
|
|
if (size < 1) g_undoMaxSize = 1;
|
|
else g_undoMaxSize = size;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_GetMaxSize
|
|
=============
|
|
*/
|
|
int Undo_GetMaxSize(void)
|
|
{
|
|
return g_undoMaxSize;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_SetMaxMemorySize
|
|
=============
|
|
*/
|
|
void Undo_SetMaxMemorySize(int size)
|
|
{
|
|
Undo_Clear();
|
|
if (size < 1024) g_undoMaxMemorySize = 1024;
|
|
else g_undoMaxMemorySize = size;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_GetMaxMemorySize
|
|
=============
|
|
*/
|
|
int Undo_GetMaxMemorySize(void)
|
|
{
|
|
return g_undoMaxMemorySize;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_FreeFirstUndo
|
|
=============
|
|
*/
|
|
void Undo_FreeFirstUndo(void)
|
|
{
|
|
undo_t *undo;
|
|
brush_t *pBrush, *pNextBrush;
|
|
entity_t *pEntity, *pNextEntity;
|
|
|
|
//remove the oldest undo from the undo buffer
|
|
undo = g_undolist;
|
|
g_undolist = g_undolist->next;
|
|
g_undolist->prev = NULL;
|
|
//
|
|
for (pBrush = undo->brushlist.next ; pBrush != NULL && pBrush != &undo->brushlist ; pBrush = pNextBrush)
|
|
{
|
|
pNextBrush = pBrush->next;
|
|
g_undoMemorySize -= Brush_MemorySize(pBrush);
|
|
Brush_Free(pBrush);
|
|
}
|
|
for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = pNextEntity)
|
|
{
|
|
pNextEntity = pEntity->next;
|
|
g_undoMemorySize -= Entity_MemorySize(pEntity);
|
|
Entity_Free(pEntity);
|
|
}
|
|
g_undoMemorySize -= sizeof(undo_t);
|
|
Mem_Free(undo);
|
|
g_undoSize--;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_GeneralStart
|
|
=============
|
|
*/
|
|
void Undo_GeneralStart(char *operation)
|
|
{
|
|
undo_t *undo;
|
|
brush_t *pBrush;
|
|
entity_t *pEntity;
|
|
|
|
|
|
if (g_lastundo)
|
|
{
|
|
if (!g_lastundo->done)
|
|
{
|
|
common->Printf("Undo_Start: WARNING last undo not finished.\n");
|
|
}
|
|
}
|
|
|
|
undo = (undo_t *) Mem_ClearedAlloc(sizeof(undo_t));
|
|
if (!undo) return;
|
|
memset(undo, 0, sizeof(undo_t));
|
|
undo->brushlist.next = &undo->brushlist;
|
|
undo->brushlist.prev = &undo->brushlist;
|
|
undo->entitylist.next = &undo->entitylist;
|
|
undo->entitylist.prev = &undo->entitylist;
|
|
if (g_lastundo) g_lastundo->next = undo;
|
|
else g_undolist = undo;
|
|
undo->prev = g_lastundo;
|
|
undo->next = NULL;
|
|
g_lastundo = undo;
|
|
|
|
undo->time = Sys_DoubleTime();
|
|
//
|
|
if (g_undoId > g_undoMaxSize * 2) g_undoId = 1;
|
|
if (g_undoId <= 0) g_undoId = 1;
|
|
undo->id = g_undoId++;
|
|
undo->done = false;
|
|
undo->operation = operation;
|
|
//reset the undo IDs of all brushes using the new ID
|
|
for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pBrush->next)
|
|
{
|
|
if (pBrush->undoId == undo->id)
|
|
{
|
|
pBrush->undoId = 0;
|
|
}
|
|
}
|
|
for (pBrush = selected_brushes.next; pBrush != NULL && pBrush != &selected_brushes; pBrush = pBrush->next)
|
|
{
|
|
if (pBrush->undoId == undo->id)
|
|
{
|
|
pBrush->undoId = 0;
|
|
}
|
|
}
|
|
//reset the undo IDs of all entities using thew new ID
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
|
|
{
|
|
if (pEntity->undoId == undo->id)
|
|
{
|
|
pEntity->undoId = 0;
|
|
}
|
|
}
|
|
g_undoMemorySize += sizeof(undo_t);
|
|
g_undoSize++;
|
|
//undo buffer is bound to a max
|
|
if (g_undoSize > g_undoMaxSize)
|
|
{
|
|
Undo_FreeFirstUndo();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_BrushInUndo
|
|
=============
|
|
*/
|
|
int Undo_BrushInUndo(undo_t *undo, brush_t *brush)
|
|
{
|
|
brush_t *b;
|
|
|
|
for (b = undo->brushlist.next; b != &undo->brushlist; b = b->next)
|
|
{
|
|
if (b == brush) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_EntityInUndo
|
|
=============
|
|
*/
|
|
int Undo_EntityInUndo(undo_t *undo, entity_t *ent)
|
|
{
|
|
entity_t *e;
|
|
|
|
for (e = undo->entitylist.next; e != &undo->entitylist; e = e->next)
|
|
{
|
|
if (e == ent) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_Start
|
|
=============
|
|
*/
|
|
void Undo_Start(char *operation)
|
|
{
|
|
Undo_ClearRedo();
|
|
Undo_GeneralStart(operation);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_AddBrush
|
|
=============
|
|
*/
|
|
void Undo_AddBrush(brush_t *pBrush)
|
|
{
|
|
if (!g_lastundo)
|
|
{
|
|
Sys_Status("Undo_AddBrushList: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->entitylist.next != &g_lastundo->entitylist)
|
|
{
|
|
Sys_Status("Undo_AddBrushList: WARNING adding brushes after entity.\n");
|
|
}
|
|
//if the brush is already in the undo
|
|
if (Undo_BrushInUndo(g_lastundo, pBrush))
|
|
return;
|
|
//clone the brush
|
|
brush_t* pClone = Brush_FullClone(pBrush);
|
|
//save the ID of the owner entity
|
|
pClone->ownerId = pBrush->owner->entityId;
|
|
|
|
if (pBrush->owner && !(pBrush->owner->eclass->nShowFlags & ECLASS_WORLDSPAWN)) {
|
|
Undo_AddEntity(pBrush->owner);
|
|
}
|
|
|
|
//save the old undo ID for previous undos
|
|
pClone->undoId = pBrush->undoId;
|
|
Brush_AddToList (pClone, &g_lastundo->brushlist);
|
|
//
|
|
g_undoMemorySize += Brush_MemorySize(pClone);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_AddBrushList
|
|
=============
|
|
*/
|
|
void Undo_AddBrushList(brush_t *brushlist)
|
|
{
|
|
brush_t *pBrush;
|
|
|
|
if (!g_lastundo)
|
|
{
|
|
Sys_Status("Undo_AddBrushList: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->entitylist.next != &g_lastundo->entitylist)
|
|
{
|
|
Sys_Status("Undo_AddBrushList: WARNING adding brushes after entity.\n");
|
|
}
|
|
//copy the brushes to the undo
|
|
for (pBrush = brushlist->next ; pBrush != NULL && pBrush != brushlist; pBrush=pBrush->next)
|
|
{
|
|
//if the brush is already in the undo
|
|
if (Undo_BrushInUndo(g_lastundo, pBrush))
|
|
continue;
|
|
//clone the brush
|
|
brush_t* pClone = Brush_FullClone(pBrush);
|
|
//save the ID of the owner entity
|
|
pClone->ownerId = pBrush->owner->entityId;
|
|
//save the old undo ID from previous undos
|
|
pClone->undoId = pBrush->undoId;
|
|
|
|
if ( pBrush->owner && pBrush->owner != world_entity ) {
|
|
Undo_AddEntity(pBrush->owner);
|
|
}
|
|
|
|
|
|
Brush_AddToList (pClone, &g_lastundo->brushlist);
|
|
//
|
|
g_undoMemorySize += Brush_MemorySize(pClone);
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_EndBrush
|
|
=============
|
|
*/
|
|
void Undo_EndBrush(brush_t *pBrush)
|
|
{
|
|
if (!g_lastundo)
|
|
{
|
|
//Sys_Status("Undo_End: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->done)
|
|
{
|
|
//Sys_Status("Undo_End: last undo already finished.\n");
|
|
return;
|
|
}
|
|
pBrush->undoId = g_lastundo->id;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_EndBrushList
|
|
=============
|
|
*/
|
|
void Undo_EndBrushList(brush_t *brushlist)
|
|
{
|
|
if (!g_lastundo)
|
|
{
|
|
//Sys_Status("Undo_End: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->done)
|
|
{
|
|
//Sys_Status("Undo_End: last undo already finished.\n");
|
|
return;
|
|
}
|
|
for (brush_t* pBrush = brushlist->next; pBrush != NULL && pBrush != brushlist; pBrush=pBrush->next)
|
|
{
|
|
pBrush->undoId = g_lastundo->id;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_AddEntity
|
|
=============
|
|
*/
|
|
void Undo_AddEntity(entity_t *entity)
|
|
{
|
|
entity_t* pClone;
|
|
|
|
if (!g_lastundo)
|
|
{
|
|
Sys_Status("Undo_AddEntity: no last undo.\n");
|
|
return;
|
|
}
|
|
//if the entity is already in the undo
|
|
if (Undo_EntityInUndo(g_lastundo, entity))
|
|
return;
|
|
//clone the entity
|
|
pClone = Entity_Clone(entity);
|
|
//NOTE: Entity_Clone adds the entity to the entity list
|
|
// so we remove it from that list here
|
|
Entity_RemoveFromList(pClone);
|
|
//save the old undo ID for previous undos
|
|
pClone->undoId = entity->undoId;
|
|
//save the entity ID (we need a full clone)
|
|
pClone->entityId = entity->entityId;
|
|
//
|
|
Entity_AddToList(pClone, &g_lastundo->entitylist);
|
|
//
|
|
g_undoMemorySize += Entity_MemorySize(pClone);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_EndEntity
|
|
=============
|
|
*/
|
|
void Undo_EndEntity(entity_t *entity)
|
|
{
|
|
if (!g_lastundo)
|
|
{
|
|
//Sys_Status("Undo_End: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->done)
|
|
{
|
|
//Sys_Status("Undo_End: last undo already finished.\n");
|
|
return;
|
|
}
|
|
if (entity == world_entity)
|
|
{
|
|
//Sys_Status("Undo_AddEntity: undo on world entity.\n");
|
|
//NOTE: we never delete the world entity when undoing an operation
|
|
// we only transfer the epairs
|
|
return;
|
|
}
|
|
entity->undoId = g_lastundo->id;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_End
|
|
=============
|
|
*/
|
|
void Undo_End(void)
|
|
{
|
|
if (!g_lastundo)
|
|
{
|
|
//Sys_Status("Undo_End: no last undo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo->done)
|
|
{
|
|
//Sys_Status("Undo_End: last undo already finished.\n");
|
|
return;
|
|
}
|
|
g_lastundo->done = true;
|
|
|
|
//undo memory size is bound to a max
|
|
while (g_undoMemorySize > g_undoMaxMemorySize)
|
|
{
|
|
//always keep one undo
|
|
if (g_undolist == g_lastundo) break;
|
|
Undo_FreeFirstUndo();
|
|
}
|
|
//
|
|
//Sys_Status("undo size = %d, undo memory = %d\n", g_undoSize, g_undoMemorySize);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_Undo
|
|
=============
|
|
*/
|
|
void Undo_Undo(void)
|
|
{
|
|
undo_t *undo, *redo;
|
|
brush_t *pBrush, *pNextBrush;
|
|
entity_t *pEntity, *pNextEntity, *pUndoEntity;
|
|
|
|
if (!g_lastundo)
|
|
{
|
|
Sys_Status("Nothing left to undo.\n");
|
|
return;
|
|
}
|
|
if (!g_lastundo->done)
|
|
{
|
|
Sys_Status("Undo_Undo: WARNING: last undo not yet finished!\n");
|
|
}
|
|
// get the last undo
|
|
undo = g_lastundo;
|
|
if (g_lastundo->prev) g_lastundo->prev->next = NULL;
|
|
else g_undolist = NULL;
|
|
g_lastundo = g_lastundo->prev;
|
|
|
|
//allocate a new redo
|
|
redo = (undo_t *) Mem_ClearedAlloc(sizeof(undo_t));
|
|
if (!redo) return;
|
|
memset(redo, 0, sizeof(undo_t));
|
|
redo->brushlist.next = &redo->brushlist;
|
|
redo->brushlist.prev = &redo->brushlist;
|
|
redo->entitylist.next = &redo->entitylist;
|
|
redo->entitylist.prev = &redo->entitylist;
|
|
if (g_lastredo) g_lastredo->next = redo;
|
|
else g_redolist = redo;
|
|
redo->prev = g_lastredo;
|
|
redo->next = NULL;
|
|
g_lastredo = redo;
|
|
redo->time = Sys_DoubleTime();
|
|
redo->id = g_redoId++;
|
|
redo->done = true;
|
|
redo->operation = undo->operation;
|
|
|
|
//reset the redo IDs of all brushes using the new ID
|
|
for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pBrush->next)
|
|
{
|
|
if (pBrush->redoId == redo->id)
|
|
{
|
|
pBrush->redoId = 0;
|
|
}
|
|
}
|
|
for (pBrush = selected_brushes.next; pBrush != NULL && pBrush != &selected_brushes; pBrush = pBrush->next)
|
|
{
|
|
if (pBrush->redoId == redo->id)
|
|
{
|
|
pBrush->redoId = 0;
|
|
}
|
|
}
|
|
//reset the redo IDs of all entities using thew new ID
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
|
|
{
|
|
if (pEntity->redoId == redo->id)
|
|
{
|
|
pEntity->redoId = 0;
|
|
}
|
|
}
|
|
|
|
// remove current selection
|
|
Select_Deselect();
|
|
// move "created" brushes to the redo
|
|
for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush=pNextBrush)
|
|
{
|
|
pNextBrush = pBrush->next;
|
|
if (pBrush->undoId == undo->id)
|
|
{
|
|
//Brush_Free(pBrush);
|
|
//move the brush to the redo
|
|
Brush_RemoveFromList(pBrush);
|
|
Brush_AddToList(pBrush, &redo->brushlist);
|
|
//make sure the ID of the owner is stored
|
|
pBrush->ownerId = pBrush->owner->entityId;
|
|
//unlink the brush from the owner entity
|
|
Entity_UnlinkBrush(pBrush);
|
|
}
|
|
}
|
|
// move "created" entities to the redo
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pNextEntity)
|
|
{
|
|
pNextEntity = pEntity->next;
|
|
if (pEntity->undoId == undo->id)
|
|
{
|
|
// check if this entity is in the undo
|
|
for (pUndoEntity = undo->entitylist.next; pUndoEntity != NULL && pUndoEntity != &undo->entitylist; pUndoEntity = pUndoEntity->next)
|
|
{
|
|
// move brushes to the undo entity
|
|
if (pUndoEntity->entityId == pEntity->entityId)
|
|
{
|
|
pUndoEntity->brushes.next = pEntity->brushes.next;
|
|
pUndoEntity->brushes.prev = pEntity->brushes.prev;
|
|
pEntity->brushes.next = &pEntity->brushes;
|
|
pEntity->brushes.prev = &pEntity->brushes;
|
|
}
|
|
}
|
|
//
|
|
//Entity_Free(pEntity);
|
|
//move the entity to the redo
|
|
Entity_RemoveFromList(pEntity);
|
|
Entity_AddToList(pEntity, &redo->entitylist);
|
|
}
|
|
}
|
|
// add the undo entities back into the entity list
|
|
for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = undo->entitylist.next)
|
|
{
|
|
g_undoMemorySize -= Entity_MemorySize(pEntity);
|
|
//if this is the world entity
|
|
if (pEntity->entityId == world_entity->entityId)
|
|
{
|
|
//free the epairs of the world entity
|
|
Entity_FreeEpairs(world_entity);
|
|
//set back the original epairs
|
|
world_entity->epairs = pEntity->epairs;
|
|
//free the world_entity clone that stored the epairs
|
|
Entity_Free(pEntity);
|
|
}
|
|
else
|
|
{
|
|
Entity_RemoveFromList(pEntity);
|
|
Entity_AddToList(pEntity, &entities);
|
|
pEntity->redoId = redo->id;
|
|
}
|
|
}
|
|
// add the undo brushes back into the selected brushes
|
|
for (pBrush = undo->brushlist.next; pBrush != NULL && pBrush != &undo->brushlist; pBrush = undo->brushlist.next)
|
|
{
|
|
g_undoMemorySize -= Brush_MemorySize(pBrush);
|
|
Brush_RemoveFromList(pBrush);
|
|
Brush_AddToList(pBrush, &active_brushes);
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
|
|
{
|
|
if (pEntity->entityId == pBrush->ownerId)
|
|
{
|
|
Entity_LinkBrush(pEntity, pBrush);
|
|
break;
|
|
}
|
|
}
|
|
//if the brush is not linked then it should be linked into the world entity
|
|
if (pEntity == NULL || pEntity == &entities)
|
|
{
|
|
Entity_LinkBrush(world_entity, pBrush);
|
|
}
|
|
//build the brush
|
|
//Brush_Build(pBrush);
|
|
Select_Brush(pBrush);
|
|
pBrush->redoId = redo->id;
|
|
}
|
|
//
|
|
common->Printf("%s undone.\n", undo->operation);
|
|
// free the undo
|
|
g_undoMemorySize -= sizeof(undo_t);
|
|
Mem_Free(undo);
|
|
g_undoSize--;
|
|
g_undoId--;
|
|
if (g_undoId <= 0) g_undoId = 2 * g_undoMaxSize;
|
|
//
|
|
|
|
Sys_BeginWait();
|
|
brush_t *b, *next;
|
|
for (b = active_brushes.next ; b != NULL && b != &active_brushes ; b=next) {
|
|
next = b->next;
|
|
Brush_Build( b, true, false, false );
|
|
}
|
|
for (b = selected_brushes.next ; b != NULL && b != &selected_brushes ; b=next) {
|
|
next = b->next;
|
|
Brush_Build( b, true, false, false );
|
|
}
|
|
Sys_EndWait();
|
|
|
|
g_bScreenUpdates = true;
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_Redo
|
|
=============
|
|
*/
|
|
void Undo_Redo(void)
|
|
{
|
|
undo_t *redo;
|
|
brush_t *pBrush, *pNextBrush;
|
|
entity_t *pEntity, *pNextEntity, *pRedoEntity;
|
|
|
|
if (!g_lastredo)
|
|
{
|
|
Sys_Status("Nothing left to redo.\n");
|
|
return;
|
|
}
|
|
if (g_lastundo)
|
|
{
|
|
if (!g_lastundo->done)
|
|
{
|
|
Sys_Status("WARNING: last undo not finished.\n");
|
|
}
|
|
}
|
|
// get the last redo
|
|
redo = g_lastredo;
|
|
if (g_lastredo->prev) g_lastredo->prev->next = NULL;
|
|
else g_redolist = NULL;
|
|
g_lastredo = g_lastredo->prev;
|
|
//
|
|
Undo_GeneralStart(redo->operation);
|
|
// remove current selection
|
|
Select_Deselect();
|
|
// move "created" brushes back to the last undo
|
|
for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pNextBrush)
|
|
{
|
|
pNextBrush = pBrush->next;
|
|
if (pBrush->redoId == redo->id)
|
|
{
|
|
//move the brush to the undo
|
|
Brush_RemoveFromList(pBrush);
|
|
Brush_AddToList(pBrush, &g_lastundo->brushlist);
|
|
g_undoMemorySize += Brush_MemorySize(pBrush);
|
|
pBrush->ownerId = pBrush->owner->entityId;
|
|
Entity_UnlinkBrush(pBrush);
|
|
}
|
|
}
|
|
// move "created" entities back to the last undo
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pNextEntity)
|
|
{
|
|
pNextEntity = pEntity->next;
|
|
if (pEntity->redoId == redo->id)
|
|
{
|
|
// check if this entity is in the redo
|
|
for (pRedoEntity = redo->entitylist.next; pRedoEntity != NULL && pRedoEntity != &redo->entitylist; pRedoEntity = pRedoEntity->next)
|
|
{
|
|
// move brushes to the redo entity
|
|
if (pRedoEntity->entityId == pEntity->entityId)
|
|
{
|
|
pRedoEntity->brushes.next = pEntity->brushes.next;
|
|
pRedoEntity->brushes.prev = pEntity->brushes.prev;
|
|
pEntity->brushes.next = &pEntity->brushes;
|
|
pEntity->brushes.prev = &pEntity->brushes;
|
|
}
|
|
}
|
|
//
|
|
//Entity_Free(pEntity);
|
|
//move the entity to the redo
|
|
Entity_RemoveFromList(pEntity);
|
|
Entity_AddToList(pEntity, &g_lastundo->entitylist);
|
|
g_undoMemorySize += Entity_MemorySize(pEntity);
|
|
}
|
|
}
|
|
// add the undo entities back into the entity list
|
|
for (pEntity = redo->entitylist.next; pEntity != NULL && pEntity != &redo->entitylist; pEntity = redo->entitylist.next)
|
|
{
|
|
//if this is the world entity
|
|
if (pEntity->entityId == world_entity->entityId)
|
|
{
|
|
//free the epairs of the world entity
|
|
Entity_FreeEpairs(world_entity);
|
|
//set back the original epairs
|
|
world_entity->epairs = pEntity->epairs;
|
|
//free the world_entity clone that stored the epairs
|
|
Entity_Free(pEntity);
|
|
}
|
|
else
|
|
{
|
|
Entity_RemoveFromList(pEntity);
|
|
Entity_AddToList(pEntity, &entities);
|
|
}
|
|
}
|
|
// add the redo brushes back into the selected brushes
|
|
for (pBrush = redo->brushlist.next; pBrush != NULL && pBrush != &redo->brushlist; pBrush = redo->brushlist.next)
|
|
{
|
|
Brush_RemoveFromList(pBrush);
|
|
Brush_AddToList(pBrush, &active_brushes);
|
|
for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
|
|
{
|
|
if (pEntity->entityId == pBrush->ownerId)
|
|
{
|
|
Entity_LinkBrush(pEntity, pBrush);
|
|
break;
|
|
}
|
|
}
|
|
//if the brush is not linked then it should be linked into the world entity
|
|
if (pEntity == NULL || pEntity == &entities)
|
|
{
|
|
Entity_LinkBrush(world_entity, pBrush);
|
|
}
|
|
//build the brush
|
|
//Brush_Build(pBrush);
|
|
Select_Brush(pBrush);
|
|
}
|
|
//
|
|
Undo_End();
|
|
//
|
|
common->Printf("%s redone.\n", redo->operation);
|
|
//
|
|
g_redoId--;
|
|
// free the undo
|
|
Mem_Free(redo);
|
|
//
|
|
g_bScreenUpdates = true;
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_RedoAvailable
|
|
=============
|
|
*/
|
|
int Undo_RedoAvailable(void)
|
|
{
|
|
if (g_lastredo) return true;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Undo_UndoAvailable
|
|
=============
|
|
*/
|
|
int Undo_UndoAvailable(void)
|
|
{
|
|
if (g_lastundo)
|
|
{
|
|
if (g_lastundo->done)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|