src/copy.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 copy pins, elements ...
  30  * it's necessary to copy data by calling create... since the base pointer
  31  * may change cause of dynamic memory allocation
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <stdlib.h>
  39
  40 #include "global.h"
  41
  42 #include "copy.h"
  43 #include "create.h"
  44 #include "data.h"
  45 #include "draw.h"
  46 #include "mymem.h"
  47 #include "mirror.h"
  48 #include "misc.h"
  49 #include "move.h"
  50 #include "polygon.h"
  51 #include "rats.h"
  52 #include "rtree.h"
  53 #include "select.h"
  54 #include "undo.h"
  55
  56 #ifdef HAVE_LIBDMALLOC
  57 #include <dmalloc.h>
  58 #endif
  59
  60 RCSID ("$Id$");
  61
  62 /* ---------------------------------------------------------------------------
  63  * some local prototypes
  64  */
  65 static void *CopyVia (PinTypePtr);
  66 static void *CopyLine (LayerTypePtr, LineTypePtr);
  67 static void *CopyArc (LayerTypePtr, ArcTypePtr);
  68 static void *CopyText (LayerTypePtr, TextTypePtr);
  69 static void *CopyPolygon (LayerTypePtr, PolygonTypePtr);
  70 static void *CopyElement (ElementTypePtr);
  71
  72 /* ---------------------------------------------------------------------------
  73  * some local identifiers
  74  */
  75 static LocationType DeltaX, DeltaY;     /* movement vector */
  76 static ObjectFunctionType CopyFunctions = {
  77   CopyLine,
  78   CopyText,
  79   CopyPolygon,
  80   CopyVia,
  81   CopyElement,
  82   NULL,
  83   NULL,
  84   NULL,
  85   NULL,
  86   NULL,
  87   CopyArc,
  88   NULL
  89 };
  90
  91 /* ---------------------------------------------------------------------------
  92  * copies data from one polygon to another
  93  * 'Dest' has to exist
  94  */
  95 PolygonTypePtr
  96 CopyPolygonLowLevel (PolygonTypePtr Dest, PolygonTypePtr Src)
  97 {
  98   Cardinal hole = 0;
  99   Cardinal n;
 100
 101   for (n = 0; n < Src->PointN; n++)
 102     {
 103       if (hole < Src->HoleIndexN && n == Src->HoleIndex[hole])
 104         {
 105           CreateNewHoleInPolygon (Dest);
 106           hole++;
 107         }
 108       CreateNewPointInPolygon (Dest, Src->Points[n].X, Src->Points[n].Y);
 109     }
 110   SetPolygonBoundingBox (Dest);
 111   Dest->Flags = Src->Flags;
 112   CLEAR_FLAG (FOUNDFLAG, Dest);
 113   return (Dest);
 114 }
 115
 116 /* ---------------------------------------------------------------------------
 117  * copies data from one element to another and creates the destination
 118  * if necessary
 119  */
 120 ElementTypePtr
 121 CopyElementLowLevel (DataTypePtr Data, ElementTypePtr Dest,
 122                      ElementTypePtr Src, bool uniqueName, LocationType dx,
 123                      LocationType dy)
 124 {
 125   int i;
 126   /* release old memory if necessary */
 127   if (Dest)
 128     FreeElementMemory (Dest);
 129
 130   /* both coordinates and flags are the same */
 131   Dest = CreateNewElement (Data, Dest, &PCB->Font,
 132                            MaskFlags (Src->Flags, FOUNDFLAG),
 133                            DESCRIPTION_NAME (Src), NAMEONPCB_NAME (Src),
 134                            VALUE_NAME (Src), DESCRIPTION_TEXT (Src).X + dx,
 135                            DESCRIPTION_TEXT (Src).Y + dy,
 136                            DESCRIPTION_TEXT (Src).Direction,
 137                            DESCRIPTION_TEXT (Src).Scale,
 138                            MaskFlags (DESCRIPTION_TEXT (Src).Flags,
 139                                       FOUNDFLAG), uniqueName);
 140
 141   /* abort on error */
 142   if (!Dest)
 143     return (Dest);
 144
 145   ELEMENTLINE_LOOP (Src);
 146   {
 147     CreateNewLineInElement (Dest, line->Point1.X + dx,
 148                             line->Point1.Y + dy, line->Point2.X + dx,
 149                             line->Point2.Y + dy, line->Thickness);
 150   }
 151   END_LOOP;
 152   PIN_LOOP (Src);
 153   {
 154     CreateNewPin (Dest, pin->X + dx, pin->Y + dy, pin->Thickness,
 155                   pin->Clearance, pin->Mask, pin->DrillingHole,
 156                   pin->Name, pin->Number, MaskFlags (pin->Flags, FOUNDFLAG));
 157   }
 158   END_LOOP;
 159   PAD_LOOP (Src);
 160   {
 161     CreateNewPad (Dest, pad->Point1.X + dx, pad->Point1.Y + dy,
 162                   pad->Point2.X + dx, pad->Point2.Y + dy, pad->Thickness,
 163                   pad->Clearance, pad->Mask, pad->Name, pad->Number,
 164                   MaskFlags (pad->Flags, FOUNDFLAG));
 165   }
 166   END_LOOP;
 167   ARC_LOOP (Src);
 168   {
 169     CreateNewArcInElement (Dest, arc->X + dx, arc->Y + dy, arc->Width,
 170                            arc->Height, arc->StartAngle, arc->Delta,
 171                            arc->Thickness);
 172   }
 173   END_LOOP;
 174
 175   for (i=0; i<Src->Attributes.Number; i++)
 176     CreateNewAttribute (& Dest->Attributes,
 177                         Src->Attributes.List[i].name,
 178                         Src->Attributes.List[i].value);
 179
 180   Dest->MarkX = Src->MarkX + dx;
 181   Dest->MarkY = Src->MarkY + dy;
 182
 183   SetElementBoundingBox (Data, Dest, &PCB->Font);
 184   return (Dest);
 185 }
 186
 187 /* ---------------------------------------------------------------------------
 188  * copies a via
 189  */
 190 static void *
 191 CopyVia (PinTypePtr Via)
 192 {
 193   PinTypePtr via;
 194
 195   via = CreateNewVia (PCB->Data, Via->X + DeltaX, Via->Y + DeltaY,
 196                       Via->Thickness, Via->Clearance, Via->Mask,
 197                       Via->DrillingHole, Via->Name,
 198                       MaskFlags (Via->Flags, FOUNDFLAG));
 199   if (!via)
 200     return (via);
 201   DrawVia (via, 0);
 202   AddObjectToCreateUndoList (VIA_TYPE, via, via, via);
 203   return (via);
 204 }
 205
 206 /* ---------------------------------------------------------------------------
 207  * copies a line
 208  */
 209 static void *
 210 CopyLine (LayerTypePtr Layer, LineTypePtr Line)
 211 {
 212   LineTypePtr line;
 213
 214   line = CreateDrawnLineOnLayer (Layer, Line->Point1.X + DeltaX,
 215                                  Line->Point1.Y + DeltaY,
 216                                  Line->Point2.X + DeltaX,
 217                                  Line->Point2.Y + DeltaY, Line->Thickness,
 218                                  Line->Clearance,
 219                                  MaskFlags (Line->Flags, FOUNDFLAG));
 220   if (!line)
 221     return (line);
 222   if (Line->Number)
 223     line->Number = strdup (Line->Number);
 224   DrawLine (Layer, line, 0);
 225   AddObjectToCreateUndoList (LINE_TYPE, Layer, line, line);
 226   return (line);
 227 }
 228
 229 /* ---------------------------------------------------------------------------
 230  * copies an arc
 231  */
 232 static void *
 233 CopyArc (LayerTypePtr Layer, ArcTypePtr Arc)
 234 {
 235   ArcTypePtr arc;
 236
 237   arc = CreateNewArcOnLayer (Layer, Arc->X + DeltaX,
 238                              Arc->Y + DeltaY, Arc->Width, Arc->Height, Arc->StartAngle,
 239                              Arc->Delta, Arc->Thickness, Arc->Clearance,
 240                              MaskFlags (Arc->Flags, FOUNDFLAG));
 241   if (!arc)
 242     return (arc);
 243   DrawArc (Layer, arc, 0);
 244   AddObjectToCreateUndoList (ARC_TYPE, Layer, arc, arc);
 245   return (arc);
 246 }
 247
 248 /* ---------------------------------------------------------------------------
 249  * copies a text
 250  */
 251 static void *
 252 CopyText (LayerTypePtr Layer, TextTypePtr Text)
 253 {
 254   TextTypePtr text;
 255
 256   text = CreateNewText (Layer, &PCB->Font, Text->X + DeltaX,
 257                         Text->Y + DeltaY, Text->Direction,
 258                         Text->Scale, Text->TextString,
 259                         MaskFlags (Text->Flags, FOUNDFLAG));
 260   DrawText (Layer, text, 0);
 261   AddObjectToCreateUndoList (TEXT_TYPE, Layer, text, text);
 262   return (text);
 263 }
 264
 265 /* ---------------------------------------------------------------------------
 266  * copies a polygon
 267  */
 268 static void *
 269 CopyPolygon (LayerTypePtr Layer, PolygonTypePtr Polygon)
 270 {
 271   PolygonTypePtr polygon;
 272
 273   polygon = CreateNewPolygon (Layer, NoFlags ());
 274   CopyPolygonLowLevel (polygon, Polygon);
 275   MovePolygonLowLevel (polygon, DeltaX, DeltaY);
 276   if (!Layer->polygon_tree)
 277     Layer->polygon_tree = r_create_tree (NULL, 0, 0);
 278   r_insert_entry (Layer->polygon_tree, (BoxTypePtr) polygon, 0);
 279   InitClip (PCB->Data, Layer, polygon);
 280   DrawPolygon (Layer, polygon, 0);
 281   AddObjectToCreateUndoList (POLYGON_TYPE, Layer, polygon, polygon);
 282   return (polygon);
 283 }
 284
 285 /* ---------------------------------------------------------------------------
 286  * copies an element onto the PCB.  Then does a draw.
 287  */
 288 static void *
 289 CopyElement (ElementTypePtr Element)
 290 {
 291
 292 #ifdef DEBUG
 293   printf("Entered CopyElement, trying to copy element %s\n",
 294          Element->Name[1].TextString);
 295 #endif
 296
 297   bool didDraw = false;
 298   ElementTypePtr element = CopyElementLowLevel (PCB->Data,
 299                                                 NULL, Element,
 300                                                 TEST_FLAG (UNIQUENAMEFLAG,
 301                                                            PCB), DeltaX,
 302                                                 DeltaY);
 303
 304   /* this call clears the polygons */
 305   AddObjectToCreateUndoList (ELEMENT_TYPE, element, element, element);
 306   if (PCB->ElementOn && (FRONT (element) || PCB->InvisibleObjectsOn))
 307     {
 308       DrawElementName (element, 0);
 309       DrawElementPackage (element, 0);
 310       didDraw = true;
 311     }
 312   if (PCB->PinOn)
 313     {
 314       DrawElementPinsAndPads (element, 0);
 315       didDraw = true;
 316     }
 317 #ifdef DEBUG
 318   printf(" ... Leaving CopyElement.\n");
 319 #endif
 320   return (element);
 321 }
 322
 323 /* ---------------------------------------------------------------------------
 324  * pastes the contents of the buffer to the layout. Only visible objects
 325  * are handled by the routine.
 326  */
 327 bool
 328 CopyPastebufferToLayout (LocationType X, LocationType Y)
 329 {
 330   Cardinal i;
 331   bool changed = false;
 332
 333 #ifdef DEBUG
 334   printf("Entering CopyPastebufferToLayout.....\n");
 335 #endif
 336
 337   /* set movement vector */
 338   DeltaX = X - PASTEBUFFER->X, DeltaY = Y - PASTEBUFFER->Y;
 339
 340   /* paste all layers */
 341   for (i = 0; i < max_copper_layer + 2; i++)
 342     {
 343       LayerTypePtr sourcelayer = &PASTEBUFFER->Data->Layer[i],
 344         destlayer = LAYER_PTR (i);
 345
 346       if (destlayer->On)
 347         {
 348           changed = changed ||
 349             (sourcelayer->LineN != 0) ||
 350             (sourcelayer->ArcN != 0) ||
 351             (sourcelayer->PolygonN != 0) || (sourcelayer->TextN != 0);
 352           LINE_LOOP (sourcelayer);
 353           {
 354             CopyLine (destlayer, line);
 355           }
 356           END_LOOP;
 357           ARC_LOOP (sourcelayer);
 358           {
 359             CopyArc (destlayer, arc);
 360           }
 361           END_LOOP;
 362           TEXT_LOOP (sourcelayer);
 363           {
 364             CopyText (destlayer, text);
 365           }
 366           END_LOOP;
 367           POLYGON_LOOP (sourcelayer);
 368           {
 369             CopyPolygon (destlayer, polygon);
 370           }
 371           END_LOOP;
 372         }
 373     }
 374
 375   /* paste elements */
 376   if (PCB->PinOn && PCB->ElementOn)
 377     {
 378       ELEMENT_LOOP (PASTEBUFFER->Data);
 379       {
 380 #ifdef DEBUG
 381         printf("In CopyPastebufferToLayout, pasting element %s\n",
 382               element->Name[1].TextString);
 383 #endif
 384         if (FRONT (element) || PCB->InvisibleObjectsOn)
 385           {
 386             CopyElement (element);
 387             changed = true;
 388           }
 389       }
 390       END_LOOP;
 391     }
 392
 393   /* finally the vias */
 394   if (PCB->ViaOn)
 395     {
 396       changed |= (PASTEBUFFER->Data->ViaN != 0);
 397       VIA_LOOP (PASTEBUFFER->Data);
 398       {
 399         CopyVia (via);
 400       }
 401       END_LOOP;
 402     }
 403
 404   if (changed)
 405     {
 406       Draw ();
 407       IncrementUndoSerialNumber ();
 408     }
 409
 410 #ifdef DEBUG
 411   printf("  .... Leaving CopyPastebufferToLayout.\n");
 412 #endif
 413
 414   return (changed);
 415 }
 416
 417 /* ---------------------------------------------------------------------------
 418  * copies the object identified by its data pointers and the type
 419  * the new objects is moved by DX,DY
 420  * I assume that the appropriate layer ... is switched on
 421  */
 422 void *
 423 CopyObject (int Type, void *Ptr1, void *Ptr2, void *Ptr3,
 424             LocationType DX, LocationType DY)
 425 {
 426   void *ptr;
 427
 428   /* setup movement vector */
 429   DeltaX = DX;
 430   DeltaY = DY;
 431
 432   /* the subroutines add the objects to the undo-list */
 433   ptr = ObjectOperation (&CopyFunctions, Type, Ptr1, Ptr2, Ptr3);
 434   IncrementUndoSerialNumber ();
 435   return (ptr);
 436 }