src/buffer.c

   1 /* $Id$ */
   2
   3 /*
   4  *                            COPYRIGHT
   5  *
   6  *  PCB, interactive printed circuit board design
   7  *  Copyright (C) 1994,1995,1996, 2005 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 by paste- and move/copy buffer
  30  */
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include "config.h"
  34 #endif
  35
  36 #include <stdlib.h>
  37 #include <memory.h>
  38 #include <math.h>
  39
  40 #include "global.h"
  41
  42 #include "buffer.h"
  43 #include "copy.h"
  44 #include "create.h"
  45 #include "crosshair.h"
  46 #include "data.h"
  47 #include "error.h"
  48 #include "mymem.h"
  49 #include "mirror.h"
  50 #include "misc.h"
  51 #include "parse_l.h"
  52 #include "polygon.h"
  53 #include "rats.h"
  54 #include "rotate.h"
  55 #include "remove.h"
  56 #include "rtree.h"
  57 #include "search.h"
  58 #include "select.h"
  59 #include "set.h"
  60
  61 #ifdef HAVE_LIBDMALLOC
  62 #include <dmalloc.h>
  63 #endif
  64
  65 RCSID ("$Id$");
  66
  67 /* ---------------------------------------------------------------------------
  68  * some local prototypes
  69  */
  70 static void *AddViaToBuffer (PinTypePtr);
  71 static void *AddLineToBuffer (LayerTypePtr, LineTypePtr);
  72 static void *AddArcToBuffer (LayerTypePtr, ArcTypePtr);
  73 static void *AddRatToBuffer (RatTypePtr);
  74 static void *AddTextToBuffer (LayerTypePtr, TextTypePtr);
  75 static void *AddPolygonToBuffer (LayerTypePtr, PolygonTypePtr);
  76 static void *AddElementToBuffer (ElementTypePtr);
  77 static void *MoveViaToBuffer (PinTypePtr);
  78 static void *MoveLineToBuffer (LayerTypePtr, LineTypePtr);
  79 static void *MoveArcToBuffer (LayerTypePtr, ArcTypePtr);
  80 static void *MoveRatToBuffer (RatTypePtr);
  81 static void *MoveTextToBuffer (LayerTypePtr, TextTypePtr);
  82 static void *MovePolygonToBuffer (LayerTypePtr, PolygonTypePtr);
  83 static void *MoveElementToBuffer (ElementTypePtr);
  84 static void SwapBuffer (BufferTypePtr);
  85
  86 #define ARG(n) (argc > (n) ? argv[n] : 0)
  87
  88 /* ---------------------------------------------------------------------------
  89  * some local identifiers
  90  */
  91 static DataTypePtr Dest, Source;
  92
  93 static ObjectFunctionType AddBufferFunctions = {
  94   AddLineToBuffer,
  95   AddTextToBuffer,
  96   AddPolygonToBuffer,
  97   AddViaToBuffer,
  98   AddElementToBuffer,
  99   NULL,
 100   NULL,
 101   NULL,
 102   NULL,
 103   NULL,
 104   AddArcToBuffer,
 105   AddRatToBuffer
 106 }, MoveBufferFunctions =
 107
 108 {
 109 MoveLineToBuffer,
 110     MoveTextToBuffer,
 111     MovePolygonToBuffer,
 112     MoveViaToBuffer,
 113     MoveElementToBuffer,
 114     NULL, NULL, NULL, NULL, NULL, MoveArcToBuffer, MoveRatToBuffer};
 115
 116 static int ExtraFlag = 0;
 117
 118 /* ---------------------------------------------------------------------------
 119  * copies a via to paste buffer
 120  */
 121 static void *
 122 AddViaToBuffer (PinTypePtr Via)
 123 {
 124   return (CreateNewVia (Dest, Via->X, Via->Y, Via->Thickness, Via->Clearance,
 125                         Via->Mask, Via->DrillingHole, Via->Name,
 126                         MaskFlags (Via->Flags, FOUNDFLAG | ExtraFlag)));
 127 }
 128
 129 /* ---------------------------------------------------------------------------
 130  * copies a rat-line to paste buffer
 131  */
 132 static void *
 133 AddRatToBuffer (RatTypePtr Rat)
 134 {
 135   return (CreateNewRat (Dest, Rat->Point1.X, Rat->Point1.Y,
 136                         Rat->Point2.X, Rat->Point2.Y, Rat->group1,
 137                         Rat->group2, Rat->Thickness,
 138                         MaskFlags (Rat->Flags, FOUNDFLAG | ExtraFlag)));
 139 }
 140
 141 /* ---------------------------------------------------------------------------
 142  * copies a line to buffer
 143  */
 144 static void *
 145 AddLineToBuffer (LayerTypePtr Layer, LineTypePtr Line)
 146 {
 147   LineTypePtr line;
 148   LayerTypePtr layer = &Dest->Layer[GetLayerNumber (Source, Layer)];
 149
 150   line = CreateNewLineOnLayer (layer, Line->Point1.X, Line->Point1.Y,
 151                                Line->Point2.X, Line->Point2.Y,
 152                                Line->Thickness, Line->Clearance,
 153                                MaskFlags (Line->Flags,
 154                                           FOUNDFLAG | ExtraFlag));
 155   if (line && Line->Number)
 156     line->Number = MyStrdup (Line->Number, "AddLineToBuffer");
 157   return (line);
 158 }
 159
 160 /* ---------------------------------------------------------------------------
 161  * copies an arc to buffer
 162  */
 163 static void *
 164 AddArcToBuffer (LayerTypePtr Layer, ArcTypePtr Arc)
 165 {
 166   LayerTypePtr layer = &Dest->Layer[GetLayerNumber (Source, Layer)];
 167
 168   return (CreateNewArcOnLayer (layer, Arc->X, Arc->Y,
 169                                Arc->Width, Arc->Height, Arc->StartAngle, Arc->Delta,
 170                                Arc->Thickness, Arc->Clearance,
 171                                MaskFlags (Arc->Flags,
 172                                           FOUNDFLAG | ExtraFlag)));
 173 }
 174
 175 /* ---------------------------------------------------------------------------
 176  * copies a text to buffer
 177  */
 178 static void *
 179 AddTextToBuffer (LayerTypePtr Layer, TextTypePtr Text)
 180 {
 181   LayerTypePtr layer = &Dest->Layer[GetLayerNumber (Source, Layer)];
 182
 183   return (CreateNewText (layer, &PCB->Font, Text->X, Text->Y,
 184                          Text->Direction, Text->Scale, Text->TextString,
 185                          MaskFlags (Text->Flags, ExtraFlag)));
 186 }
 187
 188 /* ---------------------------------------------------------------------------
 189  * copies a polygon to buffer
 190  */
 191 static void *
 192 AddPolygonToBuffer (LayerTypePtr Layer, PolygonTypePtr Polygon)
 193 {
 194   LayerTypePtr layer = &Dest->Layer[GetLayerNumber (Source, Layer)];
 195   PolygonTypePtr polygon;
 196
 197   polygon = GetPolygonMemory (layer);
 198   CopyPolygonLowLevel (polygon, Polygon);
 199   CLEAR_FLAG (FOUNDFLAG | ExtraFlag, polygon);
 200   return (polygon);
 201 }
 202
 203 /* ---------------------------------------------------------------------------
 204  * copies a element to buffer
 205  */
 206 static void *
 207 AddElementToBuffer (ElementTypePtr Element)
 208 {
 209   ElementTypePtr element;
 210
 211   element = GetElementMemory (Dest);
 212   CopyElementLowLevel (Dest, element, Element, False, 0, 0);
 213   CLEAR_FLAG (ExtraFlag, element);
 214   if (ExtraFlag)
 215     {
 216       ELEMENTTEXT_LOOP (element);
 217       {
 218         CLEAR_FLAG (ExtraFlag, text);
 219       }
 220       END_LOOP;
 221       PIN_LOOP (element);
 222       {
 223         CLEAR_FLAG (FOUNDFLAG | ExtraFlag, pin);
 224       }
 225       END_LOOP;
 226       PAD_LOOP (element);
 227       {
 228         CLEAR_FLAG (FOUNDFLAG | ExtraFlag, pad);
 229       }
 230       END_LOOP;
 231     }
 232   return (element);
 233 }
 234
 235 /* ---------------------------------------------------------------------------
 236  * moves a via to paste buffer without allocating memory for the name
 237  */
 238 static void *
 239 MoveViaToBuffer (PinTypePtr Via)
 240 {
 241   PinTypePtr via;
 242
 243   RestoreToPolygon (Source, VIA_TYPE, Via, Via);
 244   r_delete_entry (Source->via_tree, (BoxType *) Via);
 245   via = GetViaMemory (Dest);
 246   *via = *Via;
 247   CLEAR_FLAG (WARNFLAG | FOUNDFLAG, via);
 248   if (Via != &Source->Via[--Source->ViaN])
 249   {
 250   *Via = Source->Via[Source->ViaN];
 251   r_substitute (Source->via_tree, (BoxType *) & Source->Via[Source->ViaN],
 252                 (BoxType *) Via);
 253   }
 254   memset (&Source->Via[Source->ViaN], 0, sizeof (PinType));
 255   if (!Dest->via_tree)
 256     Dest->via_tree = r_create_tree (NULL, 0, 0);
 257   r_insert_entry (Dest->via_tree, (BoxType *) via, 0);
 258   ClearFromPolygon (Dest, VIA_TYPE, via, via);
 259   return (via);
 260 }
 261
 262 /* ---------------------------------------------------------------------------
 263  * moves a rat-line to paste buffer
 264  */
 265 static void *
 266 MoveRatToBuffer (RatTypePtr Rat)
 267 {
 268   RatTypePtr rat;
 269
 270   r_delete_entry (Source->rat_tree, &Rat->BoundingBox);
 271   rat = GetRatMemory (Dest);
 272   *rat = *Rat;
 273   CLEAR_FLAG (FOUNDFLAG, rat);
 274   if (Rat != &Source->Rat[--Source->RatN])
 275   {
 276   *Rat = Source->Rat[Source->RatN];
 277   r_substitute (Source->rat_tree, &Source->Rat[Source->RatN].BoundingBox,
 278                 &Rat->BoundingBox);
 279   }
 280   memset (&Source->Rat[Source->RatN], 0, sizeof (RatType));
 281   if (!Dest->rat_tree)
 282     Dest->rat_tree = r_create_tree (NULL, 0, 0);
 283   r_insert_entry (Dest->rat_tree, &rat->BoundingBox, 0);
 284   return (rat);
 285 }
 286
 287 /* ---------------------------------------------------------------------------
 288  * moves a line to buffer
 289  */
 290 static void *
 291 MoveLineToBuffer (LayerTypePtr Layer, LineTypePtr Line)
 292 {
 293   LayerTypePtr lay;
 294   LineTypePtr line;
 295
 296   RestoreToPolygon (Source, LINE_TYPE, Layer, Line);
 297   r_delete_entry (Layer->line_tree, (BoxTypePtr) Line);
 298   lay = &Dest->Layer[GetLayerNumber (Source, Layer)];
 299   line = GetLineMemory (lay);
 300   *line = *Line;
 301   CLEAR_FLAG (FOUNDFLAG, line);
 302   /* line pointers being shuffled */
 303   if (Line != &Layer->Line[--Layer->LineN])
 304   {
 305   *Line = Layer->Line[Layer->LineN];
 306   r_substitute (Layer->line_tree, (BoxTypePtr) & Layer->Line[Layer->LineN],
 307                 (BoxTypePtr) Line);
 308   }
 309   memset (&Layer->Line[Layer->LineN], 0, sizeof (LineType));
 310   if (!lay->line_tree)
 311     lay->line_tree = r_create_tree (NULL, 0, 0);
 312   r_insert_entry (lay->line_tree, (BoxTypePtr) line, 0);
 313   ClearFromPolygon (Dest, LINE_TYPE, lay, line);
 314   return (line);
 315 }
 316
 317 /* ---------------------------------------------------------------------------
 318  * moves an arc to buffer
 319  */
 320 static void *
 321 MoveArcToBuffer (LayerTypePtr Layer, ArcTypePtr Arc)
 322 {
 323   LayerTypePtr lay;
 324   ArcTypePtr arc;
 325
 326   RestoreToPolygon (Source, ARC_TYPE, Layer, Arc);
 327   r_delete_entry (Layer->arc_tree, (BoxTypePtr) Arc);
 328   lay = &Dest->Layer[GetLayerNumber (Source, Layer)];
 329   arc = GetArcMemory (lay);
 330   *arc = *Arc;
 331   CLEAR_FLAG (FOUNDFLAG, arc);
 332   /* arc pointers being shuffled */
 333   if (Arc != &Layer->Arc[--Layer->ArcN])
 334   {
 335   *Arc = Layer->Arc[Layer->ArcN];
 336   r_substitute (Layer->arc_tree, (BoxTypePtr) & Layer->Arc[Layer->ArcN],
 337                 (BoxTypePtr) Arc);
 338   }
 339   memset (&Layer->Arc[Layer->ArcN], 0, sizeof (ArcType));
 340   if (!lay->arc_tree)
 341     lay->arc_tree = r_create_tree (NULL, 0, 0);
 342   r_insert_entry (lay->arc_tree, (BoxTypePtr) arc, 0);
 343   ClearFromPolygon (Dest, ARC_TYPE, lay, arc);
 344   return (arc);
 345 }
 346
 347 /* ---------------------------------------------------------------------------
 348  * moves a text to buffer without allocating memory for the name
 349  */
 350 static void *
 351 MoveTextToBuffer (LayerTypePtr Layer, TextTypePtr Text)
 352 {
 353   TextTypePtr text;
 354   LayerTypePtr lay;
 355
 356   r_delete_entry (Layer->text_tree, (BoxTypePtr) Text);
 357   RestoreToPolygon (Source, TEXT_TYPE, Layer, Text);
 358   lay = &Dest->Layer[GetLayerNumber (Source, Layer)];
 359   text = GetTextMemory (lay);
 360   *text = *Text;
 361   if (Text != &Layer->Text[--Layer->TextN])
 362   {
 363   *Text = Layer->Text[Layer->TextN];
 364   r_substitute (Layer->text_tree, (BoxTypePtr) & Layer->Text[Layer->TextN],
 365                 (BoxTypePtr) Text);
 366   }
 367   memset (&Layer->Text[Layer->TextN], 0, sizeof (TextType));
 368   if (!lay->text_tree)
 369     lay->text_tree = r_create_tree (NULL, 0, 0);
 370   r_insert_entry (lay->text_tree, (BoxTypePtr) text, 0);
 371   ClearFromPolygon (Dest, TEXT_TYPE, lay, text);
 372   return (text);
 373 }
 374
 375 /* ---------------------------------------------------------------------------
 376  * moves a polygon to buffer. Doesn't allocate memory for the points
 377  */
 378 static void *
 379 MovePolygonToBuffer (LayerTypePtr Layer, PolygonTypePtr Polygon)
 380 {
 381   LayerTypePtr lay;
 382   PolygonTypePtr polygon;
 383
 384   r_delete_entry (Layer->polygon_tree, (BoxTypePtr) Polygon);
 385   lay = &Dest->Layer[GetLayerNumber (Source, Layer)];
 386   polygon = GetPolygonMemory (lay);
 387   *polygon = *Polygon;
 388   CLEAR_FLAG (FOUNDFLAG, polygon);
 389   if (Polygon != &Layer->Polygon[--Layer->PolygonN])
 390   {
 391   *Polygon = Layer->Polygon[Layer->PolygonN];
 392   r_substitute (Layer->polygon_tree,
 393                 (BoxTypePtr) & Layer->Polygon[Layer->PolygonN],
 394                 (BoxTypePtr) Polygon);
 395   }
 396   memset (&Layer->Polygon[Layer->PolygonN], 0, sizeof (PolygonType));
 397   if (!lay->polygon_tree)
 398     lay->polygon_tree = r_create_tree (NULL, 0, 0);
 399   r_insert_entry (lay->polygon_tree, (BoxTypePtr) polygon, 0);
 400   return (polygon);
 401 }
 402
 403 /* ---------------------------------------------------------------------------
 404  * moves a element to buffer without allocating memory for pins/names
 405  */
 406 static void *
 407 MoveElementToBuffer (ElementTypePtr Element)
 408 {
 409   ElementTypePtr element;
 410   int i;
 411
 412   /*
 413    * Two steps at once:  Delete the element from the source (remove it
 414    * from trees, restore to polygons) and simultaneously adjust its
 415    * component pointers to the new storage in Dest
 416    */
 417   r_delete_element (Source, Element);
 418   element = GetElementMemory (Dest);
 419   *element = *Element;
 420   PIN_LOOP (element);
 421   {
 422     RestoreToPolygon(Source, PIN_TYPE, Element, pin);
 423     CLEAR_FLAG (WARNFLAG | FOUNDFLAG, pin);
 424     pin->Element = element;
 425   }
 426   END_LOOP;
 427   PAD_LOOP (element);
 428   {
 429     RestoreToPolygon(Source, PAD_TYPE, Element, pad);
 430     CLEAR_FLAG (WARNFLAG | FOUNDFLAG, pad);
 431     pad->Element = element;
 432   }
 433   END_LOOP;
 434   ELEMENTTEXT_LOOP (element);
 435   {
 436     text->Element = element;
 437   }
 438   END_LOOP;
 439   SetElementBoundingBox (Dest, element, &PCB->Font);
 440   /*
 441    * Now clear the from the polygons in the destination
 442    */
 443   PIN_LOOP (element);
 444   {
 445     ClearFromPolygon (Dest, PIN_TYPE, element, pin);
 446   }
 447   END_LOOP;
 448   PAD_LOOP (element);
 449   {
 450     ClearFromPolygon (Dest, PAD_TYPE, element, pad);
 451   }
 452   END_LOOP;
 453
 454   /*
 455    * Now compact the Source's Element array by moving the last element
 456    * to the hole created by the removal above.  Then make a pass adjusting
 457    * *its* component pointers.  Confusingly, this element (which is of no
 458    * particular relation to this removal) becomes `Element' while the
 459    * original Element is now in `element'.
 460    */
 461   if (Element != &Source->Element[--Source->ElementN])
 462     {
 463   *Element = Source->Element[Source->ElementN];
 464   r_substitute (Source->element_tree,
 465                 (BoxType *) & Source->Element[Source->ElementN],
 466                 (BoxType *) Element);
 467   for (i = 0; i < MAX_ELEMENTNAMES; i++)
 468     r_substitute (Source->name_tree[i],
 469                   (BoxType *) & Source->Element[Source->ElementN].Name[i],
 470                   (BoxType *) & Element->Name[i]);
 471   ELEMENTTEXT_LOOP (Element);
 472   {
 473     text->Element = Element;
 474   }
 475   END_LOOP;
 476   PIN_LOOP (Element);
 477   {
 478     pin->Element = Element;
 479   }
 480   END_LOOP;
 481   PAD_LOOP (Element);
 482   {
 483     pad->Element = Element;
 484   }
 485   END_LOOP;
 486   }
 487   memset (&Source->Element[Source->ElementN], 0, sizeof (ElementType));
 488   return (element);
 489 }
 490
 491 /* ---------------------------------------------------------------------------
 492  * calculates the bounding box of the buffer
 493  */
 494 void
 495 SetBufferBoundingBox (BufferTypePtr Buffer)
 496 {
 497   BoxTypePtr box = GetDataBoundingBox (Buffer->Data);
 498
 499   if (box)
 500     Buffer->BoundingBox = *box;
 501 }
 502
 503 /* ---------------------------------------------------------------------------
 504  * clears the contents of the paste buffer
 505  */
 506 void
 507 ClearBuffer (BufferTypePtr Buffer)
 508 {
 509   if (Buffer && Buffer->Data)
 510     {
 511       FreeDataMemory (Buffer->Data);
 512       Buffer->Data->pcb = PCB;
 513     }
 514 }
 515
 516 /* ----------------------------------------------------------------------
 517  * copies all selected and visible objects to the paste buffer
 518  * returns True if any objects have been removed
 519  */
 520 void
 521 AddSelectedToBuffer (BufferTypePtr Buffer, LocationType X, LocationType Y,
 522                      Boolean LeaveSelected)
 523 {
 524   /* switch crosshair off because adding objects to the pastebuffer
 525    * may change the 'valid' area for the cursor
 526    */
 527   if (!LeaveSelected)
 528     ExtraFlag = SELECTEDFLAG;
 529   HideCrosshair (True);
 530   Source = PCB->Data;
 531   Dest = Buffer->Data;
 532   SelectedOperation (&AddBufferFunctions, False, ALL_TYPES);
 533
 534   /* set origin to passed or current position */
 535   if (X || Y)
 536     {
 537       Buffer->X = X;
 538       Buffer->Y = Y;
 539     }
 540   else
 541     {
 542       Buffer->X = Crosshair.X;
 543       Buffer->Y = Crosshair.Y;
 544     }
 545   RestoreCrosshair (True);
 546   ExtraFlag = 0;
 547 }
 548
 549 /* ---------------------------------------------------------------------------
 550  * loads element data from file/library into buffer
 551  * parse the file with disabled 'PCB mode' (see parser)
 552  * returns False on error
 553  * if successful, update some other stuff and reposition the pastebuffer
 554  */
 555 Boolean
 556 LoadElementToBuffer (BufferTypePtr Buffer, char *Name, Boolean FromFile)
 557 {
 558   ElementTypePtr element;
 559
 560   ClearBuffer (Buffer);
 561   if (FromFile)
 562     {
 563       if (!ParseElementFile (Buffer->Data, Name))
 564         {
 565           if (Settings.ShowSolderSide)
 566             SwapBuffer (Buffer);
 567           SetBufferBoundingBox (Buffer);
 568           if (Buffer->Data->ElementN)
 569             {
 570               element = &(Buffer->Data->Element[0]);
 571               Buffer->X = element->MarkX;
 572               Buffer->Y = element->MarkY;
 573             }
 574           else
 575             {
 576               Buffer->X = 0;
 577               Buffer->Y = 0;
 578             }
 579           return (True);
 580         }
 581     }
 582   else
 583     {
 584       if (!ParseLibraryEntry (Buffer->Data, Name)
 585           && Buffer->Data->ElementN != 0)
 586         {
 587           element = &(Buffer->Data->Element[0]);
 588
 589           /* always add elements using top-side coordinates */
 590           if (Settings.ShowSolderSide)
 591             MirrorElementCoordinates (Buffer->Data, element, 0);
 592           SetElementBoundingBox (Buffer->Data, element, &PCB->Font);
 593
 594           /* set buffer offset to 'mark' position */
 595           Buffer->X = element->MarkX;
 596           Buffer->Y = element->MarkY;
 597           SetBufferBoundingBox (Buffer);
 598           return (True);
 599         }
 600     }
 601   /* release memory which might have been acquired */
 602   ClearBuffer (Buffer);
 603   return (False);
 604 }
 605
 606
 607 /*---------------------------------------------------------------------------
 608  * Searches for the given element by "footprint" name, and loads it
 609  * into the buffer.
 610  */
 611
 612 /* Figuring out which library entry is the one we want is a little
 613    tricky.  For file-based footprints, it's just a matter of finding
 614    the first match in the search list.  For m4-based footprints you
 615    need to know what magic to pass to the m4 functions.  Fortunately,
 616    the footprint needed is determined when we build the m4 libraries
 617    and stored as a comment in the description, so we can search for
 618    that to find the magic we need.  We use a hash to store the
 619    corresponding footprints and pointers to the library tree so we can
 620    quickly find the various bits we need to load a given
 621    footprint.  */
 622
 623 typedef struct {
 624   char *footprint;
 625   int footprint_allocated;
 626   int menu_idx;
 627   int entry_idx;
 628 } FootprintHashEntry;
 629
 630 static FootprintHashEntry *footprint_hash = 0;
 631 int footprint_hash_size = 0;
 632
 633 void
 634 clear_footprint_hash ()
 635 {
 636   int i;
 637   if (!footprint_hash)
 638     return;
 639   for (i=0; i<footprint_hash_size; i++)
 640     if (footprint_hash[i].footprint_allocated)
 641       free (footprint_hash[i].footprint);
 642   free (footprint_hash);
 643   footprint_hash = NULL;
 644   footprint_hash_size = 0;
 645 }
 646
 647 /* Used to sort footprint pointer entries.  Note we include the index
 648    numbers so that same-named footprints are sorted by the library
 649    search order.  */
 650 static int
 651 footprint_hash_cmp (const void *va, const void *vb)
 652 {
 653   int i;
 654   FootprintHashEntry *a = (FootprintHashEntry *)va;
 655   FootprintHashEntry *b = (FootprintHashEntry *)vb;
 656
 657   i = strcmp (a->footprint, b->footprint);
 658   if (i == 0)
 659     i = a->menu_idx - b->menu_idx;
 660   if (i == 0)
 661     i = a->entry_idx - b->entry_idx;
 662   return i;
 663 }
 664
 665 void
 666 make_footprint_hash ()
 667 {
 668   int i, j;
 669   char *fp;
 670   int num_entries = 0;
 671
 672   clear_footprint_hash ();
 673
 674   for (i=0; i<Library.MenuN; i++)
 675     for (j=0; j<Library.Menu[i].EntryN; j++)
 676       num_entries ++;
 677   footprint_hash = (FootprintHashEntry *)malloc (num_entries * sizeof(FootprintHashEntry));
 678   num_entries = 0;
 679
 680   /* There are two types of library entries.  The file-based types
 681      have a Template of (char *)-1 and the AllocatedMemory is the full
 682      path to the footprint file.  The m4 ones have the footprint name
 683      in brackets in the description.  */
 684   for (i=0; i<Library.MenuN; i++)
 685     {
 686 #ifdef DEBUG
 687   printf("In make_footprint_hash, looking for footprints in %s\n",
 688          Library.Menu[i].directory);
 689 #endif
 690
 691     for (j=0; j<Library.Menu[i].EntryN; j++)
 692         {
 693           footprint_hash[num_entries].menu_idx = i;
 694           footprint_hash[num_entries].entry_idx = j;
 695           if (Library.Menu[i].Entry[j].Template == (char *) -1)
 696           /* file */
 697             {
 698 #ifdef DEBUG
 699 /*            printf(" ... Examining file %s\n", Library.Menu[i].Entry[j].AllocatedMemory); */
 700 #endif
 701               fp = strrchr (Library.Menu[i].Entry[j].AllocatedMemory, '/');
 702
 703               if (!fp)
 704                 fp = strrchr (Library.Menu[i].Entry[j].AllocatedMemory, '\\');
 705
 706               if (fp)
 707                 fp ++;
 708               else
 709                 fp = Library.Menu[i].Entry[j].AllocatedMemory;
 710
 711 #ifdef DEBUG
 712 /*            printf(" ... found file footprint %s\n",  fp); */
 713 #endif
 714
 715               footprint_hash[num_entries].footprint = fp;
 716               footprint_hash[num_entries].footprint_allocated = 0;
 717             }
 718           else
 719           /* m4 */
 720             {
 721               fp = strrchr (Library.Menu[i].Entry[j].Description, '[');
 722               if (fp)
 723                 {
 724                   footprint_hash[num_entries].footprint = strdup (fp+1);
 725                   footprint_hash[num_entries].footprint_allocated = 1;
 726                   fp = strchr (footprint_hash[num_entries].footprint, ']');
 727                   if (fp)
 728                     *fp = 0;
 729                 }
 730               else
 731                 {
 732                   fp = Library.Menu[i].Entry[j].Description;
 733                   footprint_hash[num_entries].footprint = fp;
 734                   footprint_hash[num_entries].footprint_allocated = 0;
 735                 }
 736             }
 737           num_entries ++;
 738         }
 739     }
 740
 741   footprint_hash_size = num_entries;
 742   qsort (footprint_hash, num_entries, sizeof(footprint_hash[0]), footprint_hash_cmp);
 743 /*
 744 #ifdef DEBUG
 745   printf("       found footprints:  \n");
 746   for (i=0; i<num_entries; i++)
 747     printf("[%s]\n", footprint_hash[i].footprint);
 748 #endif
 749 */
 750 }
 751
 752 FootprintHashEntry *
 753 search_footprint_hash (const char *footprint)
 754 {
 755   int i, min, max, c;
 756
 757   /* Standard binary search */
 758
 759   min = -1;
 760   max = footprint_hash_size;
 761
 762   while (max - min > 1)
 763     {
 764       i = (min+max)/2;
 765       c = strcmp (footprint, footprint_hash[i].footprint);
 766       if (c < 0)
 767         max = i;
 768       else if (c > 0)
 769         min = i;
 770       else
 771         {
 772           /* We want to return the first match, not just any match.  */
 773           while (i > 0
 774                  && strcmp (footprint, footprint_hash[i-1].footprint) == 0)
 775             i--;
 776           return & footprint_hash[i];
 777         }
 778     }
 779   return NULL;
 780 }
 781
 782 /* Returns zero on success, non-zero on error.  */
 783 int
 784 LoadFootprintByName (BufferTypePtr Buffer, char *Footprint)
 785 {
 786   int i;
 787   FootprintHashEntry *fpe;
 788   LibraryMenuType *menu;
 789   LibraryEntryType *entry;
 790   char *with_fp = NULL;
 791
 792   if (!footprint_hash)
 793     make_footprint_hash ();
 794
 795   fpe = search_footprint_hash (Footprint);
 796   if (!fpe)
 797     {
 798       with_fp = Concat (Footprint, ".fp", NULL);
 799       fpe = search_footprint_hash (with_fp);
 800       if (fpe)
 801         Footprint = with_fp;
 802     }
 803   if (!fpe)
 804     {
 805       Message("Unable to load footprint %s\n", Footprint);
 806       return 1;
 807     }
 808
 809   menu = & Library.Menu[fpe->menu_idx];
 810   entry = & menu->Entry[fpe->entry_idx];
 811
 812   if (entry->Template == (char *) -1)
 813     {
 814       i = LoadElementToBuffer (Buffer, entry->AllocatedMemory, True);
 815       if (with_fp)
 816         free (with_fp);
 817       return i ? 0 : 1;
 818     }
 819   else
 820     {
 821       char *args;
 822
 823       args = Concat("'", EMPTY (entry->Template), "' '",
 824                     EMPTY (entry->Value), "' '", EMPTY (entry->Package), "'", NULL);
 825       i = LoadElementToBuffer (Buffer, args, False);
 826
 827       free (args);
 828       if (with_fp)
 829         free (with_fp);
 830       return i ? 0 : 1;
 831     }
 832
 833 #ifdef DEBUG
 834   {
 835     int j;
 836     printf("Library path: %s\n", Settings.LibraryPath);
 837     printf("Library tree: %s\n", Settings.LibraryTree);
 838
 839     printf("Library:\n");
 840     for (i=0; i<Library.MenuN; i++)
 841       {
 842         printf("  [%02d] Name: %s\n", i, Library.Menu[i].Name);
 843         printf("       Dir:  %s\n", Library.Menu[i].directory);
 844         printf("       Sty:  %s\n", Library.Menu[i].Style);
 845         for (j=0; j<Library.Menu[i].EntryN; j++)
 846           {
 847             printf("       [%02d] E: %s\n", j, Library.Menu[i].Entry[j].ListEntry);
 848             if (Library.Menu[i].Entry[j].Template == (char *) -1)
 849               printf("            A: %s\n", Library.Menu[i].Entry[j].AllocatedMemory);
 850             else
 851               {
 852                 printf("            T: %s\n", Library.Menu[i].Entry[j].Template);
 853                 printf("            P: %s\n", Library.Menu[i].Entry[j].Package);
 854                 printf("            V: %s\n", Library.Menu[i].Entry[j].Value);
 855                 printf("            D: %s\n", Library.Menu[i].Entry[j].Description);
 856               }
 857             if (j == 10)
 858               break;
 859           }
 860       }
 861   }
 862 #endif
 863 }
 864
 865
 866 static const char loadfootprint_syntax[] = "LoadFootprint(filename[,refdes,value])";
 867
 868 static const char loadfootprint_help[] = "Loads a single footprint by name";
 869
 870 /* %start-doc actions LoadFootprint
 871
 872 Loads a single footprint by name, rather than by reference or through
 873 the library.  If a refdes and value are specified, those are inserted
 874 into the footprint as well.  The footprint remains in the paste buffer.
 875
 876 %end-doc */
 877
 878 int
 879 LoadFootprint (int argc, char **argv, int x, int y)
 880 {
 881   char *name = ARG(0);
 882   char *refdes = ARG(1);
 883   char *value = ARG(2);
 884   ElementTypePtr e;
 885
 886   if (!name)
 887     AFAIL (loadfootprint);
 888
 889   if (LoadFootprintByName (PASTEBUFFER, name))
 890     return 1;
 891
 892   if (PASTEBUFFER->Data->ElementN == 0)
 893     {
 894       Message("Footprint %s contains no elements", name);
 895       return 1;
 896     }
 897   if (PASTEBUFFER->Data->ElementN > 1)
 898     {
 899       Message("Footprint %s contains multiple elements", name);
 900       return 1;
 901     }
 902
 903   e = & PASTEBUFFER->Data->Element[0];
 904
 905   if (e->Name[0].TextString)
 906     free (e->Name[0].TextString);
 907   e->Name[0].TextString = strdup (name);
 908
 909   if (e->Name[1].TextString)
 910     free (e->Name[1].TextString);
 911   e->Name[1].TextString = refdes ? strdup (refdes) : 0;
 912
 913   if (e->Name[2].TextString)
 914     free (e->Name[2].TextString);
 915   e->Name[2].TextString = value ? strdup (value) : 0;
 916
 917   return 0;
 918 }
 919
 920 /*---------------------------------------------------------------------------
 921  *
 922  * break buffer element into pieces
 923  */
 924 Boolean
 925 SmashBufferElement (BufferTypePtr Buffer)
 926 {
 927   ElementTypePtr element;
 928   Cardinal group;
 929   LayerTypePtr clayer, slayer;
 930
 931   if (Buffer->Data->ElementN != 1)
 932     {
 933       Message (_("Error!  Buffer doesn't contain a single element\n"));
 934       return (False);
 935     }
 936   element = &Buffer->Data->Element[0];
 937   Buffer->Data->ElementN = 0;
 938   ClearBuffer (Buffer);
 939   ELEMENTLINE_LOOP (element);
 940   {
 941     CreateNewLineOnLayer (&Buffer->Data->SILKLAYER,
 942                           line->Point1.X, line->Point1.Y,
 943                           line->Point2.X, line->Point2.Y,
 944                           line->Thickness, 0, NoFlags ());
 945     if (line)
 946       line->Number = MyStrdup (NAMEONPCB_NAME (element), "SmashBuffer");
 947   }
 948   END_LOOP;
 949   ARC_LOOP (element);
 950   {
 951     CreateNewArcOnLayer (&Buffer->Data->SILKLAYER,
 952                          arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle,
 953                          arc->Delta, arc->Thickness, 0, NoFlags ());
 954   }
 955   END_LOOP;
 956   PIN_LOOP (element);
 957   {
 958     FlagType f = NoFlags ();
 959     AddFlags (f, VIAFLAG);
 960     if (TEST_FLAG (HOLEFLAG, pin))
 961       AddFlags (f, HOLEFLAG);
 962
 963     CreateNewVia (Buffer->Data, pin->X, pin->Y,
 964                   pin->Thickness, pin->Clearance, pin->Mask,
 965                   pin->DrillingHole, pin->Number, f);
 966   }
 967   END_LOOP;
 968   group =
 969     GetLayerGroupNumberByNumber (max_layer +
 970                                  (SWAP_IDENT ? SOLDER_LAYER :
 971                                   COMPONENT_LAYER));
 972   clayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
 973   group =
 974     GetLayerGroupNumberByNumber (max_layer +
 975                                  (SWAP_IDENT ? COMPONENT_LAYER :
 976                                   SOLDER_LAYER));
 977   slayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
 978   PAD_LOOP (element);
 979   {
 980     LineTypePtr line;
 981     line = CreateNewLineOnLayer (TEST_FLAG (ONSOLDERFLAG, pad) ? slayer : clayer,
 982                                  pad->Point1.X, pad->Point1.Y,
 983                                  pad->Point2.X, pad->Point2.Y,
 984                                  pad->Thickness, pad->Clearance, NoFlags ());
 985     if (line)
 986       line->Number = MyStrdup (pad->Number, "SmashBuffer");
 987   }
 988   END_LOOP;
 989   FreeElementMemory (element);
 990   SaveFree (element);
 991   return (True);
 992 }
 993
 994 /*---------------------------------------------------------------------------
 995  *
 996  * see if a polygon is a rectangle.  If so, canonicalize it.
 997  */
 998
 999 static int
1000 polygon_is_rectangle (PolygonTypePtr poly)
1001 {
1002   int i, best;
1003   PointType temp[4];
1004   if (poly->PointN != 4)
1005     return 0;
1006   best = 0;
1007   for (i=1; i<4; i++)
1008     if (poly->Points[i].X < poly->Points[best].X
1009         || poly->Points[i].Y < poly->Points[best].Y)
1010       best = i;
1011   for (i=0; i<4; i++)
1012     temp[i] = poly->Points[(i+best)%4];
1013   if (temp[0].X == temp[1].X)
1014     memcpy (poly->Points, temp, sizeof(temp));
1015   else
1016     {
1017       /* reverse them */
1018       poly->Points[0] = temp[0];
1019       poly->Points[1] = temp[3];
1020       poly->Points[2] = temp[2];
1021       poly->Points[3] = temp[1];
1022     }
1023   if (poly->Points[0].X == poly->Points[1].X
1024       && poly->Points[1].Y == poly->Points[2].Y
1025       && poly->Points[2].X == poly->Points[3].X
1026       && poly->Points[3].Y == poly->Points[0].Y)
1027     return 1;
1028   return 0;
1029 }
1030
1031 /*---------------------------------------------------------------------------
1032  *
1033  * convert buffer contents into an element
1034  */
1035 Boolean
1036 ConvertBufferToElement (BufferTypePtr Buffer)
1037 {
1038   ElementTypePtr Element;
1039   Cardinal group;
1040   Cardinal pin_n = 1;
1041   Boolean hasParts = False, crooked = False;
1042
1043   if (Buffer->Data->pcb == 0)
1044     Buffer->Data->pcb = PCB;
1045
1046   Element = CreateNewElement (PCB->Data, NULL, &PCB->Font, NoFlags (),
1047                               NULL, NULL, NULL, PASTEBUFFER->X,
1048                               PASTEBUFFER->Y, 0, 100,
1049                               MakeFlags (SWAP_IDENT ? ONSOLDERFLAG : NOFLAG),
1050                               False);
1051   if (!Element)
1052     return (False);
1053   VIA_LOOP (Buffer->Data);
1054   {
1055     char num[8];
1056     if (via->Mask < via->Thickness)
1057       via->Mask = via->Thickness + 2 * MASKFRAME * 100; /* MASKFRAME is in mils */
1058     if (via->Name)
1059       CreateNewPin (Element, via->X, via->Y, via->Thickness,
1060                     via->Clearance, via->Mask, via->DrillingHole,
1061                     NULL, via->Name, MaskFlags (via->Flags,
1062                                                 VIAFLAG | FOUNDFLAG |
1063                                                 SELECTEDFLAG | WARNFLAG));
1064     else
1065       {
1066         sprintf (num, "%d", pin_n++);
1067         CreateNewPin (Element, via->X, via->Y, via->Thickness,
1068                       via->Clearance, via->Mask, via->DrillingHole,
1069                       NULL, num, MaskFlags (via->Flags,
1070                                             VIAFLAG | FOUNDFLAG | SELECTEDFLAG
1071                                             | WARNFLAG));
1072       }
1073     hasParts = True;
1074   }
1075   END_LOOP;
1076   /* get the component-side SM pads */
1077   group = GetLayerGroupNumberByNumber (max_layer +
1078                                        (SWAP_IDENT ? SOLDER_LAYER :
1079                                         COMPONENT_LAYER));
1080   GROUP_LOOP (Buffer->Data, group);
1081   {
1082     char num[8];
1083     LINE_LOOP (layer);
1084     {
1085       sprintf (num, "%d", pin_n++);
1086       CreateNewPad (Element, line->Point1.X,
1087                     line->Point1.Y, line->Point2.X,
1088                     line->Point2.Y, line->Thickness,
1089                     line->Clearance,
1090                     line->Thickness + line->Clearance, NULL,
1091                     line->Number ? line->Number : num,
1092                     MakeFlags (SWAP_IDENT ? ONSOLDERFLAG : NOFLAG));
1093       hasParts = True;
1094     }
1095     END_LOOP;
1096     POLYGON_LOOP (layer);
1097     {
1098       int x1, y1, x2, y2, w, h, t;
1099
1100       if (! polygon_is_rectangle (polygon))
1101         {
1102           crooked = True;
1103           continue;
1104         }
1105
1106       w = polygon->Points[2].X - polygon->Points[0].X;
1107       h = polygon->Points[1].Y - polygon->Points[0].Y;
1108       t = (w < h) ? w : h;
1109       x1 = polygon->Points[0].X + t/2;
1110       y1 = polygon->Points[0].Y + t/2;
1111       x2 = x1 + (w-t);
1112       y2 = y1 + (h-t);
1113
1114       sprintf (num, "%d", pin_n++);
1115       CreateNewPad (Element,
1116                     x1, y1, x2, y2, t,
1117                     2 * Settings.Keepaway,
1118                     t + Settings.Keepaway,
1119                     NULL, num,
1120                     MakeFlags (SQUAREFLAG | (SWAP_IDENT ? ONSOLDERFLAG : NOFLAG)));
1121       hasParts = True;
1122     }
1123     END_LOOP;
1124   }
1125   END_LOOP;
1126   /* now get the opposite side pads */
1127   group = GetLayerGroupNumberByNumber (max_layer +
1128                                        (SWAP_IDENT ? COMPONENT_LAYER :
1129                                         SOLDER_LAYER));
1130   GROUP_LOOP (Buffer->Data, group);
1131   {
1132     Boolean warned = False;
1133     char num[8];
1134     LINE_LOOP (layer);
1135     {
1136       sprintf (num, "%d", pin_n++);
1137       CreateNewPad (Element, line->Point1.X,
1138                     line->Point1.Y, line->Point2.X,
1139                     line->Point2.Y, line->Thickness,
1140                     line->Clearance,
1141                     line->Thickness + line->Clearance, NULL,
1142                     line->Number ? line->Number : num,
1143                     MakeFlags (SWAP_IDENT ? NOFLAG : ONSOLDERFLAG));
1144       if (!hasParts && !warned)
1145         {
1146           warned = True;
1147           Message
1148             (_("Warning: All of the pads are on the opposite\n"
1149                "side from the component - that's probably not what\n"
1150                "you wanted\n"));
1151         }
1152       hasParts = True;
1153     }
1154     END_LOOP;
1155   }
1156   END_LOOP;
1157   /* now add the silkscreen. NOTE: elements must have pads or pins too */
1158   LINE_LOOP (&Buffer->Data->SILKLAYER);
1159   {
1160     if (line->Number && !NAMEONPCB_NAME (Element))
1161       NAMEONPCB_NAME (Element) = MyStrdup (line->Number,
1162                                            "ConvertBufferToElement");
1163     CreateNewLineInElement (Element, line->Point1.X,
1164                             line->Point1.Y, line->Point2.X,
1165                             line->Point2.Y, line->Thickness);
1166     hasParts = True;
1167   }
1168   END_LOOP;
1169   ARC_LOOP (&Buffer->Data->SILKLAYER);
1170   {
1171     CreateNewArcInElement (Element, arc->X, arc->Y, arc->Width,
1172                            arc->Height, arc->StartAngle, arc->Delta,
1173                            arc->Thickness);
1174     hasParts = True;
1175   }
1176   END_LOOP;
1177   if (!hasParts)
1178     {
1179       DestroyObject (PCB->Data, ELEMENT_TYPE, Element, Element, Element);
1180       Message (_("There was nothing to convert!\n"
1181                  "Elements must have some silk, pads or pins.\n"));
1182       return (False);
1183     }
1184   if (crooked)
1185      Message (_("There were polygons that can't be made into pins!\n"
1186                 "So they were not included in the element\n"));
1187   Element->MarkX = Buffer->X;
1188   Element->MarkY = Buffer->Y;
1189   if (SWAP_IDENT)
1190     SET_FLAG (ONSOLDERFLAG, Element);
1191   SetElementBoundingBox (PCB->Data, Element, &PCB->Font);
1192   ClearBuffer (Buffer);
1193   MoveObjectToBuffer (Buffer->Data, PCB->Data, ELEMENT_TYPE, Element, Element,
1194                       Element);
1195   SetBufferBoundingBox (Buffer);
1196   return (True);
1197 }
1198
1199 /* ---------------------------------------------------------------------------
1200  * load PCB into buffer
1201  * parse the file with enabled 'PCB mode' (see parser)
1202  * if successful, update some other stuff
1203  */
1204 Boolean
1205 LoadLayoutToBuffer (BufferTypePtr Buffer, char *Filename)
1206 {
1207   PCBTypePtr newPCB = CreateNewPCB (False);
1208
1209   /* new data isn't added to the undo list */
1210   if (!ParsePCB (newPCB, Filename))
1211     {
1212       /* clear data area and replace pointer */
1213       ClearBuffer (Buffer);
1214       SaveFree (Buffer->Data);
1215       Buffer->Data = newPCB->Data;
1216       newPCB->Data = NULL;
1217       Buffer->X = newPCB->CursorX;
1218       Buffer->Y = newPCB->CursorY;
1219       RemovePCB (newPCB);
1220       Buffer->Data->pcb = PCB;
1221       return (True);
1222     }
1223
1224   /* release unused memory */
1225   RemovePCB (newPCB);
1226       Buffer->Data->pcb = PCB;
1227   return (False);
1228 }
1229
1230 /* ---------------------------------------------------------------------------
1231  * rotates the contents of the pastebuffer
1232  */
1233 void
1234 RotateBuffer (BufferTypePtr Buffer, BYTE Number)
1235 {
1236   /* rotate vias */
1237   VIA_LOOP (Buffer->Data);
1238   {
1239     r_delete_entry (Buffer->Data->via_tree, (BoxTypePtr) via);
1240     ROTATE_VIA_LOWLEVEL (via, Buffer->X, Buffer->Y, Number);
1241     SetPinBoundingBox (via);
1242     r_insert_entry (Buffer->Data->via_tree, (BoxTypePtr) via, 0);
1243   }
1244   END_LOOP;
1245
1246   /* elements */
1247   ELEMENT_LOOP (Buffer->Data);
1248   {
1249     RotateElementLowLevel (Buffer->Data, element, Buffer->X, Buffer->Y,
1250                            Number);
1251   }
1252   END_LOOP;
1253
1254   /* all layer related objects */
1255   ALLLINE_LOOP (Buffer->Data);
1256   {
1257     r_delete_entry (layer->line_tree, (BoxTypePtr) line);
1258     RotateLineLowLevel (line, Buffer->X, Buffer->Y, Number);
1259     r_insert_entry (layer->line_tree, (BoxTypePtr) line, 0);
1260   }
1261   ENDALL_LOOP;
1262   ALLARC_LOOP (Buffer->Data);
1263   {
1264     r_delete_entry (layer->arc_tree, (BoxTypePtr) arc);
1265     RotateArcLowLevel (arc, Buffer->X, Buffer->Y, Number);
1266     r_insert_entry (layer->arc_tree, (BoxTypePtr) arc, 0);
1267   }
1268   ENDALL_LOOP;
1269   ALLTEXT_LOOP (Buffer->Data);
1270   {
1271     r_delete_entry (layer->text_tree, (BoxTypePtr) text);
1272     RotateTextLowLevel (text, Buffer->X, Buffer->Y, Number);
1273     r_insert_entry (layer->text_tree, (BoxTypePtr) text, 0);
1274   }
1275   ENDALL_LOOP;
1276   ALLPOLYGON_LOOP (Buffer->Data);
1277   {
1278     r_delete_entry (layer->polygon_tree, (BoxTypePtr) polygon);
1279     RotatePolygonLowLevel (polygon, Buffer->X, Buffer->Y, Number);
1280     r_insert_entry (layer->polygon_tree, (BoxTypePtr) polygon, 0);
1281   }
1282   ENDALL_LOOP;
1283
1284   /* finally the origin and the bounding box */
1285   ROTATE (Buffer->X, Buffer->Y, Buffer->X, Buffer->Y, Number);
1286   RotateBoxLowLevel (&Buffer->BoundingBox, Buffer->X, Buffer->Y, Number);
1287 }
1288
1289 static void
1290 free_rotate (int *x, int *y, int cx, int cy, double cosa, double sina)
1291 {
1292   double nx, ny;
1293   int px = *x - cx;
1294   int py = *y - cy;
1295
1296   nx = px * cosa + py * sina;
1297   ny = py * cosa - px * sina;
1298
1299   *x = nx + cx;
1300   *y = ny + cy;
1301 }
1302
1303 void
1304 FreeRotateElementLowLevel (DataTypePtr Data, ElementTypePtr Element,
1305                            LocationType X, LocationType Y,
1306                            double cosa, double sina, double Angle)
1307 {
1308   /* solder side objects need a different orientation */
1309
1310   /* the text subroutine decides by itself if the direction
1311    * is to be corrected
1312    */
1313 #if 0
1314   ELEMENTTEXT_LOOP (Element);
1315   {
1316     if (Data && Data->name_tree[n])
1317       r_delete_entry (Data->name_tree[n], (BoxType *) text);
1318     RotateTextLowLevel (text, X, Y, Number);
1319   }
1320   END_LOOP;
1321 #endif
1322   ELEMENTLINE_LOOP (Element);
1323   {
1324     free_rotate (&line->Point1.X, &line->Point1.Y, X, Y, cosa, sina);
1325     free_rotate (&line->Point2.X, &line->Point2.Y, X, Y, cosa, sina);
1326     SetLineBoundingBox (line);
1327   }
1328   END_LOOP;
1329   PIN_LOOP (Element);
1330   {
1331     /* pre-delete the pins from the pin-tree before their coordinates change */
1332     if (Data)
1333       r_delete_entry (Data->pin_tree, (BoxType *) pin);
1334     RestoreToPolygon (Data, PIN_TYPE, Element, pin);
1335     free_rotate (&pin->X, &pin->Y, X, Y, cosa, sina);
1336     SetPinBoundingBox (pin);
1337   }
1338   END_LOOP;
1339   PAD_LOOP (Element);
1340   {
1341     /* pre-delete the pads before their coordinates change */
1342     if (Data)
1343       r_delete_entry (Data->pad_tree, (BoxType *) pad);
1344     RestoreToPolygon (Data, PAD_TYPE, Element, pad);
1345     free_rotate (&pad->Point1.X, &pad->Point1.Y, X, Y, cosa, sina);
1346     free_rotate (&pad->Point2.X, &pad->Point2.Y, X, Y, cosa, sina);
1347     SetLineBoundingBox ((LineType *) pad);
1348   }
1349   END_LOOP;
1350   ARC_LOOP (Element);
1351   {
1352     free_rotate (&arc->X, &arc->Y, X, Y, cosa, sina);
1353     arc->StartAngle += Angle;
1354     arc->StartAngle %= 360;
1355   }
1356   END_LOOP;
1357
1358   free_rotate (&Element->MarkX, &Element->MarkY, X, Y, cosa, sina);
1359   SetElementBoundingBox (Data, Element, &PCB->Font);
1360   ClearFromPolygon (Data, ELEMENT_TYPE, Element, Element);
1361 }
1362
1363 void
1364 FreeRotateBuffer (BufferTypePtr Buffer, double Angle)
1365 {
1366   double cosa, sina;
1367
1368   cosa = cos(Angle * M_PI/180.0);
1369   sina = sin(Angle * M_PI/180.0);
1370
1371   /* rotate vias */
1372   VIA_LOOP (Buffer->Data);
1373   {
1374     r_delete_entry (Buffer->Data->via_tree, (BoxTypePtr) via);
1375     free_rotate (&via->X, &via->Y, Buffer->X, Buffer->Y, cosa, sina);
1376     SetPinBoundingBox (via);
1377     r_insert_entry (Buffer->Data->via_tree, (BoxTypePtr) via, 0);
1378   }
1379   END_LOOP;
1380
1381   /* elements */
1382   ELEMENT_LOOP (Buffer->Data);
1383   {
1384     FreeRotateElementLowLevel (Buffer->Data, element, Buffer->X, Buffer->Y,
1385                                cosa, sina, Angle);
1386   }
1387   END_LOOP;
1388
1389   /* all layer related objects */
1390   ALLLINE_LOOP (Buffer->Data);
1391   {
1392     r_delete_entry (layer->line_tree, (BoxTypePtr) line);
1393     free_rotate (&line->Point1.X, &line->Point1.Y, Buffer->X, Buffer->Y, cosa, sina);
1394     free_rotate (&line->Point2.X, &line->Point2.Y, Buffer->X, Buffer->Y, cosa, sina);
1395     SetLineBoundingBox (line);
1396     r_insert_entry (layer->line_tree, (BoxTypePtr) line, 0);
1397   }
1398   ENDALL_LOOP;
1399   ALLARC_LOOP (Buffer->Data);
1400   {
1401     r_delete_entry (layer->arc_tree, (BoxTypePtr) arc);
1402     free_rotate (&arc->X, &arc->Y, Buffer->X, Buffer->Y, cosa, sina);
1403     arc->StartAngle += Angle;
1404     arc->StartAngle %= 360;
1405     r_insert_entry (layer->arc_tree, (BoxTypePtr) arc, 0);
1406   }
1407   ENDALL_LOOP;
1408   /* FIXME: rotate text */
1409   ALLPOLYGON_LOOP (Buffer->Data);
1410   {
1411     r_delete_entry (layer->polygon_tree, (BoxTypePtr) polygon);
1412     POLYGONPOINT_LOOP (polygon);
1413     {
1414       free_rotate (&point->X, &point->Y, Buffer->X, Buffer->Y, cosa, sina);
1415     }
1416     END_LOOP;
1417     SetPolygonBoundingBox (polygon);
1418     r_insert_entry (layer->polygon_tree, (BoxTypePtr) polygon, 0);
1419   }
1420   ENDALL_LOOP;
1421
1422   SetBufferBoundingBox (Buffer);
1423 }
1424
1425
1426 /* -------------------------------------------------------------------------- */
1427
1428 static const char freerotatebuffer_syntax[] =
1429   "FreeRotateBuffer(Angle)";
1430
1431 static const char freerotatebuffer_help[] =
1432   "Rotates the current paste buffer contents by the specified angle.  The\n"
1433   "angle is given in degrees.\n";
1434
1435 /* %start-doc actions FreeRotateBuffer
1436
1437 Rotates the contents of the pastebuffer by an arbitrary angle.
1438 %end-doc */
1439
1440 int
1441 ActionFreeRotateBuffer(int argc, char **argv, int x, int y)
1442 {
1443   HideCrosshair(False);
1444   FreeRotateBuffer(PASTEBUFFER, strtod(argv[0], 0));
1445   RestoreCrosshair(False);
1446   return 0;
1447 }
1448
1449 /* ---------------------------------------------------------------------------
1450  * initializes the buffers by allocating memory
1451  */
1452 void
1453 InitBuffers (void)
1454 {
1455   int i;
1456
1457   for (i = 0; i < MAX_BUFFER; i++)
1458     Buffers[i].Data = CreateNewBuffer ();
1459 }
1460
1461 void
1462 SwapBuffers (void)
1463 {
1464   int i;
1465
1466   for (i = 0; i < MAX_BUFFER; i++)
1467     SwapBuffer (&Buffers[i]);
1468   SetCrosshairRangeToBuffer ();
1469 }
1470
1471 void
1472 MirrorBuffer (BufferTypePtr Buffer)
1473 {
1474   int i;
1475
1476   if (Buffer->Data->ElementN)
1477     {
1478       Message (_("You can't mirror a buffer that has elements!\n"));
1479       return;
1480     }
1481   for (i = 0; i < max_layer + 2; i++)
1482     {
1483       LayerTypePtr layer = Buffer->Data->Layer + i;
1484       if (layer->TextN)
1485         {
1486           Message (_("You can't mirror a buffer that has text!\n"));
1487           return;
1488         }
1489     }
1490   /* set buffer offset to 'mark' position */
1491   Buffer->X = SWAP_X (Buffer->X);
1492   Buffer->Y = SWAP_Y (Buffer->Y);
1493   VIA_LOOP (Buffer->Data);
1494   {
1495     via->X = SWAP_X (via->X);
1496     via->Y = SWAP_Y (via->Y);
1497   }
1498   END_LOOP;
1499   ALLLINE_LOOP (Buffer->Data);
1500   {
1501     line->Point1.X = SWAP_X (line->Point1.X);
1502     line->Point1.Y = SWAP_Y (line->Point1.Y);
1503     line->Point2.X = SWAP_X (line->Point2.X);
1504     line->Point2.Y = SWAP_Y (line->Point2.Y);
1505   }
1506   ENDALL_LOOP;
1507   ALLARC_LOOP (Buffer->Data);
1508   {
1509     arc->X = SWAP_X (arc->X);
1510     arc->Y = SWAP_Y (arc->Y);
1511     arc->StartAngle = SWAP_ANGLE (arc->StartAngle);
1512     arc->Delta = SWAP_DELTA (arc->Delta);
1513     SetArcBoundingBox (arc);
1514   }
1515   ENDALL_LOOP;
1516   ALLPOLYGON_LOOP (Buffer->Data);
1517   {
1518     POLYGONPOINT_LOOP (polygon);
1519     {
1520       point->X = SWAP_X (point->X);
1521       point->Y = SWAP_Y (point->Y);
1522     }
1523     END_LOOP;
1524     SetPolygonBoundingBox (polygon);
1525   }
1526   ENDALL_LOOP;
1527   SetBufferBoundingBox (Buffer);
1528 }
1529
1530
1531 /* ---------------------------------------------------------------------------
1532  * flip components/tracks from one side to the other
1533  */
1534 static void
1535 SwapBuffer (BufferTypePtr Buffer)
1536 {
1537   int j, k;
1538   Cardinal sgroup, cgroup;
1539   LayerType swap;
1540
1541   ELEMENT_LOOP (Buffer->Data);
1542   {
1543     r_delete_element (Buffer->Data, element);
1544     MirrorElementCoordinates (Buffer->Data, element, 0);
1545   }
1546   END_LOOP;
1547   /* set buffer offset to 'mark' position */
1548   Buffer->X = SWAP_X (Buffer->X);
1549   Buffer->Y = SWAP_Y (Buffer->Y);
1550   VIA_LOOP (Buffer->Data);
1551   {
1552     r_delete_entry (Buffer->Data->via_tree, (BoxTypePtr) via);
1553     via->X = SWAP_X (via->X);
1554     via->Y = SWAP_Y (via->Y);
1555     SetPinBoundingBox (via);
1556     r_insert_entry (Buffer->Data->via_tree, (BoxTypePtr) via, 0);
1557   }
1558   END_LOOP;
1559   ALLLINE_LOOP (Buffer->Data);
1560   {
1561     r_delete_entry (layer->line_tree, (BoxTypePtr) line);
1562     line->Point1.X = SWAP_X (line->Point1.X);
1563     line->Point1.Y = SWAP_Y (line->Point1.Y);
1564     line->Point2.X = SWAP_X (line->Point2.X);
1565     line->Point2.Y = SWAP_Y (line->Point2.Y);
1566     SetLineBoundingBox (line);
1567     r_insert_entry (layer->line_tree, (BoxTypePtr) line, 0);
1568   }
1569   ENDALL_LOOP;
1570   ALLARC_LOOP (Buffer->Data);
1571   {
1572     r_delete_entry (layer->arc_tree, (BoxTypePtr) arc);
1573     arc->X = SWAP_X (arc->X);
1574     arc->Y = SWAP_Y (arc->Y);
1575     arc->StartAngle = SWAP_ANGLE (arc->StartAngle);
1576     arc->Delta = SWAP_DELTA (arc->Delta);
1577     SetArcBoundingBox (arc);
1578     r_insert_entry (layer->arc_tree, (BoxTypePtr) arc, 0);
1579   }
1580   ENDALL_LOOP;
1581   ALLPOLYGON_LOOP (Buffer->Data);
1582   {
1583     r_delete_entry (layer->polygon_tree, (BoxTypePtr) polygon);
1584     POLYGONPOINT_LOOP (polygon);
1585     {
1586       point->X = SWAP_X (point->X);
1587       point->Y = SWAP_Y (point->Y);
1588     }
1589     END_LOOP;
1590     SetPolygonBoundingBox (polygon);
1591     r_insert_entry (layer->polygon_tree, (BoxTypePtr) polygon, 0);
1592     /* hmmm, how to handle clip */
1593   }
1594   ENDALL_LOOP;
1595   ALLTEXT_LOOP (Buffer->Data);
1596   {
1597     r_delete_entry (layer->text_tree, (BoxTypePtr) text);
1598     text->X = SWAP_X (text->X);
1599     text->Y = SWAP_Y (text->Y);
1600     TOGGLE_FLAG (ONSOLDERFLAG, text);
1601     SetTextBoundingBox (&PCB->Font, text);
1602     r_insert_entry (layer->text_tree, (BoxTypePtr) text, 0);
1603   }
1604   ENDALL_LOOP;
1605   /* swap silkscreen layers */
1606   swap = Buffer->Data->Layer[max_layer + SOLDER_LAYER];
1607   Buffer->Data->Layer[max_layer + SOLDER_LAYER] =
1608     Buffer->Data->Layer[max_layer + COMPONENT_LAYER];
1609   Buffer->Data->Layer[max_layer + COMPONENT_LAYER] = swap;
1610
1611   /* swap layer groups when balanced */
1612   sgroup = GetLayerGroupNumberByNumber (max_layer + SOLDER_LAYER);
1613   cgroup = GetLayerGroupNumberByNumber (max_layer + COMPONENT_LAYER);
1614   if (PCB->LayerGroups.Number[cgroup] == PCB->LayerGroups.Number[sgroup])
1615     {
1616       for (j = k = 0; j < PCB->LayerGroups.Number[sgroup]; j++)
1617         {
1618           int t1, t2;
1619           Cardinal cnumber = PCB->LayerGroups.Entries[cgroup][k];
1620           Cardinal snumber = PCB->LayerGroups.Entries[sgroup][j];
1621
1622           if (snumber >= max_layer)
1623             continue;
1624           swap = Buffer->Data->Layer[snumber];
1625
1626           while (cnumber >= max_layer)
1627             {
1628               k++;
1629               cnumber = PCB->LayerGroups.Entries[cgroup][k];
1630             }
1631           Buffer->Data->Layer[snumber] = Buffer->Data->Layer[cnumber];
1632           Buffer->Data->Layer[cnumber] = swap;
1633           k++;
1634           /* move the thermal flags with the layers */
1635           ALLPIN_LOOP (Buffer->Data);
1636           {
1637             t1 = TEST_THERM (snumber, pin);
1638             t2 = TEST_THERM (cnumber, pin);
1639             ASSIGN_THERM (snumber, t2, pin);
1640             ASSIGN_THERM (cnumber, t1, pin);
1641           }
1642           ENDALL_LOOP;
1643           VIA_LOOP (Buffer->Data);
1644           {
1645             t1 = TEST_THERM (snumber, via);
1646             t2 = TEST_THERM (cnumber, via);
1647             ASSIGN_THERM (snumber, t2, via);
1648             ASSIGN_THERM (cnumber, t1, via);
1649           }
1650           END_LOOP;
1651         }
1652     }
1653   SetBufferBoundingBox (Buffer);
1654 }
1655
1656 /* ----------------------------------------------------------------------
1657  * moves the passed object to the passed buffer and removes it
1658  * from its original place
1659  */
1660 void *
1661 MoveObjectToBuffer (DataTypePtr Destination, DataTypePtr Src,
1662                     int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1663 {
1664   /* setup local identifiers used by move operations */
1665   Dest = Destination;
1666   Source = Src;
1667   return (ObjectOperation (&MoveBufferFunctions, Type, Ptr1, Ptr2, Ptr3));
1668 }
1669
1670 /* ----------------------------------------------------------------------
1671  * Adds the passed object to the passed buffer
1672  */
1673 void *
1674 CopyObjectToBuffer (DataTypePtr Destination, DataTypePtr Src,
1675                     int Type, void *Ptr1, void *Ptr2, void *Ptr3)
1676 {
1677   /* setup local identifiers used by Add operations */
1678   Dest = Destination;
1679   Source = Src;
1680   return (ObjectOperation (&AddBufferFunctions, Type, Ptr1, Ptr2, Ptr3));
1681 }
1682
1683 /* ---------------------------------------------------------------------- */
1684
1685 HID_Action rotate_action_list[] = {
1686   {"FreeRotateBuffer", 0, ActionFreeRotateBuffer,
1687    freerotatebuffer_syntax, freerotatebuffer_help},
1688   {"LoadFootprint", 0, LoadFootprint,
1689    0,0}
1690 };
1691
1692 REGISTER_ACTIONS (rotate_action_list)