src/undo.c

   1 /* $Id$ */
   2
   3 /*
   4  *                            COPYRIGHT
   5  *
   6  *  PCB, interactive printed circuit board design
   7  *  Copyright (C) 1994,1995,1996 Thomas Nau
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  *  Contact addresses for paper mail and Email:
  24  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  25  *  Thomas.Nau@rz.uni-ulm.de
  26  *
  27  */
  28
  29 /* functions used to undo operations
  30  *
  31  * Description:
  32  * There are two lists which hold
  33  *   - information about a command
  34  *   - data of removed objects
  35  * Both lists are organized as first-in-last-out which means that the undo
  36  * list can always use the last entry of the remove list.
  37  * A serial number is incremented whenever an operation is completed.
  38  * An operation itself may consist of several basic instructions.
  39  * E.g.: removing all selected objects is one operation with exactly one
  40  * serial number even if the remove function is called several times.
  41  *
  42  * a lock flag ensures that no infinite loops occur
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #include <assert.h>
  50 #include <memory.h>
  51 #include "global.h"
  52
  53 #include "buffer.h"
  54 #include "change.h"
  55 #include "create.h"
  56 #include "data.h"
  57 #include "draw.h"
  58 #include "error.h"
  59 #include "insert.h"
  60 #include "misc.h"
  61 #include "mirror.h"
  62 #include "move.h"
  63 #include "mymem.h"
  64 #include "polygon.h"
  65 #include "remove.h"
  66 #include "rotate.h"
  67 #include "rtree.h"
  68 #include "search.h"
  69 #include "set.h"
  70 #include "undo.h"
  71 #include "strflags.h"
  72
  73 #ifdef HAVE_LIBDMALLOC
  74 #include <dmalloc.h>
  75 #endif
  76
  77 RCSID ("$Id$");
  78
  79 /* ---------------------------------------------------------------------------
  80  * some local data types
  81  */
  82 typedef struct                  /* information about a change command */
  83 {
  84   char *Name;
  85 }
  86 ChangeNameType, *ChangeNameTypePtr;
  87
  88 typedef struct                  /* information about a move command */
  89 {
  90   LocationType DX,              /* movement vector */
  91     DY;
  92 }
  93 MoveType, *MoveTypePtr;
  94
  95 typedef struct                  /* information about removed polygon points */
  96 {
  97   LocationType X, Y;            /* data */
  98   int ID;
  99   Cardinal Index;               /* index in a polygons array of points */
 100   bool last_in_contour;         /* Whether the point was the last in its contour */
 101 }
 102 RemovedPointType, *RemovedPointTypePtr;
 103
 104 typedef struct                  /* information about rotation */
 105 {
 106   LocationType CenterX,         /* center of rotation */
 107     CenterY;
 108   BYTE Steps;                   /* number of steps */
 109 }
 110 RotateType, *RotateTypePtr;
 111
 112 typedef struct                  /* information about moves between layers */
 113 {
 114   Cardinal OriginalLayer;       /* the index of the original layer */
 115 }
 116 MoveToLayerType, *MoveToLayerTypePtr;
 117
 118 typedef struct                  /* information about layer changes */
 119 {
 120   int old_index;
 121   int new_index;
 122 }
 123 LayerChangeType, *LayerChangeTypePtr;
 124
 125 typedef struct                  /* information about poly clear/restore */
 126 {
 127   bool Clear;           /* true was clear, false was restore */
 128   LayerTypePtr Layer;
 129 }
 130 ClearPolyType, *ClearPolyTypePtr;
 131
 132 typedef struct                  /* information about netlist lib changes */
 133 {
 134   LibraryTypePtr old;
 135   LibraryTypePtr lib;
 136 }
 137 NetlistChangeType, *NetlistChangeTypePtr;
 138
 139 typedef struct                  /* holds information about an operation */
 140 {
 141   int Serial,                   /* serial number of operation */
 142     Type,                       /* type of operation */
 143     Kind,                       /* type of object with given ID */
 144     ID;                         /* object ID */
 145   union                         /* some additional information */
 146   {
 147     ChangeNameType ChangeName;
 148     MoveType Move;
 149     RemovedPointType RemovedPoint;
 150     RotateType Rotate;
 151     MoveToLayerType MoveToLayer;
 152     FlagType Flags;
 153     BDimension Size;
 154     LayerChangeType LayerChange;
 155     ClearPolyType ClearPoly;
 156     NetlistChangeType NetlistChange;
 157     long int CopyID;
 158   }
 159   Data;
 160 }
 161 UndoListType, *UndoListTypePtr;
 162
 163 /* ---------------------------------------------------------------------------
 164  * some local variables
 165  */
 166 static DataTypePtr RemoveList = NULL;   /* list of removed objects */
 167 static UndoListTypePtr UndoList = NULL; /* list of operations */
 168 static int Serial = 1,          /* serial number */
 169   SavedSerial;
 170 static size_t UndoN, RedoN,     /* number of entries */
 171   UndoMax;
 172 static bool Locked = false;     /* do not add entries if */
 173 static bool andDraw = true;
 174                                                                                 /* flag is set; prevents from */
 175                                                                                 /* infinite loops */
 176
 177 /* ---------------------------------------------------------------------------
 178  * some local prototypes
 179  */
 180 static UndoListTypePtr GetUndoSlot (int, int, int);
 181 static void DrawRecoveredObject (int, void *, void *, void *);
 182 static bool UndoRotate (UndoListTypePtr);
 183 static bool UndoChangeName (UndoListTypePtr);
 184 static bool UndoCopyOrCreate (UndoListTypePtr);
 185 static bool UndoMove (UndoListTypePtr);
 186 static bool UndoRemove (UndoListTypePtr);
 187 static bool UndoRemovePoint (UndoListTypePtr);
 188 static bool UndoInsertPoint (UndoListTypePtr);
 189 static bool UndoRemoveContour (UndoListTypePtr);
 190 static bool UndoInsertContour (UndoListTypePtr);
 191 static bool UndoMoveToLayer (UndoListTypePtr);
 192 static bool UndoFlag (UndoListTypePtr);
 193 static bool UndoMirror (UndoListTypePtr);
 194 static bool UndoChangeSize (UndoListTypePtr);
 195 static bool UndoChange2ndSize (UndoListTypePtr);
 196 static bool UndoChangeAngles (UndoListTypePtr);
 197 static bool UndoChangeClearSize (UndoListTypePtr);
 198 static bool UndoChangeMaskSize (UndoListTypePtr);
 199 static bool UndoClearPoly (UndoListTypePtr);
 200 static int PerformUndo (UndoListTypePtr);
 201
 202 /* ---------------------------------------------------------------------------
 203  * adds a command plus some data to the undo list
 204  */
 205 static UndoListTypePtr
 206 GetUndoSlot (int CommandType, int ID, int Kind)
 207 {
 208   UndoListTypePtr ptr;
 209   void *ptr1, *ptr2, *ptr3;
 210   int type;
 211   static size_t limit = UNDO_WARNING_SIZE;
 212
 213 #ifdef DEBUG_ID
 214   if (SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, ID, Kind) == NO_TYPE)
 215     Message ("hace: ID (%d) and Type (%x) mismatch in AddObject...\n", ID,
 216              Kind);
 217 #endif
 218
 219   /* allocate memory */
 220   if (UndoN >= UndoMax)
 221     {
 222       size_t size;
 223
 224       UndoMax += STEP_UNDOLIST;
 225       size = UndoMax * sizeof (UndoListType);
 226       UndoList = (UndoListTypePtr) realloc (UndoList, size);
 227       memset (&UndoList[UndoN], 0, STEP_REMOVELIST * sizeof (UndoListType));
 228
 229       /* ask user to flush the table because of it's size */
 230       if (size > limit)
 231         {
 232           limit = (size / UNDO_WARNING_SIZE + 1) * UNDO_WARNING_SIZE;
 233           Message (_("Size of 'undo-list' exceeds %li kb\n"),
 234                    (long) (size >> 10));
 235         }
 236     }
 237
 238   /* free structures from the pruned redo list */
 239
 240   for (ptr = &UndoList[UndoN]; RedoN; ptr++, RedoN--)
 241     switch (ptr->Type)
 242       {
 243       case UNDO_CHANGENAME:
 244         free (ptr->Data.ChangeName.Name);
 245         break;
 246       case UNDO_REMOVE:
 247         type =
 248           SearchObjectByID (RemoveList, &ptr1, &ptr2, &ptr3, ptr->ID,
 249                             ptr->Kind);
 250         if (type != NO_TYPE)
 251           {
 252             DestroyObject (RemoveList, type, ptr1, ptr2, ptr3);
 253           }
 254         break;
 255       default:
 256         break;
 257       }
 258
 259   /* copy typefield and serial number to the list */
 260   ptr = &UndoList[UndoN++];
 261   ptr->Type = CommandType;
 262   ptr->Kind = Kind;
 263   ptr->ID = ID;
 264   ptr->Serial = Serial;
 265   return (ptr);
 266 }
 267
 268 /* ---------------------------------------------------------------------------
 269  * redraws the recovered object
 270  */
 271 static void
 272 DrawRecoveredObject (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
 273 {
 274   if (Type & (LINE_TYPE | TEXT_TYPE | POLYGON_TYPE | ARC_TYPE))
 275     {
 276       LayerTypePtr layer;
 277
 278       layer = LAYER_PTR (GetLayerNumber (RemoveList, (LayerTypePtr) Ptr1));
 279       DrawObject (Type, (void *) layer, Ptr2, 0);
 280     }
 281   else
 282     DrawObject (Type, Ptr1, Ptr2, 0);
 283 }
 284
 285 /* ---------------------------------------------------------------------------
 286  * recovers an object from a 'rotate' operation
 287  * returns true if anything has been recovered
 288  */
 289 static bool
 290 UndoRotate (UndoListTypePtr Entry)
 291 {
 292   void *ptr1, *ptr2, *ptr3;
 293   int type;
 294
 295   /* lookup entry by it's ID */
 296   type =
 297     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 298   if (type != NO_TYPE)
 299     {
 300       if (TEST_FLAG (LOCKFLAG, (ArcTypePtr) ptr2))
 301         return (false);
 302       RotateObject (type, ptr1, ptr2, ptr3,
 303                     Entry->Data.Rotate.CenterX, Entry->Data.Rotate.CenterY,
 304                     (4 - Entry->Data.Rotate.Steps) & 0x03);
 305       Entry->Data.Rotate.Steps = (4 - Entry->Data.Rotate.Steps) & 0x03;
 306       return (true);
 307     }
 308   return (false);
 309 }
 310
 311 /* ---------------------------------------------------------------------------
 312  * recovers an object from a clear/restore poly operation
 313  * returns true if anything has been recovered
 314  */
 315 static bool
 316 UndoClearPoly (UndoListTypePtr Entry)
 317 {
 318   void *ptr1, *ptr2, *ptr3;
 319   int type;
 320
 321   type =
 322     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 323   if (type != NO_TYPE)
 324     {
 325       if (Entry->Data.ClearPoly.Clear)
 326         RestoreToPolygon (PCB->Data, type, Entry->Data.ClearPoly.Layer, ptr3);
 327       else
 328         ClearFromPolygon (PCB->Data, type, Entry->Data.ClearPoly.Layer, ptr3);
 329       Entry->Data.ClearPoly.Clear = !Entry->Data.ClearPoly.Clear;
 330       return true;
 331     }
 332   return false;
 333 }
 334
 335 /* ---------------------------------------------------------------------------
 336  * recovers an object from a 'change name' operation
 337  * returns true if anything has been recovered
 338  */
 339 static bool
 340 UndoChangeName (UndoListTypePtr Entry)
 341 {
 342   void *ptr1, *ptr2, *ptr3;
 343   int type;
 344
 345   /* lookup entry by it's ID */
 346   type =
 347     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 348   if (type != NO_TYPE)
 349     {
 350       if (TEST_FLAG (LOCKFLAG, (TextTypePtr) ptr3))
 351         return (false);
 352       Entry->Data.ChangeName.Name =
 353         (ChangeObjectName (type, ptr1, ptr2, ptr3,
 354                            Entry->Data.ChangeName.Name));
 355       return (true);
 356     }
 357   return (false);
 358 }
 359
 360 /* ---------------------------------------------------------------------------
 361  * recovers an object from a 2ndSize change operation
 362  */
 363 static bool
 364 UndoChange2ndSize (UndoListTypePtr Entry)
 365 {
 366   void *ptr1, *ptr2, *ptr3;
 367   int type;
 368   BDimension swap;
 369
 370   /* lookup entry by ID */
 371   type =
 372     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 373   if (type != NO_TYPE)
 374     {
 375       if (TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
 376         return (false);
 377       swap = ((PinTypePtr) ptr2)->DrillingHole;
 378       if (andDraw)
 379         EraseObject (type, ptr1, ptr2);
 380       ((PinTypePtr) ptr2)->DrillingHole = Entry->Data.Size;
 381       Entry->Data.Size = swap;
 382       DrawObject (type, ptr1, ptr2, 0);
 383       return (true);
 384     }
 385   return (false);
 386 }
 387
 388 /* ---------------------------------------------------------------------------
 389  * recovers an object from a ChangeAngles change operation
 390  */
 391 static bool
 392 UndoChangeAngles (UndoListTypePtr Entry)
 393 {
 394   void *ptr1, *ptr2, *ptr3;
 395   int type;
 396   long int old_sa, old_da;
 397
 398   /* lookup entry by ID */
 399   type =
 400     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 401   if (type == ARC_TYPE)
 402     {
 403       LayerTypePtr Layer = (LayerTypePtr) ptr1;
 404       ArcTypePtr a = (ArcTypePtr) ptr2;
 405       if (TEST_FLAG (LOCKFLAG, a))
 406         return (false);
 407       r_delete_entry (Layer->arc_tree, (BoxTypePtr) a);
 408       old_sa = a->StartAngle;
 409       old_da = a->Delta;
 410       if (andDraw)
 411         EraseObject (type, Layer, a);
 412       a->StartAngle = Entry->Data.Move.DX;
 413       a->Delta = Entry->Data.Move.DY;
 414       SetArcBoundingBox (a);
 415       r_insert_entry (Layer->arc_tree, (BoxTypePtr) a, 0);
 416       Entry->Data.Move.DX = old_sa;
 417       Entry->Data.Move.DY = old_da;;
 418       DrawObject (type, ptr1, a, 0);
 419       return (true);
 420     }
 421   return (false);
 422 }
 423
 424 /* ---------------------------------------------------------------------------
 425  * recovers an object from a clearance size change operation
 426  */
 427 static bool
 428 UndoChangeClearSize (UndoListTypePtr Entry)
 429 {
 430   void *ptr1, *ptr2, *ptr3;
 431   int type;
 432   BDimension swap;
 433
 434   /* lookup entry by ID */
 435   type =
 436     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 437   if (type != NO_TYPE)
 438     {
 439       if (TEST_FLAG (LOCKFLAG, (LineTypePtr) ptr2))
 440         return (false);
 441       swap = ((PinTypePtr) ptr2)->Clearance;
 442       RestoreToPolygon (PCB->Data, type, ptr1, ptr2);
 443       if (andDraw)
 444         EraseObject (type, ptr1, ptr2);
 445       ((PinTypePtr) ptr2)->Clearance = Entry->Data.Size;
 446       ClearFromPolygon (PCB->Data, type, ptr1, ptr2);
 447       Entry->Data.Size = swap;
 448       if (andDraw)
 449         DrawObject (type, ptr1, ptr2, 0);
 450       return (true);
 451     }
 452   return (false);
 453 }
 454
 455 /* ---------------------------------------------------------------------------
 456  * recovers an object from a mask size change operation
 457  */
 458 static bool
 459 UndoChangeMaskSize (UndoListTypePtr Entry)
 460 {
 461   void *ptr1, *ptr2, *ptr3;
 462   int type;
 463   BDimension swap;
 464
 465   /* lookup entry by ID */
 466   type =
 467     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 468   if (type & (VIA_TYPE | PIN_TYPE | PAD_TYPE))
 469     {
 470       if (TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
 471         return (false);
 472       swap =
 473         (type ==
 474          PAD_TYPE ? ((PadTypePtr) ptr2)->Mask : ((PinTypePtr) ptr2)->Mask);
 475       if (andDraw)
 476         EraseObject (type, ptr1, ptr2);
 477       if (type == PAD_TYPE)
 478         ((PadTypePtr) ptr2)->Mask = Entry->Data.Size;
 479       else
 480         ((PinTypePtr) ptr2)->Mask = Entry->Data.Size;
 481       Entry->Data.Size = swap;
 482       if (andDraw)
 483         DrawObject (type, ptr1, ptr2, 0);
 484       return (true);
 485     }
 486   return (false);
 487 }
 488
 489
 490 /* ---------------------------------------------------------------------------
 491  * recovers an object from a Size change operation
 492  */
 493 static bool
 494 UndoChangeSize (UndoListTypePtr Entry)
 495 {
 496   void *ptr1, *ptr2, *ptr3;
 497   int type;
 498   BDimension swap;
 499
 500   /* lookup entry by ID */
 501   type =
 502     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 503   if (type != NO_TYPE)
 504     {
 505       if (TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
 506         return (false);
 507       /* Wow! can any object be treated as a pin type for size change?? */
 508       /* pins, vias, lines, and arcs can. Text can't but it has it's own mechanism */
 509       swap = ((PinTypePtr) ptr2)->Thickness;
 510       RestoreToPolygon (PCB->Data, type, ptr1, ptr2);
 511       if (andDraw)
 512         EraseObject (type, ptr1, ptr2);
 513       ((PinTypePtr) ptr2)->Thickness = Entry->Data.Size;
 514       Entry->Data.Size = swap;
 515       ClearFromPolygon (PCB->Data, type, ptr1, ptr2);
 516       if (andDraw)
 517         DrawObject (type, ptr1, ptr2, 0);
 518       return (true);
 519     }
 520   return (false);
 521 }
 522
 523 /* ---------------------------------------------------------------------------
 524  * recovers an object from a FLAG change operation
 525  */
 526 static bool
 527 UndoFlag (UndoListTypePtr Entry)
 528 {
 529   void *ptr1, *ptr2, *ptr3;
 530   int type;
 531   FlagType swap;
 532   int must_redraw;
 533
 534   /* lookup entry by ID */
 535   type =
 536     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 537   if (type != NO_TYPE)
 538     {
 539       FlagType f1, f2;
 540       PinTypePtr pin = (PinTypePtr) ptr2;
 541
 542       if (TEST_FLAG (LOCKFLAG, pin))
 543         return (false);
 544
 545       swap = pin->Flags;
 546
 547       must_redraw = 0;
 548       f1 = MaskFlags (pin->Flags, ~DRAW_FLAGS);
 549       f2 = MaskFlags (Entry->Data.Flags, ~DRAW_FLAGS);
 550
 551       if (!FLAGS_EQUAL (f1, f2))
 552         must_redraw = 1;
 553
 554       if (andDraw && must_redraw)
 555         EraseObject (type, ptr1, ptr2);
 556
 557       pin->Flags = Entry->Data.Flags;
 558
 559       Entry->Data.Flags = swap;
 560
 561       if (andDraw && must_redraw)
 562         DrawObject (type, ptr1, ptr2, 0);
 563       return (true);
 564     }
 565   Message ("hace Internal error: Can't find ID %d type %08x\n", Entry->ID,
 566            Entry->Kind);
 567   Message ("for UndoFlag Operation. Previous flags: %s\n",
 568            flags_to_string (Entry->Data.Flags, 0));
 569   return (false);
 570 }
 571
 572 /* ---------------------------------------------------------------------------
 573  * recovers an object from a mirror operation
 574  * returns true if anything has been recovered
 575  */
 576 static bool
 577 UndoMirror (UndoListTypePtr Entry)
 578 {
 579   void *ptr1, *ptr2, *ptr3;
 580   int type;
 581
 582   /* lookup entry by ID */
 583   type =
 584     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 585   if (type == ELEMENT_TYPE)
 586     {
 587       ElementTypePtr element = (ElementTypePtr) ptr3;
 588       if (TEST_FLAG (LOCKFLAG, element))
 589         return (false);
 590       if (andDraw)
 591         EraseElement (element);
 592       MirrorElementCoordinates (PCB->Data, element, Entry->Data.Move.DY);
 593       if (andDraw)
 594         DrawElement (element, 0);
 595       return (true);
 596     }
 597   Message ("hace Internal error: UndoMirror on object type %d\n", type);
 598   return (false);
 599 }
 600
 601 /* ---------------------------------------------------------------------------
 602  * recovers an object from a 'copy' or 'create' operation
 603  * returns true if anything has been recovered
 604  */
 605 static bool
 606 UndoCopyOrCreate (UndoListTypePtr Entry)
 607 {
 608   void *ptr1, *ptr2, *ptr3;
 609   int type;
 610
 611   /* lookup entry by it's ID */
 612   type =
 613     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 614   if (type != NO_TYPE)
 615     {
 616       if (TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
 617         return (false);
 618       if (!RemoveList)
 619         RemoveList = CreateNewBuffer ();
 620       if (andDraw)
 621         EraseObject (type, ptr1, ptr2);
 622       /* in order to make this re-doable we move it to the RemoveList */
 623       MoveObjectToBuffer (RemoveList, PCB->Data, type, ptr1, ptr2, ptr3);
 624       Entry->Type = UNDO_REMOVE;
 625       return (true);
 626     }
 627   return (false);
 628 }
 629
 630 /* ---------------------------------------------------------------------------
 631  * recovers an object from a 'move' operation
 632  * returns true if anything has been recovered
 633  */
 634 static bool
 635 UndoMove (UndoListTypePtr Entry)
 636 {
 637   void *ptr1, *ptr2, *ptr3;
 638   int type;
 639
 640   /* lookup entry by it's ID */
 641   type =
 642     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 643   if (type != NO_TYPE)
 644     {
 645       if (TEST_FLAG (LOCKFLAG, (LineTypePtr) ptr2))
 646         return (false);
 647       MoveObject (type, ptr1, ptr2, ptr3,
 648                   -Entry->Data.Move.DX, -Entry->Data.Move.DY);
 649       Entry->Data.Move.DX *= -1;
 650       Entry->Data.Move.DY *= -1;
 651       return (true);
 652     }
 653   return (false);
 654 }
 655
 656 /* ----------------------------------------------------------------------
 657  * recovers an object from a 'remove' operation
 658  * returns true if anything has been recovered
 659  */
 660 static bool
 661 UndoRemove (UndoListTypePtr Entry)
 662 {
 663   void *ptr1, *ptr2, *ptr3;
 664   int type;
 665
 666   /* lookup entry by it's ID */
 667   type =
 668     SearchObjectByID (RemoveList, &ptr1, &ptr2, &ptr3, Entry->ID,
 669                       Entry->Kind);
 670   if (type != NO_TYPE)
 671     {
 672       if (andDraw)
 673         DrawRecoveredObject (type, ptr1, ptr2, ptr3);
 674       MoveObjectToBuffer (PCB->Data, RemoveList, type, ptr1, ptr2, ptr3);
 675       Entry->Type = UNDO_CREATE;
 676       return (true);
 677     }
 678   return (false);
 679 }
 680
 681 /* ----------------------------------------------------------------------
 682  * recovers an object from a 'move to another layer' operation
 683  * returns true if anything has been recovered
 684  */
 685 static bool
 686 UndoMoveToLayer (UndoListTypePtr Entry)
 687 {
 688   void *ptr1, *ptr2, *ptr3;
 689   int type, swap;
 690
 691   /* lookup entry by it's ID */
 692   type =
 693     SearchObjectByID (PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind);
 694   if (type != NO_TYPE)
 695     {
 696       if (TEST_FLAG (LOCKFLAG, (LineTypePtr) ptr2))
 697         return (false);
 698       swap = GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1);
 699       MoveObjectToLayer (type, ptr1, ptr2, ptr3,
 700                          LAYER_PTR (Entry->Data.
 701                                     MoveToLayer.OriginalLayer), true);
 702       Entry->Data.MoveToLayer.OriginalLayer = swap;
 703       return (true);
 704     }
 705   return (false);
 706 }
 707
 708 /* ---------------------------------------------------------------------------
 709  * recovers a removed polygon point
 710  * returns true on success
 711  */
 712 static bool
 713 UndoRemovePoint (UndoListTypePtr Entry)
 714 {
 715   LayerTypePtr layer;
 716   PolygonTypePtr polygon;
 717   void *ptr3;
 718   int type;
 719
 720   /* lookup entry (polygon not point was saved) by it's ID */
 721   assert (Entry->Kind == POLYGON_TYPE);
 722   type =
 723     SearchObjectByID (PCB->Data, (void *) &layer, (void *) &polygon, &ptr3,
 724                       Entry->ID, Entry->Kind);
 725   switch (type)
 726     {
 727     case POLYGON_TYPE:          /* restore the removed point */
 728       {
 729         if (TEST_FLAG (LOCKFLAG, polygon))
 730           return (false);
 731         /* recover the point */
 732         if (andDraw && layer->On)
 733           ErasePolygon (polygon);
 734         InsertPointIntoObject (POLYGON_TYPE, layer, polygon,
 735                                &Entry->Data.RemovedPoint.Index,
 736                                Entry->Data.RemovedPoint.X,
 737                                Entry->Data.RemovedPoint.Y, true,
 738                                Entry->Data.RemovedPoint.last_in_contour);
 739
 740         polygon->Points[Entry->Data.RemovedPoint.Index].ID =
 741           Entry->Data.RemovedPoint.ID;
 742         if (andDraw && layer->On)
 743           DrawPolygon (layer, polygon, 0);
 744         Entry->Type = UNDO_INSERT_POINT;
 745         Entry->ID = Entry->Data.RemovedPoint.ID;
 746         Entry->Kind = POLYGONPOINT_TYPE;
 747         return (true);
 748       }
 749
 750     default:
 751       return (false);
 752     }
 753 }
 754
 755 /* ---------------------------------------------------------------------------
 756  * recovers an inserted polygon point
 757  * returns true on success
 758  */
 759 static bool
 760 UndoInsertPoint (UndoListTypePtr Entry)
 761 {
 762   LayerTypePtr layer;
 763   PolygonTypePtr polygon;
 764   PointTypePtr pnt;
 765   int type;
 766   Cardinal point_idx;
 767   Cardinal hole;
 768   bool last_in_contour = false;
 769
 770   assert (Entry->Kind == POLYGONPOINT_TYPE);
 771   /* lookup entry by it's ID */
 772   type =
 773     SearchObjectByID (PCB->Data, (void *) &layer, (void *) &polygon,
 774                       (void *) &pnt, Entry->ID, Entry->Kind);
 775   switch (type)
 776     {
 777     case POLYGONPOINT_TYPE:     /* removes an inserted polygon point */
 778       {
 779         if (TEST_FLAG (LOCKFLAG, polygon))
 780           return (false);
 781         if (andDraw && layer->On)
 782           ErasePolygon (polygon);
 783
 784         /* Check whether this point was at the end of its contour.
 785          * If so, we need to flag as such when re-adding the point
 786          * so it goes back in the correct place
 787          */
 788         point_idx = polygon_point_idx (polygon, pnt);
 789         for (hole = 0; hole < polygon->HoleIndexN; hole++)
 790           if (point_idx == polygon->HoleIndex[hole] - 1)
 791             last_in_contour = true;
 792         if (point_idx == polygon->PointN - 1)
 793           last_in_contour = true;
 794         Entry->Data.RemovedPoint.last_in_contour = last_in_contour;
 795
 796         Entry->Data.RemovedPoint.X = pnt->X;
 797         Entry->Data.RemovedPoint.Y = pnt->Y;
 798         Entry->Data.RemovedPoint.ID = pnt->ID;
 799         Entry->ID = polygon->ID;
 800         Entry->Kind = POLYGON_TYPE;
 801         Entry->Type = UNDO_REMOVE_POINT;
 802         Entry->Data.RemovedPoint.Index = point_idx;
 803         DestroyObject (PCB->Data, POLYGONPOINT_TYPE, layer, polygon, pnt);
 804         if (andDraw && layer->On)
 805           DrawPolygon (layer, polygon, 0);
 806         return (true);
 807       }
 808
 809     default:
 810       return (false);
 811     }
 812 }
 813
 814 static bool
 815 UndoSwapCopiedObject (UndoListTypePtr Entry)
 816 {
 817   void *ptr1, *ptr2, *ptr3;
 818   void *ptr1b, *ptr2b, *ptr3b;
 819   AnyObjectType *obj, *obj2;
 820   int type;
 821   long int swap_id;
 822
 823   /* lookup entry by it's ID */
 824   type =
 825     SearchObjectByID (RemoveList, &ptr1, &ptr2, &ptr3, Entry->Data.CopyID,
 826                       Entry->Kind);
 827   if (type == NO_TYPE)
 828     return false;
 829
 830   type =
 831     SearchObjectByID (PCB->Data, &ptr1b, &ptr2b, &ptr3b, Entry->ID,
 832                       Entry->Kind);
 833   if (type == NO_TYPE)
 834     return FALSE;
 835
 836   obj = ptr2;
 837   obj2 = ptr2b;
 838
 839   swap_id = obj->ID;
 840   obj->ID = obj2->ID;
 841   obj2->ID = swap_id;
 842
 843   MoveObjectToBuffer (RemoveList, PCB->Data, type, ptr1b, ptr2b, ptr3b);
 844
 845   if (andDraw)
 846     DrawRecoveredObject (Entry->Kind, ptr1, ptr2, ptr3);
 847
 848   obj = MoveObjectToBuffer (PCB->Data, RemoveList, type, ptr1, ptr2, ptr3);
 849   if (Entry->Kind == POLYGON_TYPE)
 850     InitClip (PCB->Data, ptr1b, (PolygonType *)obj);
 851   return (true);
 852 }
 853
 854 /* ---------------------------------------------------------------------------
 855  * recovers an removed polygon point
 856  * returns true on success
 857  */
 858 static bool
 859 UndoRemoveContour (UndoListTypePtr Entry)
 860 {
 861   assert (Entry->Kind == POLYGON_TYPE);
 862   return UndoSwapCopiedObject (Entry);
 863 }
 864
 865 /* ---------------------------------------------------------------------------
 866  * recovers an inserted polygon point
 867  * returns true on success
 868  */
 869 static bool
 870 UndoInsertContour (UndoListTypePtr Entry)
 871 {
 872   assert (Entry->Kind == POLYGON_TYPE);
 873   return UndoSwapCopiedObject (Entry);
 874 }
 875
 876 /* ---------------------------------------------------------------------------
 877  * undo a layer change
 878  * returns true on success
 879  */
 880 static bool
 881 UndoLayerChange (UndoListTypePtr Entry)
 882 {
 883   LayerChangeTypePtr l = &Entry->Data.LayerChange;
 884   int tmp;
 885
 886   tmp = l->new_index;
 887   l->new_index = l->old_index;
 888   l->old_index = tmp;
 889
 890   if (MoveLayer (l->old_index, l->new_index))
 891     return false;
 892   else
 893     return true;
 894 }
 895
 896 /* ---------------------------------------------------------------------------
 897  * undo a netlist change
 898  * returns true on success
 899  */
 900 static bool
 901 UndoNetlistChange (UndoListTypePtr Entry)
 902 {
 903   NetlistChangeTypePtr l = & Entry->Data.NetlistChange;
 904   unsigned int i, j;
 905   LibraryTypePtr lib, saved;
 906
 907   lib = l->lib;
 908   saved = l->old;
 909
 910   /* iterate over each net */
 911   for (i = 0 ; i < lib->MenuN; i++)
 912     {
 913       if (lib->Menu[i].Name)
 914         free (lib->Menu[i].Name);
 915
 916       if (lib->Menu[i].directory)
 917         free (lib->Menu[i].directory);
 918
 919       if (lib->Menu[i].Style)
 920         free (lib->Menu[i].Style);
 921
 922       /* iterate over each pin on the net */
 923       for (j = 0; j < lib->Menu[i].EntryN; j++) {
 924
 925         if (lib->Menu[i].Entry[j].ListEntry)
 926           free (lib->Menu[i].Entry[j].ListEntry);
 927
 928         if (lib->Menu[i].Entry[j].AllocatedMemory)
 929           free (lib->Menu[i].Entry[j].AllocatedMemory);
 930
 931         if (lib->Menu[i].Entry[j].Template)
 932           free (lib->Menu[i].Entry[j].Template);
 933
 934         if (lib->Menu[i].Entry[j].Package)
 935           free (lib->Menu[i].Entry[j].Package);
 936
 937         if (lib->Menu[i].Entry[j].Value)
 938           free (lib->Menu[i].Entry[j].Value);
 939
 940         if (lib->Menu[i].Entry[j].Description)
 941           free (lib->Menu[i].Entry[j].Description);
 942
 943       }
 944     }
 945
 946   if (lib->Menu)
 947     free (lib->Menu);
 948
 949   *lib = *saved;
 950
 951   NetlistChanged (0);
 952   return true;
 953 }
 954
 955 /* ---------------------------------------------------------------------------
 956  * undo of any 'hard to recover' operation
 957  *
 958  * returns the bitfield for the types of operations that were undone
 959  */
 960 int
 961 Undo (bool draw)
 962 {
 963   UndoListTypePtr ptr;
 964   int Types = 0;
 965   int unique;
 966
 967   unique = TEST_FLAG (UNIQUENAMEFLAG, PCB);
 968   CLEAR_FLAG (UNIQUENAMEFLAG, PCB);
 969
 970   andDraw = draw;
 971
 972   do
 973     {
 974       if (!UndoN)
 975         {
 976           if (!Serial)
 977             Message (_("Nothing to undo - buffer is empty\n"));
 978           else
 979             Serial--;
 980           return (false);
 981         }
 982
 983       /* lock undo module to prevent from loops
 984        * and loop over all entries with the same serial number
 985        */
 986       ptr = &UndoList[UndoN - 1];
 987       if (ptr->Serial != Serial - 1)
 988         {
 989           Message (_("Undo bad serial number %d expecting %d\n"),
 990                    ptr->Serial, Serial - 1);
 991           Serial = ptr->Serial + 1;
 992           return (false);
 993         }
 994       LockUndo ();
 995       Serial = ptr->Serial;
 996       for (; UndoN && ptr->Serial == Serial; ptr--, UndoN--, RedoN++)
 997         Types |= PerformUndo (ptr);
 998       /* release lock */
 999       UnlockUndo ();
1000     }
1001   while (Types == 0);
1002   if (Types && andDraw)
1003     Draw ();
1004
1005   /* restore the unique flag setting */
1006   if (unique)
1007     SET_FLAG (UNIQUENAMEFLAG, PCB);
1008
1009   return (Types);
1010 }
1011
1012 static int
1013 PerformUndo (UndoListTypePtr ptr)
1014 {
1015   switch (ptr->Type)
1016     {
1017     case UNDO_CHANGENAME:
1018       if (UndoChangeName (ptr))
1019         return (UNDO_CHANGENAME);
1020       break;
1021
1022     case UNDO_CREATE:
1023       if (UndoCopyOrCreate (ptr))
1024         return (UNDO_CREATE);
1025       break;
1026
1027     case UNDO_MOVE:
1028       if (UndoMove (ptr))
1029         return (UNDO_MOVE);
1030       break;
1031
1032     case UNDO_REMOVE:
1033       if (UndoRemove (ptr))
1034         return (UNDO_REMOVE);
1035       break;
1036
1037     case UNDO_REMOVE_POINT:
1038       if (UndoRemovePoint (ptr))
1039         return (UNDO_REMOVE_POINT);
1040       break;
1041
1042     case UNDO_INSERT_POINT:
1043       if (UndoInsertPoint (ptr))
1044         return (UNDO_INSERT_POINT);
1045       break;
1046
1047     case UNDO_REMOVE_CONTOUR:
1048       if (UndoRemoveContour (ptr))
1049         return (UNDO_REMOVE_CONTOUR);
1050       break;
1051
1052     case UNDO_INSERT_CONTOUR:
1053       if (UndoInsertContour (ptr))
1054         return (UNDO_INSERT_CONTOUR);
1055       break;
1056
1057     case UNDO_ROTATE:
1058       if (UndoRotate (ptr))
1059         return (UNDO_ROTATE);
1060       break;
1061
1062     case UNDO_CLEAR:
1063       if (UndoClearPoly (ptr))
1064         return (UNDO_CLEAR);
1065       break;
1066
1067     case UNDO_MOVETOLAYER:
1068       if (UndoMoveToLayer (ptr))
1069         return (UNDO_MOVETOLAYER);
1070       break;
1071
1072     case UNDO_FLAG:
1073       if (UndoFlag (ptr))
1074         return (UNDO_FLAG);
1075       break;
1076
1077     case UNDO_CHANGESIZE:
1078       if (UndoChangeSize (ptr))
1079         return (UNDO_CHANGESIZE);
1080       break;
1081
1082     case UNDO_CHANGECLEARSIZE:
1083       if (UndoChangeClearSize (ptr))
1084         return (UNDO_CHANGECLEARSIZE);
1085       break;
1086
1087     case UNDO_CHANGEMASKSIZE:
1088       if (UndoChangeMaskSize (ptr))
1089         return (UNDO_CHANGEMASKSIZE);
1090       break;
1091
1092     case UNDO_CHANGE2NDSIZE:
1093       if (UndoChange2ndSize (ptr))
1094         return (UNDO_CHANGE2NDSIZE);
1095       break;
1096
1097     case UNDO_CHANGEANGLES:
1098       if (UndoChangeAngles (ptr))
1099         return (UNDO_CHANGEANGLES);
1100       break;
1101
1102     case UNDO_LAYERCHANGE:
1103       if (UndoLayerChange (ptr))
1104         return (UNDO_LAYERCHANGE);
1105       break;
1106
1107     case UNDO_NETLISTCHANGE:
1108       if (UndoNetlistChange (ptr))
1109         return (UNDO_NETLISTCHANGE);
1110       break;
1111
1112     case UNDO_MIRROR:
1113       if (UndoMirror (ptr))
1114         return (UNDO_MIRROR);
1115       break;
1116     }
1117   return 0;
1118 }
1119
1120 /* ---------------------------------------------------------------------------
1121  * redo of any 'hard to recover' operation
1122  *
1123  * returns the number of operations redone
1124  */
1125 int
1126 Redo (bool draw)
1127 {
1128   UndoListTypePtr ptr;
1129   int Types = 0;
1130
1131   andDraw = draw;
1132   do
1133     {
1134       if (!RedoN)
1135         {
1136           Message
1137             (_
1138              ("Nothing to redo. Perhaps changes have been made since last undo\n"));
1139           return (false);
1140         }
1141
1142       /* lock undo module to prevent from loops
1143        * and loop over all entries with the same serial number
1144        */
1145       LockUndo ();
1146       ptr = &UndoList[UndoN];
1147       Serial = ptr->Serial;
1148       for (; RedoN && ptr->Serial == Serial; ptr++, UndoN++, RedoN--)
1149         Types |= PerformUndo (ptr);
1150       /* Make next serial number current in case we take a new branch */
1151       Serial++;
1152       UnlockUndo ();
1153     }
1154   while (Types == 0);
1155   if (Types && andDraw)
1156     Draw ();
1157   return (Types);
1158 }
1159
1160 /* ---------------------------------------------------------------------------
1161  * restores the serial number of the undo list
1162  */
1163 void
1164 RestoreUndoSerialNumber (void)
1165 {
1166   Serial = SavedSerial;
1167 }
1168
1169 /* ---------------------------------------------------------------------------
1170  * saves the serial number of the undo list
1171  */
1172 void
1173 SaveUndoSerialNumber (void)
1174 {
1175   Bumped = false;
1176   SavedSerial = Serial;
1177 }
1178
1179 /* ---------------------------------------------------------------------------
1180  * increments the serial number of the undo list
1181  * it's not done automatically because some operations perform more
1182  * than one request with the same serial #
1183  */
1184 void
1185 IncrementUndoSerialNumber (void)
1186 {
1187   if (!Locked)
1188     {
1189       /* don't increment if nothing was added */
1190       if (UndoN == 0 || UndoList[UndoN - 1].Serial != Serial)
1191         return;
1192       Serial++;
1193       Bumped = true;
1194       SetChangedFlag (true);
1195     }
1196 }
1197
1198 /* ---------------------------------------------------------------------------
1199  * releases memory of the undo- and remove list
1200  */
1201 void
1202 ClearUndoList (bool Force)
1203 {
1204   UndoListTypePtr undo;
1205
1206   if (UndoN
1207       && (Force || gui->confirm_dialog ("OK to clear 'undo' buffer?", 0)))
1208     {
1209       /* release memory allocated by objects in undo list */
1210       for (undo = UndoList; UndoN; undo++, UndoN--)
1211         {
1212           if (undo->Type == UNDO_CHANGENAME)
1213             free (undo->Data.ChangeName.Name);
1214         }
1215       free (UndoList);
1216       UndoList = NULL;
1217       if (RemoveList)
1218         {
1219           FreeDataMemory (RemoveList);
1220           free (RemoveList);
1221           RemoveList = NULL;
1222         }
1223
1224       /* reset some counters */
1225       UndoN = UndoMax = RedoN = 0;
1226     }
1227
1228   /* reset counter in any case */
1229   Serial = 1;
1230 }
1231
1232 /* ---------------------------------------------------------------------------
1233  * adds an object to the list of clearpoly objects
1234  */
1235 void
1236 AddObjectToClearPolyUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
1237                               bool clear)
1238 {
1239   UndoListTypePtr undo;
1240
1241   if (!Locked)
1242     {
1243       undo = GetUndoSlot (UNDO_CLEAR, OBJECT_ID (Ptr3), Type);
1244       undo->Data.ClearPoly.Clear = clear;
1245       undo->Data.ClearPoly.Layer = (LayerTypePtr) Ptr1;
1246     }
1247 }
1248
1249 /* ---------------------------------------------------------------------------
1250  * adds an object to the list of mirrored objects
1251  */
1252 void
1253 AddObjectToMirrorUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
1254                            LocationType yoff)
1255 {
1256   UndoListTypePtr undo;
1257
1258   if (!Locked)
1259     {
1260       undo = GetUndoSlot (UNDO_MIRROR, OBJECT_ID (Ptr3), Type);
1261       undo->Data.Move.DY = yoff;
1262     }
1263 }
1264
1265 /* ---------------------------------------------------------------------------
1266  * adds an object to the list of rotated objects
1267  */
1268 void
1269 AddObjectToRotateUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
1270                            LocationType CenterX, LocationType CenterY,
1271                            BYTE Steps)
1272 {
1273   UndoListTypePtr undo;
1274
1275   if (!Locked)
1276     {
1277       undo = GetUndoSlot (UNDO_ROTATE, OBJECT_ID (Ptr3), Type);
1278       undo->Data.Rotate.CenterX = CenterX;
1279       undo->Data.Rotate.CenterY = CenterY;
1280       undo->Data.Rotate.Steps = Steps;
1281     }
1282 }
1283
1284 /* ---------------------------------------------------------------------------
1285  * adds an object to the list of removed objects and removes it from
1286  * the current PCB
1287  */
1288 void
1289 MoveObjectToRemoveUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1290 {
1291   UndoListTypePtr undo;
1292
1293   if (!Locked)
1294     {
1295       if (!RemoveList)
1296         RemoveList = CreateNewBuffer ();
1297
1298       undo = GetUndoSlot (UNDO_REMOVE, OBJECT_ID (Ptr3), Type);
1299       MoveObjectToBuffer (RemoveList, PCB->Data, Type, Ptr1, Ptr2, Ptr3);
1300     }
1301 }
1302
1303 /* ---------------------------------------------------------------------------
1304  * adds an object to the list of removed polygon/... points
1305  */
1306 void
1307 AddObjectToRemovePointUndoList (int Type,
1308                                 void *Ptr1, void *Ptr2, Cardinal index)
1309 {
1310   UndoListTypePtr undo;
1311   PolygonTypePtr polygon = (PolygonTypePtr) Ptr2;
1312   Cardinal hole;
1313   bool last_in_contour = false;
1314
1315   if (!Locked)
1316     {
1317       switch (Type)
1318         {
1319         case POLYGONPOINT_TYPE:
1320           {
1321             /* save the ID of the parent object; else it will be
1322              * impossible to recover the point
1323              */
1324             undo =
1325               GetUndoSlot (UNDO_REMOVE_POINT, OBJECT_ID (polygon),
1326                            POLYGON_TYPE);
1327             undo->Data.RemovedPoint.X = polygon->Points[index].X;
1328             undo->Data.RemovedPoint.Y = polygon->Points[index].Y;
1329             undo->Data.RemovedPoint.ID = polygon->Points[index].ID;
1330             undo->Data.RemovedPoint.Index = index;
1331
1332             /* Check whether this point was at the end of its contour.
1333              * If so, we need to flag as such when re-adding the point
1334              * so it goes back in the correct place
1335              */
1336             for (hole = 0; hole < polygon->HoleIndexN; hole++)
1337               if (index == polygon->HoleIndex[hole] - 1)
1338                 last_in_contour = true;
1339             if (index == polygon->PointN - 1)
1340               last_in_contour = true;
1341             undo->Data.RemovedPoint.last_in_contour = last_in_contour;
1342           }
1343           break;
1344         }
1345     }
1346 }
1347
1348 /* ---------------------------------------------------------------------------
1349  * adds an object to the list of inserted polygon/... points
1350  */
1351 void
1352 AddObjectToInsertPointUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1353 {
1354   UndoListTypePtr undo;
1355
1356   if (!Locked)
1357     undo = GetUndoSlot (UNDO_INSERT_POINT, OBJECT_ID (Ptr3), Type);
1358 }
1359
1360 static void
1361 CopyObjectToUndoList (int undo_type, int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1362 {
1363   UndoListTypePtr undo;
1364   AnyObjectType *copy;
1365
1366   if (Locked)
1367     return;
1368
1369   if (!RemoveList)
1370     RemoveList = CreateNewBuffer ();
1371
1372   undo = GetUndoSlot (undo_type, OBJECT_ID (Ptr2), Type);
1373   copy = CopyObjectToBuffer (RemoveList, PCB->Data, Type, Ptr1, Ptr2, Ptr3);
1374   undo->Data.CopyID = copy->ID;
1375 }
1376
1377 /* ---------------------------------------------------------------------------
1378  * adds an object to the list of removed contours
1379  * (Actually just takes a copy of the whole polygon to restore)
1380  */
1381 void
1382 AddObjectToRemoveContourUndoList (int Type,
1383                                   LayerType *Layer, PolygonType *Polygon)
1384 {
1385   CopyObjectToUndoList (UNDO_REMOVE_CONTOUR, Type, Layer, Polygon, NULL);
1386 }
1387
1388 /* ---------------------------------------------------------------------------
1389  * adds an object to the list of insert contours
1390  * (Actually just takes a copy of the whole polygon to restore)
1391  */
1392 void
1393 AddObjectToInsertContourUndoList (int Type,
1394                                   LayerType *Layer, PolygonType *Polygon)
1395 {
1396   CopyObjectToUndoList (UNDO_INSERT_CONTOUR, Type, Layer, Polygon, NULL);
1397 }
1398
1399 /* ---------------------------------------------------------------------------
1400  * adds an object to the list of moved objects
1401  */
1402 void
1403 AddObjectToMoveUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
1404                          LocationType DX, LocationType DY)
1405 {
1406   UndoListTypePtr undo;
1407
1408   if (!Locked)
1409     {
1410       undo = GetUndoSlot (UNDO_MOVE, OBJECT_ID (Ptr3), Type);
1411       undo->Data.Move.DX = DX;
1412       undo->Data.Move.DY = DY;
1413     }
1414 }
1415
1416 /* ---------------------------------------------------------------------------
1417  * adds an object to the list of objects with changed names
1418  */
1419 void
1420 AddObjectToChangeNameUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
1421                                char *OldName)
1422 {
1423   UndoListTypePtr undo;
1424
1425   if (!Locked)
1426     {
1427       undo = GetUndoSlot (UNDO_CHANGENAME, OBJECT_ID (Ptr3), Type);
1428       undo->Data.ChangeName.Name = OldName;
1429     }
1430 }
1431
1432 /* ---------------------------------------------------------------------------
1433  * adds an object to the list of objects moved to another layer
1434  */
1435 void
1436 AddObjectToMoveToLayerUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1437 {
1438   UndoListTypePtr undo;
1439
1440   if (!Locked)
1441     {
1442       undo = GetUndoSlot (UNDO_MOVETOLAYER, OBJECT_ID (Ptr3), Type);
1443       undo->Data.MoveToLayer.OriginalLayer =
1444         GetLayerNumber (PCB->Data, (LayerTypePtr) Ptr1);
1445     }
1446 }
1447
1448 /* ---------------------------------------------------------------------------
1449  * adds an object to the list of created objects
1450  */
1451 void
1452 AddObjectToCreateUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1453 {
1454   UndoListTypePtr undo;
1455
1456   if (!Locked)
1457     undo = GetUndoSlot (UNDO_CREATE, OBJECT_ID (Ptr3), Type);
1458   ClearFromPolygon (PCB->Data, Type, Ptr1, Ptr2);
1459 }
1460
1461 /* ---------------------------------------------------------------------------
1462  * adds an object to the list of objects with flags changed
1463  */
1464 void
1465 AddObjectToFlagUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1466 {
1467   UndoListTypePtr undo;
1468
1469   if (!Locked)
1470     {
1471       undo = GetUndoSlot (UNDO_FLAG, OBJECT_ID (Ptr2), Type);
1472       undo->Data.Flags = ((PinTypePtr) Ptr2)->Flags;
1473     }
1474 }
1475
1476 /* ---------------------------------------------------------------------------
1477  * adds an object to the list of objects with Size changes
1478  */
1479 void
1480 AddObjectToSizeUndoList (int Type, void *ptr1, void *ptr2, void *ptr3)
1481 {
1482   UndoListTypePtr undo;
1483
1484   if (!Locked)
1485     {
1486       undo = GetUndoSlot (UNDO_CHANGESIZE, OBJECT_ID (ptr2), Type);
1487       switch (Type)
1488         {
1489         case PIN_TYPE:
1490         case VIA_TYPE:
1491           undo->Data.Size = ((PinTypePtr) ptr2)->Thickness;
1492           break;
1493         case LINE_TYPE:
1494         case ELEMENTLINE_TYPE:
1495           undo->Data.Size = ((LineTypePtr) ptr2)->Thickness;
1496           break;
1497         case TEXT_TYPE:
1498         case ELEMENTNAME_TYPE:
1499           undo->Data.Size = ((TextTypePtr) ptr2)->Scale;
1500           break;
1501         case PAD_TYPE:
1502           undo->Data.Size = ((PadTypePtr) ptr2)->Thickness;
1503           break;
1504         case ARC_TYPE:
1505         case ELEMENTARC_TYPE:
1506           undo->Data.Size = ((ArcTypePtr) ptr2)->Thickness;
1507           break;
1508         }
1509     }
1510 }
1511
1512 /* ---------------------------------------------------------------------------
1513  * adds an object to the list of objects with Size changes
1514  */
1515 void
1516 AddObjectToClearSizeUndoList (int Type, void *ptr1, void *ptr2, void *ptr3)
1517 {
1518   UndoListTypePtr undo;
1519
1520   if (!Locked)
1521     {
1522       undo = GetUndoSlot (UNDO_CHANGECLEARSIZE, OBJECT_ID (ptr2), Type);
1523       switch (Type)
1524         {
1525         case PIN_TYPE:
1526         case VIA_TYPE:
1527           undo->Data.Size = ((PinTypePtr) ptr2)->Clearance;
1528           break;
1529         case LINE_TYPE:
1530           undo->Data.Size = ((LineTypePtr) ptr2)->Clearance;
1531           break;
1532         case PAD_TYPE:
1533           undo->Data.Size = ((PadTypePtr) ptr2)->Clearance;
1534           break;
1535         case ARC_TYPE:
1536           undo->Data.Size = ((ArcTypePtr) ptr2)->Clearance;
1537           break;
1538         }
1539     }
1540 }
1541
1542 /* ---------------------------------------------------------------------------
1543  * adds an object to the list of objects with Size changes
1544  */
1545 void
1546 AddObjectToMaskSizeUndoList (int Type, void *ptr1, void *ptr2, void *ptr3)
1547 {
1548   UndoListTypePtr undo;
1549
1550   if (!Locked)
1551     {
1552       undo = GetUndoSlot (UNDO_CHANGEMASKSIZE, OBJECT_ID (ptr2), Type);
1553       switch (Type)
1554         {
1555         case PIN_TYPE:
1556         case VIA_TYPE:
1557           undo->Data.Size = ((PinTypePtr) ptr2)->Mask;
1558           break;
1559         case PAD_TYPE:
1560           undo->Data.Size = ((PadTypePtr) ptr2)->Mask;
1561           break;
1562         }
1563     }
1564 }
1565
1566 /* ---------------------------------------------------------------------------
1567  * adds an object to the list of objects with 2ndSize changes
1568  */
1569 void
1570 AddObjectTo2ndSizeUndoList (int Type, void *ptr1, void *ptr2, void *ptr3)
1571 {
1572   UndoListTypePtr undo;
1573
1574   if (!Locked)
1575     {
1576       undo = GetUndoSlot (UNDO_CHANGE2NDSIZE, OBJECT_ID (ptr2), Type);
1577       if (Type == PIN_TYPE || Type == VIA_TYPE)
1578         undo->Data.Size = ((PinTypePtr) ptr2)->DrillingHole;
1579     }
1580 }
1581
1582 /* ---------------------------------------------------------------------------
1583  * adds an object to the list of changed angles.  Note that you must
1584  * call this before changing the angles, passing the new start/delta.
1585  */
1586 void
1587 AddObjectToChangeAnglesUndoList (int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1588 {
1589   UndoListTypePtr undo;
1590   ArcTypePtr a = (ArcTypePtr) Ptr3;
1591
1592   if (!Locked)
1593     {
1594       undo = GetUndoSlot (UNDO_CHANGEANGLES, OBJECT_ID (Ptr3), Type);
1595       undo->Data.Move.DX = a->StartAngle;
1596       undo->Data.Move.DY = a->Delta;
1597     }
1598 }
1599
1600 /* ---------------------------------------------------------------------------
1601  * adds a layer change (new, delete, move) to the undo list.
1602  */
1603 void
1604 AddLayerChangeToUndoList (int old_index, int new_index)
1605 {
1606   UndoListTypePtr undo;
1607
1608   if (!Locked)
1609     {
1610       undo = GetUndoSlot (UNDO_LAYERCHANGE, 0, 0);
1611       undo->Data.LayerChange.old_index = old_index;
1612       undo->Data.LayerChange.new_index = new_index;
1613     }
1614 }
1615
1616 /* ---------------------------------------------------------------------------
1617  * adds a netlist change to the undo list
1618  */
1619 void
1620 AddNetlistLibToUndoList (LibraryTypePtr lib)
1621 {
1622   UndoListTypePtr undo;
1623   unsigned int i, j;
1624   LibraryTypePtr old;
1625
1626   if (!Locked)
1627     {
1628       undo = GetUndoSlot (UNDO_NETLISTCHANGE, 0, 0);
1629       /* keep track of where the data needs to go */
1630       undo->Data.NetlistChange.lib = lib;
1631
1632       /* and what the old data is that we'll need to restore */
1633       undo->Data.NetlistChange.old = malloc (sizeof (LibraryTypePtr));
1634       old = undo->Data.NetlistChange.old;
1635       old->MenuN = lib->MenuN;
1636       old->MenuMax = lib->MenuMax;
1637       old->Menu = malloc (old->MenuMax * sizeof (LibraryMenuType));
1638       if (old->Menu == NULL)
1639         {
1640           fprintf (stderr, "malloc() failed in %s\n", __FUNCTION__);
1641           exit (1);
1642         }
1643
1644       /* iterate over each net */
1645       for (i = 0 ; i < lib->MenuN; i++)
1646         {
1647           old->Menu[i].EntryN = lib->Menu[i].EntryN;
1648           old->Menu[i].EntryMax = lib->Menu[i].EntryMax;
1649
1650           old->Menu[i].Name =
1651             lib->Menu[i].Name ? strdup (lib->Menu[i].Name) : NULL;
1652
1653           old->Menu[i].directory =
1654             lib->Menu[i].directory ? strdup (lib->Menu[i].directory) : NULL;
1655
1656           old->Menu[i].Style =
1657             lib->Menu[i].Style ? strdup (lib->Menu[i].Style) : NULL;
1658
1659
1660           old->Menu[i].Entry =
1661             malloc (old->Menu[i].EntryMax * sizeof (LibraryEntryType));
1662           if (old->Menu[i].Entry == NULL)
1663             {
1664               fprintf (stderr, "malloc() failed in %s\n", __FUNCTION__);
1665               exit (1);
1666             }
1667
1668           /* iterate over each pin on the net */
1669           for (j = 0; j < lib->Menu[i].EntryN; j++) {
1670
1671             old->Menu[i].Entry[j].ListEntry =
1672               lib->Menu[i].Entry[j].ListEntry ?
1673               strdup (lib->Menu[i].Entry[j].ListEntry) :
1674               NULL;
1675
1676             old->Menu[i].Entry[j].AllocatedMemory =
1677               lib->Menu[i].Entry[j].AllocatedMemory ?
1678               strdup (lib->Menu[i].Entry[j].AllocatedMemory) :
1679               NULL;
1680
1681             old->Menu[i].Entry[j].Template =
1682               lib->Menu[i].Entry[j].Template ?
1683               strdup (lib->Menu[i].Entry[j].Template) :
1684               NULL;
1685
1686             old->Menu[i].Entry[j].Package =
1687               lib->Menu[i].Entry[j].Package ?
1688               strdup (lib->Menu[i].Entry[j].Package) :
1689               NULL;
1690
1691             old->Menu[i].Entry[j].Value =
1692               lib->Menu[i].Entry[j].Value ?
1693               strdup (lib->Menu[i].Entry[j].Value) :
1694               NULL;
1695
1696             old->Menu[i].Entry[j].Description =
1697               lib->Menu[i].Entry[j].Description ?
1698               strdup (lib->Menu[i].Entry[j].Description) :
1699               NULL;
1700
1701
1702           }
1703         }
1704
1705     }
1706 }
1707
1708 /* ---------------------------------------------------------------------------
1709  * set lock flag
1710  */
1711 void
1712 LockUndo (void)
1713 {
1714   Locked = true;
1715 }
1716
1717 /* ---------------------------------------------------------------------------
1718  * reset lock flag
1719  */
1720 void
1721 UnlockUndo (void)
1722 {
1723   Locked = false;
1724 }
1725
1726 /* ---------------------------------------------------------------------------
1727  * return undo lock state
1728  */
1729 bool
1730 Undoing (void)
1731 {
1732   return (Locked);
1733 }