radiant/undo.cpp

   1 /*
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22
  23 /*
  24
  25   QERadiant Undo/Redo
  26
  27
  28 basic setup:
  29
  30 <-g_undolist---------g_lastundo> <---map data---> <-g_lastredo---------g_redolist->
  31
  32
  33   undo/redo on the world_entity is special, only the epair changes are remembered
  34   and the world entity never gets deleted.
  35
  36   FIXME: maybe reset the Undo system at map load
  37                  maybe also reset the entityId at map load
  38 */
  39
  40 #include "stdafx.h"
  41
  42 typedef struct undo_s
  43 {
  44         double time;                            //time operation was performed
  45         int id;                                         //every undo has an unique id
  46         int done;                                       //true when undo is build
  47         char *operation;                        //name of the operation
  48         brush_t brushlist;                      //deleted brushes
  49         entity_t entitylist;            //deleted entities
  50         struct undo_s *prev, *next;     //next and prev undo in list
  51 } undo_t;
  52
  53 undo_t *g_undolist;                                             //first undo in the list
  54 undo_t *g_lastundo;                                             //last undo in the list
  55 undo_t *g_redolist;                                             //first redo in the list
  56 undo_t *g_lastredo;                                             //last undo in list
  57 int g_undoMaxSize = 64;                                 //maximum number of undos
  58 int g_undoSize = 0;                                             //number of undos in the list
  59 int g_undoMaxMemorySize = 2*1024*1024;  //maximum undo memory (default 2 MB)
  60 int g_undoMemorySize = 0;                               //memory size of undo buffer
  61 int g_undoId = 1;                                               //current undo ID (zero is invalid id)
  62 int g_redoId = 1;                                               //current redo ID (zero is invalid id)
  63
  64 /*
  65 =============
  66 Undo_MemorySize
  67 =============
  68 */
  69 int Undo_MemorySize(void)
  70 {
  71         return g_undoMemorySize;
  72 }
  73
  74 /*
  75 =============
  76 Undo_ClearRedo
  77 =============
  78 */
  79 void Undo_ClearRedo(void)
  80 {
  81         undo_t *redo, *nextredo;
  82         brush_t *pBrush, *pNextBrush;
  83         entity_t *pEntity, *pNextEntity;
  84
  85         for (redo = g_redolist; redo; redo = nextredo)
  86         {
  87                 nextredo = redo->next;
  88                 for (pBrush = redo->brushlist.next ; pBrush != NULL && pBrush != &redo->brushlist ; pBrush = pNextBrush)
  89                 {
  90                         pNextBrush = pBrush->next;
  91                         Brush_Free(pBrush);
  92                 }
  93                 for (pEntity = redo->entitylist.next; pEntity != NULL && pEntity != &redo->entitylist; pEntity = pNextEntity)
  94                 {
  95                         pNextEntity = pEntity->next;
  96                         Entity_Free(pEntity);
  97                 }
  98                 free(redo);
  99         }
 100         g_redolist = NULL;
 101         g_lastredo = NULL;
 102         g_redoId = 1;
 103 }
 104
 105 /*
 106 =============
 107 Undo_Clear
 108
 109   Clears the undo buffer.
 110 =============
 111 */
 112 void Undo_Clear(void)
 113 {
 114         undo_t *undo, *nextundo;
 115         brush_t *pBrush, *pNextBrush;
 116         entity_t *pEntity, *pNextEntity;
 117
 118         Undo_ClearRedo();
 119         for (undo = g_undolist; undo; undo = nextundo)
 120         {
 121                 nextundo = undo->next;
 122                 for (pBrush = undo->brushlist.next ; pBrush != NULL && pBrush != &undo->brushlist ; pBrush = pNextBrush)
 123                 {
 124                         pNextBrush = pBrush->next;
 125                         g_undoMemorySize -= Brush_MemorySize(pBrush);
 126                         Brush_Free(pBrush);
 127                 }
 128                 for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = pNextEntity)
 129                 {
 130                         pNextEntity = pEntity->next;
 131                         g_undoMemorySize -= Entity_MemorySize(pEntity);
 132                         Entity_Free(pEntity);
 133                 }
 134                 g_undoMemorySize -= sizeof(undo_t);
 135                 free(undo);
 136         }
 137         g_undolist = NULL;
 138         g_lastundo = NULL;
 139         g_undoSize = 0;
 140         g_undoMemorySize = 0;
 141         g_undoId = 1;
 142 }
 143
 144 /*
 145 =============
 146 Undo_SetMaxSize
 147 =============
 148 */
 149 void Undo_SetMaxSize(int size)
 150 {
 151         Undo_Clear();
 152         if (size < 1) g_undoMaxSize = 1;
 153         else g_undoMaxSize = size;
 154 }
 155
 156 /*
 157 =============
 158 Undo_GetMaxSize
 159 =============
 160 */
 161 int Undo_GetMaxSize(void)
 162 {
 163         return g_undoMaxSize;
 164 }
 165
 166 /*
 167 =============
 168 Undo_SetMaxMemorySize
 169 =============
 170 */
 171 void Undo_SetMaxMemorySize(int size)
 172 {
 173         Undo_Clear();
 174         if (size < 1024) g_undoMaxMemorySize = 1024;
 175         else g_undoMaxMemorySize = size;
 176 }
 177
 178 /*
 179 =============
 180 Undo_GetMaxMemorySize
 181 =============
 182 */
 183 int Undo_GetMaxMemorySize(void)
 184 {
 185         return g_undoMaxMemorySize;
 186 }
 187
 188 /*
 189 =============
 190 Undo_FreeFirstUndo
 191 =============
 192 */
 193 void Undo_FreeFirstUndo(void)
 194 {
 195         undo_t *undo;
 196         brush_t *pBrush, *pNextBrush;
 197         entity_t *pEntity, *pNextEntity;
 198
 199         //remove the oldest undo from the undo buffer
 200         undo = g_undolist;
 201         g_undolist = g_undolist->next;
 202         g_undolist->prev = NULL;
 203         //
 204         for (pBrush = undo->brushlist.next ; pBrush != NULL && pBrush != &undo->brushlist ; pBrush = pNextBrush)
 205         {
 206                 pNextBrush = pBrush->next;
 207                 g_undoMemorySize -= Brush_MemorySize(pBrush);
 208                 Brush_Free(pBrush);
 209         }
 210         for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = pNextEntity)
 211         {
 212                 pNextEntity = pEntity->next;
 213                 g_undoMemorySize -= Entity_MemorySize(pEntity);
 214                 Entity_Free(pEntity);
 215         }
 216         g_undoMemorySize -= sizeof(undo_t);
 217         free(undo);
 218         g_undoSize--;
 219 }
 220
 221 /*
 222 =============
 223 Undo_GeneralStart
 224 =============
 225 */
 226 void Undo_GeneralStart(char *operation)
 227 {
 228         undo_t *undo;
 229         brush_t *pBrush;
 230         entity_t *pEntity;
 231
 232
 233         if (g_lastundo)
 234         {
 235                 if (!g_lastundo->done)
 236                 {
 237                         Sys_Printf("Undo_Start: WARNING last undo not finished.\n");
 238                 }
 239         }
 240
 241         undo = (undo_t *) malloc(sizeof(undo_t));
 242         if (!undo)
 243     return;
 244         memset(undo, 0, sizeof(undo_t));
 245         undo->brushlist.next = &undo->brushlist;
 246         undo->brushlist.prev = &undo->brushlist;
 247         undo->entitylist.next = &undo->entitylist;
 248         undo->entitylist.prev = &undo->entitylist;
 249         if (g_lastundo)
 250     g_lastundo->next = undo;
 251         else
 252     g_undolist = undo;
 253         undo->prev = g_lastundo;
 254         undo->next = NULL;
 255         g_lastundo = undo;
 256
 257         undo->time = Sys_DoubleTime();
 258         //
 259         if (g_undoId > g_undoMaxSize * 2) g_undoId = 1;
 260         if (g_undoId <= 0) g_undoId = 1;
 261         undo->id = g_undoId++;
 262         undo->done = false;
 263         undo->operation = operation;
 264         //reset the undo IDs of all brushes using the new ID
 265         for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pBrush->next)
 266         {
 267                 if (pBrush->undoId == undo->id)
 268                 {
 269                         pBrush->undoId = 0;
 270                 }
 271         }
 272         for (pBrush = selected_brushes.next; pBrush != NULL && pBrush != &selected_brushes; pBrush = pBrush->next)
 273         {
 274                 if (pBrush->undoId == undo->id)
 275                 {
 276                         pBrush->undoId = 0;
 277                 }
 278         }
 279         //reset the undo IDs of all entities using thew new ID
 280         for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
 281         {
 282                 if (pEntity->undoId == undo->id)
 283                 {
 284                         pEntity->undoId = 0;
 285                 }
 286         }
 287         g_undoMemorySize += sizeof(undo_t);
 288         g_undoSize++;
 289         //undo buffer is bound to a max
 290         if (g_undoSize > g_undoMaxSize)
 291         {
 292                 Undo_FreeFirstUndo();
 293         }
 294 }
 295
 296 /*
 297 =============
 298 Undo_BrushInUndo
 299 =============
 300 */
 301 int Undo_BrushInUndo(undo_t *undo, brush_t *brush)
 302 {
 303 /*      brush_t *b;
 304
 305         for (b = undo->brushlist.next; b != &undo->brushlist; b = b->next)
 306         {
 307     // Arnout: NOTE - can't do a pointer compare as the brushes get cloned into the undo brushlist, and not just referenced from it
 308     // For entities we have a unique ID, for brushes we have numberID - but brush full clone increases that anyway so it's useless right now.
 309                 if (b == brush) return true;
 310         }*/
 311   // Arnout: function is pointless right now, see above explanation
 312         return false;
 313 }
 314
 315 /*
 316 =============
 317 Undo_EntityInUndo
 318 =============
 319 */
 320 int Undo_EntityInUndo(undo_t *undo, entity_t *ent)
 321 {
 322         entity_t *e;
 323
 324         for (e = undo->entitylist.next; e != &undo->entitylist; e = e->next)
 325         {
 326     // Arnout: NOTE - can't do a pointer compare as the entities get cloned into the undo entitylist, and not just referenced from it
 327                 //if (e == ent) return true;
 328     if( e->entityId == ent->entityId ) return true;
 329         }
 330         return false;
 331 }
 332
 333 /*
 334 =============
 335 Undo_Start
 336 =============
 337 */
 338 void Undo_Start(char *operation)
 339 {
 340         // spog - disable undo if undo levels = 0
 341         if (g_PrefsDlg.m_nUndoLevels == 0)
 342         {
 343 #ifdef DBG_UNDO
 344                 Sys_Printf("Undo_Start: undo is disabled.\n");
 345 #endif
 346                 return;
 347         }
 348
 349         Undo_ClearRedo();
 350         Undo_GeneralStart(operation);
 351 }
 352
 353 /*
 354 =============
 355 Undo_AddBrush
 356 =============
 357 */
 358 void Undo_AddBrush(brush_t *pBrush)
 359 {
 360         // spog - disable undo if undo levels = 0
 361         if (g_PrefsDlg.m_nUndoLevels == 0)
 362         {
 363 #ifdef DBG_UNDO
 364                 Sys_Printf("Undo_AddBrush: undo is disabled.\n");
 365 #endif
 366                 return;
 367         }
 368
 369         if (!g_lastundo)
 370         {
 371                 Sys_Printf("Undo_AddBrushList: no last undo.\n");
 372                 return;
 373         }
 374         if (g_lastundo->entitylist.next != &g_lastundo->entitylist)
 375         {
 376                 Sys_Printf("Undo_AddBrushList: WARNING adding brushes after entity.\n");
 377         }
 378         //if the brush is already in the undo
 379         if (Undo_BrushInUndo(g_lastundo, pBrush))
 380                 return;
 381         //clone the brush
 382         brush_t* pClone = Brush_FullClone(pBrush);
 383         //save the ID of the owner entity
 384         pClone->ownerId = pBrush->owner->entityId;
 385         //save the old undo ID for previous undos
 386         pClone->undoId = pBrush->undoId;
 387         Brush_AddToList (pClone, &g_lastundo->brushlist);
 388         //
 389         g_undoMemorySize += Brush_MemorySize(pClone);
 390 }
 391
 392 /*
 393 =============
 394 Undo_AddBrushList
 395 TTimo: some brushes are just there for UI, and the information is somewhere else
 396 for patches it's in the patchMesh_t structure, so when we clone the brush we get that information (brush_t::pPatch)
 397 but: models are stored in pBrush->owner->md3Class, and owner epairs and origin parameters are important
 398   so, we detect models and push the entity in the undo session (as well as it's BBox brush)
 399         same for other items like weapons and ammo etc.
 400 =============
 401 */
 402 void Undo_AddBrushList(brush_t *brushlist)
 403 {
 404         // spog - disable undo if undo levels = 0
 405         if (g_PrefsDlg.m_nUndoLevels == 0)
 406         {
 407 #ifdef DBG_UNDO
 408                 Sys_Printf("Undo_AddBrushList: undo is disabled.\n");
 409 #endif
 410                 return;
 411         }
 412
 413         brush_t *pBrush;
 414
 415         if (!g_lastundo)
 416         {
 417                 Sys_Printf("Undo_AddBrushList: no last undo.\n");
 418                 return;
 419         }
 420         if (g_lastundo->entitylist.next != &g_lastundo->entitylist)
 421         {
 422                 Sys_Printf("Undo_AddBrushList: WARNING adding brushes after entity.\n");
 423         }
 424         //copy the brushes to the undo
 425         for (pBrush = brushlist->next ; pBrush != NULL && pBrush != brushlist; pBrush=pBrush->next)
 426         {
 427                 //if the brush is already in the undo
 428                 //++timo FIXME: when does this happen?
 429                 if (Undo_BrushInUndo(g_lastundo, pBrush))
 430                         continue;
 431                 // do we need to store this brush's entity in the undo?
 432                 // if it's a fixed size entity, the brush that reprents it is not really relevant, it's used for selecting and moving around
 433                 // what we want to store for undo is the owner entity, epairs and origin/angle stuff
 434                 //++timo FIXME: if the entity is not fixed size I don't know, so I don't do it yet
 435                 if (pBrush->owner->eclass->fixedsize == 1)
 436                         Undo_AddEntity( pBrush->owner );
 437                 // clone the brush
 438                 brush_t* pClone = Brush_FullClone(pBrush);
 439                 // save the ID of the owner entity
 440                 pClone->ownerId = pBrush->owner->entityId;
 441                 // save the old undo ID from previous undos
 442                 pClone->undoId = pBrush->undoId;
 443                 Brush_AddToList (pClone, &g_lastundo->brushlist);
 444                 // track memory size used by undo
 445                 g_undoMemorySize += Brush_MemorySize(pClone);
 446         }
 447 }
 448
 449 /*
 450 =============
 451 Undo_EndBrush
 452 =============
 453 */
 454 void Undo_EndBrush(brush_t *pBrush)
 455 {
 456         // spog - disable undo if undo levels = 0
 457         if (g_PrefsDlg.m_nUndoLevels == 0)
 458         {
 459 #ifdef DBG_UNDO
 460                 Sys_Printf("Undo_EndBrush: undo is disabled.\n");
 461 #endif
 462                 return;
 463         }
 464
 465
 466         if (!g_lastundo)
 467         {
 468                 //Sys_Printf("Undo_End: no last undo.\n");
 469                 return;
 470         }
 471         if (g_lastundo->done)
 472         {
 473                 //Sys_Printf("Undo_End: last undo already finished.\n");
 474                 return;
 475         }
 476         pBrush->undoId = g_lastundo->id;
 477 }
 478
 479 /*
 480 =============
 481 Undo_EndBrushList
 482 =============
 483 */
 484 void Undo_EndBrushList(brush_t *brushlist)
 485 {
 486         // spog - disable undo if undo levels = 0
 487         if (g_PrefsDlg.m_nUndoLevels == 0)
 488         {
 489 #ifdef DBG_UNDO
 490                 Sys_Printf("Undo_EndBrushList: undo is disabled.\n");
 491 #endif
 492                 return;
 493         }
 494
 495
 496         if (!g_lastundo)
 497         {
 498                 //Sys_Printf("Undo_End: no last undo.\n");
 499                 return;
 500         }
 501         if (g_lastundo->done)
 502         {
 503                 //Sys_Printf("Undo_End: last undo already finished.\n");
 504                 return;
 505         }
 506         for (brush_t* pBrush = brushlist->next; pBrush != NULL && pBrush != brushlist; pBrush=pBrush->next)
 507         {
 508                 pBrush->undoId = g_lastundo->id;
 509         }
 510 }
 511
 512 /*
 513 =============
 514 Undo_AddEntity
 515 =============
 516 */
 517 void Undo_AddEntity(entity_t *entity)
 518 {
 519         // spog - disable undo if undo levels = 0
 520         if (g_PrefsDlg.m_nUndoLevels == 0)
 521         {
 522 #ifdef DBG_UNDO
 523                 Sys_Printf("Undo_AddEntity: undo is disabled.\n");
 524 #endif
 525                 return;
 526         }
 527
 528
 529         entity_t* pClone;
 530
 531         if (!g_lastundo)
 532         {
 533                 Sys_Printf("Undo_AddEntity: no last undo.\n");
 534                 return;
 535         }
 536         //if the entity is already in the undo
 537         if (Undo_EntityInUndo(g_lastundo, entity))
 538                 return;
 539         //clone the entity
 540         pClone = Entity_Clone(entity);
 541         //save the old undo ID for previous undos
 542         pClone->undoId = entity->undoId;
 543         //save the entity ID (we need a full clone)
 544         pClone->entityId = entity->entityId;
 545         //
 546         Entity_AddToList(pClone, &g_lastundo->entitylist);
 547         //
 548         g_undoMemorySize += Entity_MemorySize(pClone);
 549 }
 550
 551 /*
 552 =============
 553 Undo_EndEntity
 554 =============
 555 */
 556 void Undo_EndEntity(entity_t *entity)
 557 {
 558         // spog - disable undo if undo levels = 0
 559         if (g_PrefsDlg.m_nUndoLevels == 0)
 560         {
 561 #ifdef DBG_UNDO
 562                 Sys_Printf("Undo_EndEntity: undo is disabled.\n");
 563 #endif
 564                 return;
 565         }
 566
 567
 568         if (!g_lastundo)
 569         {
 570 #ifdef _DEBUG
 571                 Sys_Printf("Undo_End: no last undo.\n");
 572 #endif
 573                 return;
 574         }
 575         if (g_lastundo->done)
 576         {
 577 #ifdef _DEBUG
 578                 Sys_Printf("Undo_End: last undo already finished.\n");
 579 #endif
 580                 return;
 581         }
 582         if (entity == world_entity)
 583         {
 584                 //Sys_Printf("Undo_AddEntity: undo on world entity.\n");
 585                 //NOTE: we never delete the world entity when undoing an operation
 586                 //              we only transfer the epairs
 587                 return;
 588         }
 589         entity->undoId = g_lastundo->id;
 590 }
 591
 592 /*
 593 =============
 594 Undo_End
 595 =============
 596 */
 597 void Undo_End(void)
 598 {
 599         // spog - disable undo if undo levels = 0
 600         if (g_PrefsDlg.m_nUndoLevels == 0)
 601         {
 602 #ifdef DBG_UNDO
 603                 Sys_Printf("Undo_End: undo is disabled.\n");
 604 #endif
 605                 return;
 606         }
 607
 608
 609         if (!g_lastundo)
 610         {
 611                 //Sys_Printf("Undo_End: no last undo.\n");
 612                 return;
 613         }
 614         if (g_lastundo->done)
 615         {
 616                 //Sys_Printf("Undo_End: last undo already finished.\n");
 617                 return;
 618         }
 619         g_lastundo->done = true;
 620
 621         //undo memory size is bound to a max
 622         while (g_undoMemorySize > g_undoMaxMemorySize)
 623         {
 624                 //always keep one undo
 625                 if (g_undolist == g_lastundo) break;
 626                 Undo_FreeFirstUndo();
 627         }
 628         //
 629         //Sys_Printf("undo size = %d, undo memory = %d\n", g_undoSize, g_undoMemorySize);
 630 }
 631
 632 /*
 633 =============
 634 Undo_Undo
 635 =============
 636 */
 637 void Undo_Undo(boolean bSilent)
 638 {
 639         // spog - disable undo if undo levels = 0
 640         if (g_PrefsDlg.m_nUndoLevels == 0)
 641         {
 642                 Sys_Printf("Undo_Undo: undo is disabled.\n");
 643                 return;
 644         }
 645
 646         undo_t *undo, *redo;
 647         brush_t *pBrush, *pNextBrush;
 648         entity_t *pEntity, *pNextEntity, *pUndoEntity;
 649
 650         if (!g_lastundo)
 651         {
 652                 Sys_Printf("Nothing left to undo.\n");
 653                 return;
 654         }
 655         if (!g_lastundo->done)
 656         {
 657                 Sys_Printf("Undo_Undo: WARNING: last undo not yet finished!\n");
 658         }
 659         // get the last undo
 660         undo = g_lastundo;
 661         if (g_lastundo->prev) g_lastundo->prev->next = NULL;
 662         else g_undolist = NULL;
 663         g_lastundo = g_lastundo->prev;
 664
 665         //allocate a new redo
 666         redo = (undo_t *) malloc(sizeof(undo_t));
 667         if (!redo) return;
 668         memset(redo, 0, sizeof(undo_t));
 669         redo->brushlist.next = &redo->brushlist;
 670         redo->brushlist.prev = &redo->brushlist;
 671         redo->entitylist.next = &redo->entitylist;
 672         redo->entitylist.prev = &redo->entitylist;
 673         if (g_lastredo) g_lastredo->next = redo;
 674         else g_redolist = redo;
 675         redo->prev = g_lastredo;
 676         redo->next = NULL;
 677         g_lastredo = redo;
 678         redo->time = Sys_DoubleTime();
 679         redo->id = g_redoId++;
 680         redo->done = true;
 681         redo->operation = undo->operation;
 682
 683         //reset the redo IDs of all brushes using the new ID
 684         for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pBrush->next)
 685         {
 686                 if (pBrush->redoId == redo->id)
 687                 {
 688                         pBrush->redoId = 0;
 689                 }
 690         }
 691         for (pBrush = selected_brushes.next; pBrush != NULL && pBrush != &selected_brushes; pBrush = pBrush->next)
 692         {
 693                 if (pBrush->redoId == redo->id)
 694                 {
 695                         pBrush->redoId = 0;
 696                 }
 697         }
 698         //reset the redo IDs of all entities using thew new ID
 699         for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next)
 700         {
 701                 if (pEntity->redoId == redo->id)
 702                 {
 703                         pEntity->redoId = 0;
 704                 }
 705         }
 706
 707         // deselect current sutff
 708         Select_Deselect();
 709         // move "created" brushes to the redo
 710         for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush=pNextBrush)
 711         {
 712                 pNextBrush = pBrush->next;
 713                 if (pBrush->undoId == undo->id)
 714                 {
 715                         //Brush_Free(pBrush);
 716                         //move the brush to the redo
 717                         Brush_RemoveFromList(pBrush);
 718                         Brush_AddToList(pBrush, &redo->brushlist);
 719                         //make sure the ID of the owner is stored
 720                         pBrush->ownerId = pBrush->owner->entityId;
 721                         //unlink the brush from the owner entity
 722                         Entity_UnlinkBrush(pBrush);
 723                 }
 724         }
 725         // move "created" entities to the redo
 726         for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pNextEntity)
 727         {
 728                 pNextEntity = pEntity->next;
 729                 if (pEntity->undoId == undo->id)
 730                 {
 731                         // check if this entity is in the undo
 732                         for (pUndoEntity = undo->entitylist.next; pUndoEntity != NULL && pUndoEntity != &undo->entitylist; pUndoEntity = pUndoEntity->next)
 733                         {
 734                                 // move brushes to the undo entity
 735                                 if (pUndoEntity->entityId == pEntity->entityId)
 736                                 {
 737                                         pUndoEntity->brushes.next = pEntity->brushes.next;
 738                                         pUndoEntity->brushes.prev = pEntity->brushes.prev;
 739                                         pEntity->brushes.next = &pEntity->brushes;
 740                                         pEntity->brushes.prev = &pEntity->brushes;
 741                                 }
 742                         }
 743                         //
 744                         //Entity_Free(pEntity);
 745                         //move the entity to the redo
 746                         Entity_RemoveFromList(pEntity);
 747                         Entity_AddToList(pEntity, &redo->entitylist);
 748                 }
 749         }
 750         // add the undo entities back into the entity list
 751         for (pEntity = undo->entitylist.next; pEntity != NULL && pEntity != &undo->entitylist; pEntity = undo->entitylist.next)
 752         {
 753                 g_undoMemorySize -= Entity_MemorySize(pEntity);
 754                 //if this is the world entity
 755                 if (pEntity->entityId == world_entity->entityId)
 756                 {
 757                         epair_t* tmp = world_entity->epairs;
 758                         world_entity->epairs = pEntity->epairs;
 759       pEntity->epairs = tmp;
 760                         Entity_Free(pEntity);
 761                 }
 762                 else
 763                 {
 764                         Entity_RemoveFromList(pEntity);
 765                         Entity_AddToList(pEntity, &entities);
 766                         pEntity->redoId = redo->id;
 767                 }
 768         }
 769         // add the undo brushes back into the selected brushes
 770         for (pBrush = undo->brushlist.next; pBrush != NULL && pBrush != &undo->brushlist; pBrush = undo->brushlist.next)
 771         {
 772                 //Sys_Printf("Owner ID: %i\n",pBrush->ownerId);
 773                 g_undoMemorySize -= Brush_MemorySize(pBrush);
 774                 Brush_RemoveFromList(pBrush);
 775         Brush_AddToList(pBrush, &active_brushes);
 776                 for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next) // fixes broken undo on entities
 777                 {
 778                         //Sys_Printf("Entity ID: %i\n",pEntity->entityId);
 779                         if (pEntity->entityId == pBrush->ownerId)
 780                         {
 781                                 Entity_LinkBrush(pEntity, pBrush);
 782                                 break;
 783                         }
 784                 }
 785                 //if the brush is not linked then it should be linked into the world entity
 786                 //++timo FIXME: maybe not, maybe we've lost this entity's owner!
 787                 if (pEntity == NULL || pEntity == &entities)
 788                 {
 789                         Entity_LinkBrush(world_entity, pBrush);
 790                 }
 791                 //build the brush
 792                 //Brush_Build(pBrush);
 793                 Select_Brush(pBrush);
 794                 pBrush->redoId = redo->id;
 795     }
 796         if (!bSilent)
 797                 Sys_Printf("%s undone.\n", undo->operation);
 798         // free the undo
 799         g_undoMemorySize -= sizeof(undo_t);
 800         free(undo);
 801         g_undoSize--;
 802         g_undoId--;
 803         if (g_undoId <= 0) g_undoId = 2 * g_undoMaxSize;
 804         //
 805     g_bScreenUpdates = true;
 806     UpdateSurfaceDialog();
 807     Sys_UpdateWindows(W_ALL);
 808 }
 809
 810 /*
 811 =============
 812 Undo_Redo
 813 =============
 814 */
 815 void Undo_Redo(void)
 816 {
 817         // spog - disable undo if undo levels = 0
 818         if (g_PrefsDlg.m_nUndoLevels == 0)
 819         {
 820                 Sys_Printf("Undo_Redo: undo is disabled.\n");
 821                 return;
 822         }
 823
 824         undo_t *redo;
 825         brush_t *pBrush, *pNextBrush;
 826         entity_t *pEntity, *pNextEntity, *pRedoEntity;
 827
 828         if (!g_lastredo)
 829         {
 830                 Sys_Printf("Nothing left to redo.\n");
 831                 return;
 832         }
 833         if (g_lastundo)
 834         {
 835                 if (!g_lastundo->done)
 836                 {
 837                         Sys_Printf("WARNING: last undo not finished.\n");
 838                 }
 839         }
 840         // get the last redo
 841         redo = g_lastredo;
 842         if (g_lastredo->prev) g_lastredo->prev->next = NULL;
 843         else g_redolist = NULL;
 844         g_lastredo = g_lastredo->prev;
 845         //
 846         Undo_GeneralStart(redo->operation);
 847         // remove current selection
 848         Select_Deselect();
 849         // move "created" brushes back to the last undo
 850         for (pBrush = active_brushes.next; pBrush != NULL && pBrush != &active_brushes; pBrush = pNextBrush)
 851         {
 852                 pNextBrush = pBrush->next;
 853                 if (pBrush->redoId == redo->id)
 854                 {
 855                         //move the brush to the undo
 856                         Brush_RemoveFromList(pBrush);
 857                         Brush_AddToList(pBrush, &g_lastundo->brushlist);
 858                         g_undoMemorySize += Brush_MemorySize(pBrush);
 859                         pBrush->ownerId = pBrush->owner->entityId;
 860                         Entity_UnlinkBrush(pBrush);
 861                 }
 862         }
 863         // move "created" entities back to the last undo
 864         for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pNextEntity)
 865         {
 866                 pNextEntity = pEntity->next;
 867                 if (pEntity->redoId == redo->id)
 868                 {
 869                         // check if this entity is in the redo
 870                         for (pRedoEntity = redo->entitylist.next; pRedoEntity != NULL && pRedoEntity != &redo->entitylist; pRedoEntity = pRedoEntity->next)
 871                         {
 872                                 // move brushes to the redo entity
 873                                 if (pRedoEntity->entityId == pEntity->entityId)
 874                                 {
 875                                         pRedoEntity->brushes.next = pEntity->brushes.next;
 876                                         pRedoEntity->brushes.prev = pEntity->brushes.prev;
 877                                         pEntity->brushes.next = &pEntity->brushes;
 878                                         pEntity->brushes.prev = &pEntity->brushes;
 879                                 }
 880                         }
 881                         //
 882                         //Entity_Free(pEntity);
 883                         //move the entity to the redo
 884                         Entity_RemoveFromList(pEntity);
 885                         Entity_AddToList(pEntity, &g_lastundo->entitylist);
 886                         g_undoMemorySize += Entity_MemorySize(pEntity);
 887                 }
 888         }
 889         // add the undo entities back into the entity list
 890         for (pEntity = redo->entitylist.next; pEntity != NULL && pEntity != &redo->entitylist; pEntity = redo->entitylist.next)
 891         {
 892                 //if this is the world entity
 893                 if (pEntity->entityId == world_entity->entityId)
 894                 {
 895       epair_t* tmp = world_entity->epairs;
 896                         world_entity->epairs = pEntity->epairs;
 897       pEntity->epairs = tmp;
 898                         Entity_Free(pEntity);
 899                 }
 900                 else
 901                 {
 902                         Entity_RemoveFromList(pEntity);
 903                         Entity_AddToList(pEntity, &entities);
 904                 }
 905         }
 906         // add the redo brushes back into the selected brushes
 907         for (pBrush = redo->brushlist.next; pBrush != NULL && pBrush != &redo->brushlist; pBrush = redo->brushlist.next)
 908         {
 909                 Brush_RemoveFromList(pBrush);
 910     Brush_AddToList(pBrush, &active_brushes);
 911                 for (pEntity = entities.next; pEntity != NULL && pEntity != &entities; pEntity = pEntity->next) // fixes broken undo on entities
 912                 {
 913                         if (pEntity->entityId == pBrush->ownerId)
 914                         {
 915                                 Entity_LinkBrush(pEntity, pBrush);
 916                                 break;
 917                         }
 918                 }
 919                 //if the brush is not linked then it should be linked into the world entity
 920                 if (pEntity == NULL || pEntity == &entities)
 921                 {
 922                         Entity_LinkBrush(world_entity, pBrush);
 923                 }
 924                 //build the brush
 925                 //Brush_Build(pBrush);
 926                 Select_Brush(pBrush);
 927     }
 928         //
 929         Undo_End();
 930         //
 931         Sys_Printf("%s redone.\n", redo->operation);
 932         //
 933         g_redoId--;
 934         // free the undo
 935         free(redo);
 936         //
 937     g_bScreenUpdates = true;
 938     UpdateSurfaceDialog();
 939     Sys_UpdateWindows(W_ALL);
 940 }
 941
 942 /*
 943 =============
 944 Undo_RedoAvailable
 945 =============
 946 */
 947 int Undo_RedoAvailable(void)
 948 {
 949         if (g_lastredo) return true;
 950         return false;
 951 }
 952
 953 int Undo_GetUndoId(void)
 954 {
 955         if (g_lastundo)
 956                 return g_lastundo->id;
 957         return 0;
 958 }
 959
 960 /*
 961 =============
 962 Undo_UndoAvailable
 963 =============
 964 */
 965 int Undo_UndoAvailable(void)
 966 {
 967         if (g_lastundo)
 968         {
 969                 if (g_lastundo->done)
 970                         return true;
 971         }
 972         return false;
 973 }