src/create.c

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 1994,1995,1996, 2005 Thomas Nau
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *  Contact addresses for paper mail and Email:
  22  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  23  *  Thomas.Nau@rz.uni-ulm.de
  24  *
  25  */
  26
  27 /* functions used to create vias, pins ...
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif
  33
  34 #include <assert.h>
  35 #include <memory.h>
  36 #include <setjmp.h>
  37 #include <stdlib.h>
  38
  39 #include "global.h"
  40
  41 #include "create.h"
  42 #include "data.h"
  43 #include "draw.h"
  44 #include "error.h"
  45 #include "mymem.h"
  46 #include "misc.h"
  47 #include "parse_l.h"
  48 #include "pcb-printf.h"
  49 #include "polygon.h"
  50 #include "rtree.h"
  51 #include "search.h"
  52 #include "set.h"
  53 #include "undo.h"
  54 #include "vendor.h"
  55
  56 #ifdef HAVE_LIBDMALLOC
  57 #include <dmalloc.h>
  58 #endif
  59
  60 /* ---------------------------------------------------------------------------
  61  * some local identifiers
  62  */
  63 static int ID = 1;              /* current object ID; incremented after */
  64                                 /* each creation of an object */
  65
  66 static bool be_lenient = false;
  67
  68 /* ----------------------------------------------------------------------
  69  * some local prototypes
  70  */
  71 static void AddTextToElement (TextType *, FontType *,
  72                               Coord, Coord, unsigned, char *, int,
  73                               FlagType);
  74
  75 /* ---------------------------------------------------------------------------
  76  *  Set the lenience mode.
  77  */
  78
  79 void
  80 CreateBeLenient (bool v)
  81 {
  82   be_lenient = v;
  83 }
  84
  85 /* ---------------------------------------------------------------------------
  86  * creates a new paste buffer
  87  */
  88 DataType *
  89 CreateNewBuffer (void)
  90 {
  91   DataType *data;
  92   data = (DataType *) calloc (1, sizeof (DataType));
  93   data->pcb = (PCBType *) PCB;
  94   return data;
  95 }
  96
  97 /* ---------------------------------------------------------------------------
  98  * Perhaps PCB should internally just use the Settings colors?  For now,
  99  * use this to set PCB colors so the config can reassign PCB colors.
 100  */
 101 void
 102 pcb_colors_from_settings (PCBType *ptr)
 103 {
 104   int i;
 105
 106   /* copy default settings */
 107   ptr->ConnectedColor = Settings.ConnectedColor;
 108   ptr->ElementColor = Settings.ElementColor;
 109   ptr->RatColor = Settings.RatColor;
 110   ptr->InvisibleObjectsColor = Settings.InvisibleObjectsColor;
 111   ptr->InvisibleMarkColor = Settings.InvisibleMarkColor;
 112   ptr->ElementSelectedColor = Settings.ElementSelectedColor;
 113   ptr->RatSelectedColor = Settings.RatSelectedColor;
 114   ptr->PinColor = Settings.PinColor;
 115   ptr->PinSelectedColor = Settings.PinSelectedColor;
 116   ptr->PinNameColor = Settings.PinNameColor;
 117   ptr->ViaColor = Settings.ViaColor;
 118   ptr->ViaSelectedColor = Settings.ViaSelectedColor;
 119   ptr->WarnColor = Settings.WarnColor;
 120   ptr->MaskColor = Settings.MaskColor;
 121   for (i = 0; i < MAX_LAYER; i++)
 122     {
 123       ptr->Data->Layer[i].Color = Settings.LayerColor[i];
 124       ptr->Data->Layer[i].SelectedColor = Settings.LayerSelectedColor[i];
 125     }
 126   ptr->Data->Layer[component_silk_layer].Color =
 127     Settings.ShowSolderSide ?
 128     Settings.InvisibleObjectsColor : Settings.ElementColor;
 129   ptr->Data->Layer[component_silk_layer].SelectedColor =
 130     Settings.ElementSelectedColor;
 131   ptr->Data->Layer[solder_silk_layer].Color =
 132     Settings.ShowSolderSide ?
 133     Settings.ElementColor : Settings.InvisibleObjectsColor;
 134   ptr->Data->Layer[solder_silk_layer].SelectedColor =
 135     Settings.ElementSelectedColor;
 136 }
 137
 138 /* ---------------------------------------------------------------------------
 139  * creates a new PCB
 140  */
 141 PCBType *
 142 CreateNewPCB (bool SetDefaultNames)
 143 {
 144   PCBType *ptr;
 145   int i;
 146
 147   /* allocate memory, switch all layers on and copy resources */
 148   ptr = (PCBType *)calloc (1, sizeof (PCBType));
 149   ptr->Data = CreateNewBuffer ();
 150   ptr->Data->pcb = (PCBType *) ptr;
 151   ptr->Data->polyClip = 1;
 152
 153   ptr->ThermStyle = 4;
 154   ptr->IsleArea = 2.e8;
 155   ptr->SilkActive = false;
 156   ptr->RatDraw = false;
 157   SET_FLAG (NAMEONPCBFLAG, ptr);
 158   if (Settings.ShowNumber)
 159     SET_FLAG (SHOWNUMBERFLAG, ptr);
 160   if (Settings.AllDirectionLines)
 161     SET_FLAG (ALLDIRECTIONFLAG, ptr);
 162   ptr->Clipping = 1;            /* this is the most useful starting point for now */
 163   if (Settings.RubberBandMode)
 164     SET_FLAG (RUBBERBANDFLAG, ptr);
 165   if (Settings.SwapStartDirection)
 166     SET_FLAG (SWAPSTARTDIRFLAG, ptr);
 167   if (Settings.UniqueNames)
 168     SET_FLAG (UNIQUENAMEFLAG, ptr);
 169   if (Settings.SnapPin)
 170     SET_FLAG (SNAPPINFLAG, ptr);
 171   if (Settings.ClearLine)
 172     SET_FLAG (CLEARNEWFLAG, ptr);
 173   if (Settings.FullPoly)
 174     SET_FLAG (NEWFULLPOLYFLAG, ptr);
 175   if (Settings.OrthogonalMoves)
 176     SET_FLAG (ORTHOMOVEFLAG, ptr);
 177   if (Settings.liveRouting)
 178     SET_FLAG (LIVEROUTEFLAG, ptr);
 179   if (Settings.ShowDRC)
 180     SET_FLAG (SHOWDRCFLAG, ptr);
 181   if (Settings.AutoDRC)
 182     SET_FLAG (AUTODRCFLAG, ptr);
 183   ptr->Grid = Settings.Grid;
 184   ptr->LayerGroups = Settings.LayerGroups;
 185   STYLE_LOOP (ptr);
 186   {
 187     *style = Settings.RouteStyle[n];
 188     style->index = n;
 189   }
 190   END_LOOP;
 191   ptr->MaxWidth = Settings.MaxWidth;
 192   ptr->MaxHeight = Settings.MaxHeight;
 193   ptr->ID = ID++;
 194   ptr->ThermScale = 0.5;
 195
 196   ptr->Bloat = Settings.Bloat;
 197   ptr->Shrink = Settings.Shrink;
 198   ptr->minWid = Settings.minWid;
 199   ptr->minSlk = Settings.minSlk;
 200   ptr->minDrill = Settings.minDrill;
 201   ptr->minRing = Settings.minRing;
 202
 203   for (i = 0; i < MAX_LAYER; i++)
 204     ptr->Data->Layer[i].Name = strdup (Settings.DefaultLayerName[i]);
 205
 206         CreateDefaultFont (ptr);
 207
 208   return (ptr);
 209 }
 210
 211 /* This post-processing step adds the top and bottom silk layers to a
 212  * pre-existing PCB.
 213  */
 214 int
 215 CreateNewPCBPost (PCBType *pcb, int use_defaults)
 216 {
 217   /* copy default settings */
 218   pcb_colors_from_settings (pcb);
 219
 220   if (use_defaults)
 221     {
 222       if (ParseGroupString (Settings.Groups, &pcb->LayerGroups, DEF_LAYER))
 223         return 1;
 224
 225       pcb->Data->Layer[component_silk_layer].Name = strdup ("silk");
 226       pcb->Data->Layer[solder_silk_layer].Name = strdup ("silk");
 227     }
 228   return 0;
 229 }
 230
 231 /* ---------------------------------------------------------------------------
 232  * creates a new via
 233  */
 234 PinType *
 235 CreateNewVia (DataType *Data,
 236               Coord X, Coord Y,
 237               Coord Thickness, Coord Clearance, Coord Mask,
 238               Coord DrillingHole, char *Name, FlagType Flags)
 239 {
 240   PinType *Via;
 241
 242   if (!be_lenient)
 243     {
 244       VIA_LOOP (Data);
 245       {
 246         if (Distance (X, Y, via->X, via->Y) <=
 247             via->DrillingHole / 2 + DrillingHole / 2)
 248           {
 249             Message (_("%m+Dropping via at %$mD because it's hole would overlap with the via "
 250                        "at %$mD\n"), Settings.grid_unit->allow, X, Y, via->X, via->Y);
 251             return (NULL);              /* don't allow via stacking */
 252           }
 253       }
 254       END_LOOP;
 255     }
 256
 257   Via = GetViaMemory (Data);
 258
 259   if (!Via)
 260     return (Via);
 261   /* copy values */
 262   Via->X = X;
 263   Via->Y = Y;
 264   Via->Thickness = Thickness;
 265   Via->Clearance = Clearance;
 266   Via->Mask = Mask;
 267   Via->DrillingHole = vendorDrillMap (DrillingHole);
 268   if (Via->DrillingHole != DrillingHole)
 269     {
 270       Message (_("%m+Mapped via drill hole to %$mS from %$mS per vendor table\n"),
 271                Settings.grid_unit->allow, Via->DrillingHole, DrillingHole);
 272     }
 273
 274   Via->Name = STRDUP (Name);
 275   Via->Flags = Flags;
 276   CLEAR_FLAG (WARNFLAG, Via);
 277   SET_FLAG (VIAFLAG, Via);
 278   Via->ID = ID++;
 279
 280   /*
 281    * don't complain about MIN_PINORVIACOPPER on a mounting hole (pure
 282    * hole)
 283    */
 284   if (!TEST_FLAG (HOLEFLAG, Via) &&
 285       (Via->Thickness < Via->DrillingHole + MIN_PINORVIACOPPER))
 286     {
 287       Via->Thickness = Via->DrillingHole + MIN_PINORVIACOPPER;
 288       Message (_("%m+Increased via thickness to %$mS to allow enough copper"
 289                  " at %$mD.\n"),
 290                Settings.grid_unit->allow, Via->Thickness, Via->X, Via->Y);
 291     }
 292
 293   SetPinBoundingBox (Via);
 294   if (!Data->via_tree)
 295     Data->via_tree = r_create_tree (NULL, 0, 0);
 296   r_insert_entry (Data->via_tree, (BoxType *) Via, 0);
 297   return (Via);
 298 }
 299
 300 struct line_info
 301 {
 302   Coord X1, X2, Y1, Y2;
 303   Coord Thickness;
 304   Coord Clearance;
 305   FlagType Flags;
 306   LineType test, *ans;
 307   jmp_buf env;
 308 };
 309
 310 static int
 311 line_callback (const BoxType * b, void *cl)
 312 {
 313   LineType *line = (LineType *) b;
 314   struct line_info *i = (struct line_info *) cl;
 315
 316   if (line->Point1.X == i->X1 &&
 317       line->Point2.X == i->X2 &&
 318       line->Point1.Y == i->Y1 && line->Point2.Y == i->Y2)
 319     {
 320       i->ans = (LineType *) (-1);
 321       longjmp (i->env, 1);
 322     }
 323   /* check the other point order */
 324   if (line->Point1.X == i->X1 &&
 325       line->Point2.X == i->X2 &&
 326       line->Point1.Y == i->Y1 && line->Point2.Y == i->Y2)
 327     {
 328       i->ans = (LineType *) (-1);
 329       longjmp (i->env, 1);
 330     }
 331   if (line->Point2.X == i->X1 &&
 332       line->Point1.X == i->X2 &&
 333       line->Point2.Y == i->Y1 && line->Point1.Y == i->Y2)
 334     {
 335       i->ans = (LineType *) - 1;
 336       longjmp (i->env, 1);
 337     }
 338   /* remove unnecessary line points */
 339   if (line->Thickness == i->Thickness &&
 340       /* don't merge lines if the clearances differ  */
 341       line->Clearance == i->Clearance &&
 342       /* don't merge lines if the clear flags differ  */
 343       TEST_FLAG (CLEARLINEFLAG, line) == TEST_FLAG (CLEARLINEFLAG, i))
 344     {
 345       if (line->Point1.X == i->X1 && line->Point1.Y == i->Y1)
 346         {
 347           i->test.Point1.X = line->Point2.X;
 348           i->test.Point1.Y = line->Point2.Y;
 349           i->test.Point2.X = i->X2;
 350           i->test.Point2.Y = i->Y2;
 351           if (IsPointOnLine (i->X1, i->Y1, 0.0, &i->test))
 352             {
 353               i->ans = line;
 354               longjmp (i->env, 1);
 355             }
 356         }
 357       else if (line->Point2.X == i->X1 && line->Point2.Y == i->Y1)
 358         {
 359           i->test.Point1.X = line->Point1.X;
 360           i->test.Point1.Y = line->Point1.Y;
 361           i->test.Point2.X = i->X2;
 362           i->test.Point2.Y = i->Y2;
 363           if (IsPointOnLine (i->X1, i->Y1, 0.0, &i->test))
 364             {
 365               i->ans = line;
 366               longjmp (i->env, 1);
 367             }
 368         }
 369       else if (line->Point1.X == i->X2 && line->Point1.Y == i->Y2)
 370         {
 371           i->test.Point1.X = line->Point2.X;
 372           i->test.Point1.Y = line->Point2.Y;
 373           i->test.Point2.X = i->X1;
 374           i->test.Point2.Y = i->Y1;
 375           if (IsPointOnLine (i->X2, i->Y2, 0.0, &i->test))
 376             {
 377               i->ans = line;
 378               longjmp (i->env, 1);
 379             }
 380         }
 381       else if (line->Point2.X == i->X2 && line->Point2.Y == i->Y2)
 382         {
 383           i->test.Point1.X = line->Point1.X;
 384           i->test.Point1.Y = line->Point1.Y;
 385           i->test.Point2.X = i->X1;
 386           i->test.Point2.Y = i->Y1;
 387           if (IsPointOnLine (i->X2, i->Y2, 0.0, &i->test))
 388             {
 389               i->ans = line;
 390               longjmp (i->env, 1);
 391             }
 392         }
 393     }
 394   return 0;
 395 }
 396
 397
 398 /* ---------------------------------------------------------------------------
 399  * creates a new line on a layer and checks for overlap and extension
 400  */
 401 LineType *
 402 CreateDrawnLineOnLayer (LayerType *Layer,
 403                         Coord X1, Coord Y1,
 404                         Coord X2, Coord Y2,
 405                         Coord Thickness, Coord Clearance,
 406                         FlagType Flags)
 407 {
 408   struct line_info info;
 409   BoxType search;
 410
 411   search.X1 = MIN (X1, X2);
 412   search.X2 = MAX (X1, X2);
 413   search.Y1 = MIN (Y1, Y2);
 414   search.Y2 = MAX (Y1, Y2);
 415   if (search.Y2 == search.Y1)
 416     search.Y2++;
 417   if (search.X2 == search.X1)
 418     search.X2++;
 419   info.X1 = X1;
 420   info.X2 = X2;
 421   info.Y1 = Y1;
 422   info.Y2 = Y2;
 423   info.Thickness = Thickness;
 424   info.Clearance = Clearance;
 425   info.Flags = Flags;
 426   info.test.Thickness = 0;
 427   info.test.Flags = NoFlags ();
 428   info.ans = NULL;
 429   /* prevent stacking of duplicate lines
 430    * and remove needless intermediate points
 431    * verify that the layer is on the board first!
 432    */
 433   if (setjmp (info.env) == 0)
 434     {
 435       r_search (Layer->line_tree, &search, NULL, line_callback, &info);
 436       return CreateNewLineOnLayer (Layer, X1, Y1, X2, Y2,
 437                                    Thickness, Clearance, Flags);
 438     }
 439
 440   if ((void *) info.ans == (void *) (-1))
 441     return NULL;                /* stacked line */
 442   /* remove unnecessary points */
 443   if (info.ans)
 444     {
 445       /* must do this BEFORE getting new line memory */
 446       MoveObjectToRemoveUndoList (LINE_TYPE, Layer, info.ans, info.ans);
 447       X1 = info.test.Point1.X;
 448       X2 = info.test.Point2.X;
 449       Y1 = info.test.Point1.Y;
 450       Y2 = info.test.Point2.Y;
 451     }
 452   return CreateNewLineOnLayer (Layer, X1, Y1, X2, Y2,
 453                                Thickness, Clearance, Flags);
 454 }
 455
 456 LineType *
 457 CreateNewLineOnLayer (LayerType *Layer,
 458                       Coord X1, Coord Y1,
 459                       Coord X2, Coord Y2,
 460                       Coord Thickness, Coord Clearance,
 461                       FlagType Flags)
 462 {
 463   LineType *Line;
 464
 465   Line = GetLineMemory (Layer);
 466   if (!Line)
 467     return (Line);
 468   Line->ID = ID++;
 469   Line->Flags = Flags;
 470   CLEAR_FLAG (RATFLAG, Line);
 471   Line->Thickness = Thickness;
 472   Line->Clearance = Clearance;
 473   Line->Point1.X = X1;
 474   Line->Point1.Y = Y1;
 475   Line->Point1.ID = ID++;
 476   Line->Point2.X = X2;
 477   Line->Point2.Y = Y2;
 478   Line->Point2.ID = ID++;
 479   SetLineBoundingBox (Line);
 480   if (!Layer->line_tree)
 481     Layer->line_tree = r_create_tree (NULL, 0, 0);
 482   r_insert_entry (Layer->line_tree, (BoxType *) Line, 0);
 483   return (Line);
 484 }
 485
 486 /* ---------------------------------------------------------------------------
 487  * creates a new rat-line
 488  */
 489 RatType *
 490 CreateNewRat (DataType *Data, Coord X1, Coord Y1,
 491               Coord X2, Coord Y2, Cardinal group1,
 492               Cardinal group2, Coord Thickness, FlagType Flags)
 493 {
 494   RatType *Line = GetRatMemory (Data);
 495
 496   if (!Line)
 497     return (Line);
 498
 499   Line->ID = ID++;
 500   Line->Flags = Flags;
 501   SET_FLAG (RATFLAG, Line);
 502   Line->Thickness = Thickness;
 503   Line->Point1.X = X1;
 504   Line->Point1.Y = Y1;
 505   Line->Point1.ID = ID++;
 506   Line->Point2.X = X2;
 507   Line->Point2.Y = Y2;
 508   Line->Point2.ID = ID++;
 509   Line->group1 = group1;
 510   Line->group2 = group2;
 511   SetLineBoundingBox ((LineType *) Line);
 512   if (!Data->rat_tree)
 513     Data->rat_tree = r_create_tree (NULL, 0, 0);
 514   r_insert_entry (Data->rat_tree, &Line->BoundingBox, 0);
 515   return (Line);
 516 }
 517
 518 /* ---------------------------------------------------------------------------
 519  * creates a new arc on a layer
 520  */
 521 ArcType *
 522 CreateNewArcOnLayer (LayerType *Layer,
 523                      Coord X1, Coord Y1,
 524                      Coord width,
 525                      Coord height,
 526                      Angle sa,
 527                      Angle dir, Coord Thickness,
 528                      Coord Clearance, FlagType Flags)
 529 {
 530   ArcType *Arc;
 531
 532   ARC_LOOP (Layer);
 533   {
 534     if (arc->X == X1 && arc->Y == Y1 && arc->Width == width &&
 535         NormalizeAngle (arc->StartAngle) == NormalizeAngle (sa) &&
 536         arc->Delta == dir)
 537       return (NULL);            /* prevent stacked arcs */
 538   }
 539   END_LOOP;
 540   Arc = GetArcMemory (Layer);
 541   if (!Arc)
 542     return (Arc);
 543
 544   Arc->ID = ID++;
 545   Arc->Flags = Flags;
 546   Arc->Thickness = Thickness;
 547   Arc->Clearance = Clearance;
 548   Arc->X = X1;
 549   Arc->Y = Y1;
 550   Arc->Width = width;
 551   Arc->Height = height;
 552   Arc->StartAngle = sa;
 553   Arc->Delta = dir;
 554   SetArcBoundingBox (Arc);
 555   if (!Layer->arc_tree)
 556     Layer->arc_tree = r_create_tree (NULL, 0, 0);
 557   r_insert_entry (Layer->arc_tree, (BoxType *) Arc, 0);
 558   return (Arc);
 559 }
 560
 561
 562 /* ---------------------------------------------------------------------------
 563  * creates a new polygon from the old formats rectangle data
 564  */
 565 PolygonType *
 566 CreateNewPolygonFromRectangle (LayerType *Layer,
 567                                Coord X1, Coord Y1,
 568                                Coord X2, Coord Y2,
 569                                FlagType Flags)
 570 {
 571   PolygonType *polygon = CreateNewPolygon (Layer, Flags);
 572   if (!polygon)
 573     return (polygon);
 574
 575   CreateNewPointInPolygon (polygon, X1, Y1);
 576   CreateNewPointInPolygon (polygon, X2, Y1);
 577   CreateNewPointInPolygon (polygon, X2, Y2);
 578   CreateNewPointInPolygon (polygon, X1, Y2);
 579   SetPolygonBoundingBox (polygon);
 580   if (!Layer->polygon_tree)
 581     Layer->polygon_tree = r_create_tree (NULL, 0, 0);
 582   r_insert_entry (Layer->polygon_tree, (BoxType *) polygon, 0);
 583   return (polygon);
 584 }
 585
 586 /* ---------------------------------------------------------------------------
 587  * creates a new text on a layer
 588  */
 589 TextType *
 590 CreateNewText (LayerType *Layer, FontType *PCBFont,
 591                Coord X, Coord Y,
 592                unsigned Direction, int Scale, char *TextString, FlagType Flags)
 593 {
 594   TextType *text;
 595
 596   if (TextString == NULL)
 597     return NULL;
 598
 599   text = GetTextMemory (Layer);
 600   if (text == NULL)
 601     return NULL;
 602
 603   /* copy values, width and height are set by drawing routine
 604    * because at this point we don't know which symbols are available
 605    */
 606   text->X = X;
 607   text->Y = Y;
 608   text->Direction = Direction;
 609   text->Flags = Flags;
 610   text->Scale = Scale;
 611   text->TextString = strdup (TextString);
 612
 613   /* calculate size of the bounding box */
 614   SetTextBoundingBox (PCBFont, text);
 615   text->ID = ID++;
 616   if (!Layer->text_tree)
 617     Layer->text_tree = r_create_tree (NULL, 0, 0);
 618   r_insert_entry (Layer->text_tree, (BoxType *) text, 0);
 619   return (text);
 620 }
 621
 622 /* ---------------------------------------------------------------------------
 623  * creates a new polygon on a layer
 624  */
 625 PolygonType *
 626 CreateNewPolygon (LayerType *Layer, FlagType Flags)
 627 {
 628   PolygonType *polygon = GetPolygonMemory (Layer);
 629
 630   /* copy values */
 631   polygon->Flags = Flags;
 632   polygon->ID = ID++;
 633   polygon->Clipped = NULL;
 634   polygon->NoHoles = NULL;
 635   polygon->NoHolesValid = 0;
 636   return (polygon);
 637 }
 638
 639 /* ---------------------------------------------------------------------------
 640  * creates a new point in a polygon
 641  */
 642 PointType *
 643 CreateNewPointInPolygon (PolygonType *Polygon, Coord X, Coord Y)
 644 {
 645   PointType *point = GetPointMemoryInPolygon (Polygon);
 646
 647   /* copy values */
 648   point->X = X;
 649   point->Y = Y;
 650   point->ID = ID++;
 651   return (point);
 652 }
 653
 654 /* ---------------------------------------------------------------------------
 655  * creates a new hole in a polygon
 656  */
 657 PolygonType *
 658 CreateNewHoleInPolygon (PolygonType *Polygon)
 659 {
 660   Cardinal *holeindex = GetHoleIndexMemoryInPolygon (Polygon);
 661   *holeindex = Polygon->PointN;
 662   return Polygon;
 663 }
 664
 665 /* ---------------------------------------------------------------------------
 666  * creates an new element
 667  * memory is allocated if needed
 668  */
 669 ElementType *
 670 CreateNewElement (DataType *Data, ElementType *Element,
 671                   FontType *PCBFont,
 672                   FlagType Flags,
 673                   char *Description, char *NameOnPCB, char *Value,
 674                   Coord TextX, Coord TextY, BYTE Direction,
 675                   int TextScale, FlagType TextFlags, bool uniqueName)
 676 {
 677 #ifdef DEBUG
 678   printf("Entered CreateNewElement.....\n");
 679 #endif
 680
 681   if (!Element)
 682     Element = GetElementMemory (Data);
 683
 684   /* copy values and set additional information */
 685   TextScale = MAX (MIN_TEXTSCALE, TextScale);
 686   AddTextToElement (&DESCRIPTION_TEXT (Element), PCBFont, TextX, TextY,
 687                     Direction, Description, TextScale, TextFlags);
 688   if (uniqueName)
 689     NameOnPCB = UniqueElementName (Data, NameOnPCB);
 690   AddTextToElement (&NAMEONPCB_TEXT (Element), PCBFont, TextX, TextY,
 691                     Direction, NameOnPCB, TextScale, TextFlags);
 692   AddTextToElement (&VALUE_TEXT (Element), PCBFont, TextX, TextY,
 693                     Direction, Value, TextScale, TextFlags);
 694   DESCRIPTION_TEXT (Element).Element = Element;
 695   NAMEONPCB_TEXT (Element).Element = Element;
 696   VALUE_TEXT (Element).Element = Element;
 697   Element->Flags = Flags;
 698   Element->ID = ID++;
 699
 700 #ifdef DEBUG
 701   printf("  .... Leaving CreateNewElement.\n");
 702 #endif
 703
 704   return (Element);
 705 }
 706
 707 /* ---------------------------------------------------------------------------
 708  * creates a new arc in an element
 709  */
 710 ArcType *
 711 CreateNewArcInElement (ElementType *Element,
 712                        Coord X, Coord Y,
 713                        Coord Width, Coord Height,
 714                        Angle angle, Angle delta, Coord Thickness)
 715 {
 716   ArcType *arc;
 717
 718   arc = g_slice_new0 (ArcType);
 719   Element->Arc = g_list_append (Element->Arc, arc);
 720   Element->ArcN ++;
 721
 722   /* set Delta (0,360], StartAngle in [0,360) */
 723   if (delta < 0)
 724     {
 725       delta = -delta;
 726       angle -= delta;
 727     }
 728   angle = NormalizeAngle (angle);
 729   delta = NormalizeAngle (delta);
 730   if (delta == 0)
 731     delta = 360;
 732
 733   /* copy values */
 734   arc->X = X;
 735   arc->Y = Y;
 736   arc->Width = Width;
 737   arc->Height = Height;
 738   arc->StartAngle = angle;
 739   arc->Delta = delta;
 740   arc->Thickness = Thickness;
 741   arc->ID = ID++;
 742   return arc;
 743 }
 744
 745 /* ---------------------------------------------------------------------------
 746  * creates a new line for an element
 747  */
 748 LineType *
 749 CreateNewLineInElement (ElementType *Element,
 750                         Coord X1, Coord Y1,
 751                         Coord X2, Coord Y2,
 752                         Coord Thickness)
 753 {
 754   LineType *line;
 755
 756   if (Thickness == 0)
 757     return NULL;
 758
 759   line = g_slice_new0 (LineType);
 760   Element->Line = g_list_append (Element->Line, line);
 761   Element->LineN ++;
 762
 763   /* copy values */
 764   line->Point1.X = X1;
 765   line->Point1.Y = Y1;
 766   line->Point2.X = X2;
 767   line->Point2.Y = Y2;
 768   line->Thickness = Thickness;
 769   line->Flags = NoFlags ();
 770   line->ID = ID++;
 771   return line;
 772 }
 773
 774 /* ---------------------------------------------------------------------------
 775  * creates a new pin in an element
 776  */
 777 PinType *
 778 CreateNewPin (ElementType *Element,
 779               Coord X, Coord Y,
 780               Coord Thickness, Coord Clearance, Coord Mask,
 781               Coord DrillingHole, char *Name, char *Number,
 782               FlagType Flags)
 783 {
 784   PinType *pin = GetPinMemory (Element);
 785
 786   /* copy values */
 787   pin->X = X;
 788   pin->Y = Y;
 789   pin->Thickness = Thickness;
 790   pin->Clearance = Clearance;
 791   pin->Mask = Mask;
 792   pin->Name = STRDUP (Name);
 793   pin->Number = STRDUP (Number);
 794   pin->Flags = Flags;
 795   CLEAR_FLAG (WARNFLAG, pin);
 796   SET_FLAG (PINFLAG, pin);
 797   pin->ID = ID++;
 798   pin->Element = Element;
 799
 800   /*
 801    * If there is no vendor drill map installed, this will simply
 802    * return DrillingHole.
 803    */
 804   pin->DrillingHole = vendorDrillMap (DrillingHole);
 805
 806   /* Unless we should not map drills on this element, map them! */
 807   if (vendorIsElementMappable (Element))
 808     {
 809       if (pin->DrillingHole < MIN_PINORVIASIZE)
 810         {
 811           Message (_("%m+Did not map pin #%s (%s) drill hole because %$mS is below the minimum allowed size\n"),
 812                    Settings.grid_unit->allow, UNKNOWN (Number), UNKNOWN (Name), pin->DrillingHole);
 813           pin->DrillingHole = DrillingHole;
 814         }
 815       else if (pin->DrillingHole > MAX_PINORVIASIZE)
 816         {
 817           Message (_("%m+Did not map pin #%s (%s) drill hole because %$mS is above the maximum allowed size\n"),
 818                    Settings.grid_unit->allow, UNKNOWN (Number), UNKNOWN (Name), pin->DrillingHole);
 819           pin->DrillingHole = DrillingHole;
 820         }
 821       else if (!TEST_FLAG (HOLEFLAG, pin)
 822                && (pin->DrillingHole > pin->Thickness - MIN_PINORVIACOPPER))
 823         {
 824           Message (_("%m+Did not map pin #%s (%s) drill hole because %$mS does not leave enough copper\n"),
 825                    Settings.grid_unit->allow, UNKNOWN (Number), UNKNOWN (Name), pin->DrillingHole);
 826           pin->DrillingHole = DrillingHole;
 827         }
 828     }
 829   else
 830     {
 831       pin->DrillingHole = DrillingHole;
 832     }
 833
 834   if (pin->DrillingHole != DrillingHole)
 835     {
 836       Message (_("%m+Mapped pin drill hole to %$mS from %$mS per vendor table\n"),
 837                Settings.grid_unit->allow, pin->DrillingHole, DrillingHole);
 838     }
 839
 840   return (pin);
 841 }
 842
 843 /* ---------------------------------------------------------------------------
 844  * creates a new pad in an element
 845  */
 846 PadType *
 847 CreateNewPad (ElementType *Element,
 848               Coord X1, Coord Y1, Coord X2,
 849               Coord Y2, Coord Thickness, Coord Clearance,
 850               Coord Mask, char *Name, char *Number, FlagType Flags)
 851 {
 852   PadType *pad = GetPadMemory (Element);
 853
 854   /* copy values */
 855   if (X1 > X2 || (X1 == X2 && Y1 > Y2))
 856     {
 857       pad->Point1.X = X2;
 858       pad->Point1.Y = Y2;
 859       pad->Point2.X = X1;
 860       pad->Point2.Y = Y1;
 861     }
 862   else
 863     {
 864       pad->Point1.X = X1;
 865       pad->Point1.Y = Y1;
 866       pad->Point2.X = X2;
 867       pad->Point2.Y = Y2;
 868     }
 869   pad->Thickness = Thickness;
 870   pad->Clearance = Clearance;
 871   pad->Mask = Mask;
 872   pad->Name = STRDUP (Name);
 873   pad->Number = STRDUP (Number);
 874   pad->Flags = Flags;
 875   CLEAR_FLAG (WARNFLAG, pad);
 876   pad->ID = ID++;
 877   pad->Element = Element;
 878   return (pad);
 879 }
 880
 881 /* ---------------------------------------------------------------------------
 882  * creates a new textobject as part of an element
 883  * copies the values to the appropriate text object
 884  */
 885 static void
 886 AddTextToElement (TextType *Text, FontType *PCBFont,
 887                   Coord X, Coord Y,
 888                   unsigned Direction, char *TextString, int Scale, FlagType Flags)
 889 {
 890   free (Text->TextString);
 891   Text->TextString = (TextString && *TextString) ? strdup (TextString) : NULL;
 892   Text->X = X;
 893   Text->Y = Y;
 894   Text->Direction = Direction;
 895   Text->Flags = Flags;
 896   Text->Scale = Scale;
 897
 898   /* calculate size of the bounding box */
 899   SetTextBoundingBox (PCBFont, Text);
 900   Text->ID = ID++;
 901 }
 902
 903 /* ---------------------------------------------------------------------------
 904  * creates a new line in a symbol
 905  */
 906 LineType *
 907 CreateNewLineInSymbol (SymbolType *Symbol,
 908                        Coord X1, Coord Y1,
 909                        Coord X2, Coord Y2, Coord Thickness)
 910 {
 911   LineType *line = Symbol->Line;
 912
 913   /* realloc new memory if necessary and clear it */
 914   if (Symbol->LineN >= Symbol->LineMax)
 915     {
 916       Symbol->LineMax += STEP_SYMBOLLINE;
 917       line = (LineType *)realloc (line, Symbol->LineMax * sizeof (LineType));
 918       Symbol->Line = line;
 919       memset (line + Symbol->LineN, 0, STEP_SYMBOLLINE * sizeof (LineType));
 920     }
 921
 922   /* copy values */
 923   line = line + Symbol->LineN++;
 924   line->Point1.X = X1;
 925   line->Point1.Y = Y1;
 926   line->Point2.X = X2;
 927   line->Point2.Y = Y2;
 928   line->Thickness = Thickness;
 929   return (line);
 930 }
 931
 932 /* ---------------------------------------------------------------------------
 933  * parses a file with font information and installs it into the provided PCB
 934  * checks directories given as colon separated list by resource fontPath
 935  * if the fonts filename doesn't contain a directory component
 936  */
 937 void
 938 CreateDefaultFont (PCBType *pcb)
 939 {
 940   if (ParseFont (&pcb->Font, Settings.FontFile))
 941     Message (_("Can't find font-symbol-file '%s'\n"), Settings.FontFile);
 942 }
 943
 944 /* ---------------------------------------------------------------------------
 945  * adds a new line to the rubberband list of 'Crosshair.AttachedObject'
 946  * if Layer == 0  it is a rat line
 947  */
 948 RubberbandType *
 949 CreateNewRubberbandEntry (LayerType *Layer,
 950                           LineType *Line, PointType *MovedPoint)
 951 {
 952   RubberbandType *ptr = GetRubberbandMemory ();
 953
 954   /* we toggle the RUBBERENDFLAG of the line to determine if */
 955   /* both points are being moved. */
 956   TOGGLE_FLAG (RUBBERENDFLAG, Line);
 957   ptr->Layer = Layer;
 958   ptr->Line = Line;
 959   ptr->MovedPoint = MovedPoint;
 960   return (ptr);
 961 }
 962
 963 /* ---------------------------------------------------------------------------
 964  * Add a new net to the netlist menu
 965  */
 966 LibraryMenuType *
 967 CreateNewNet (LibraryType *lib, char *name, char *style)
 968 {
 969   LibraryMenuType *menu;
 970   char temp[64];
 971
 972   sprintf (temp, "  %s", name);
 973   menu = GetLibraryMenuMemory (lib);
 974   menu->Name = strdup (temp);
 975   menu->flag = 1;               /* net is enabled by default */
 976   if (style == NULL || NSTRCMP ("(unknown)", style) == 0)
 977     menu->Style = NULL;
 978   else
 979     menu->Style = strdup (style);
 980   return (menu);
 981 }
 982
 983 /* ---------------------------------------------------------------------------
 984  * Add a connection to the net
 985  */
 986 LibraryEntryType *
 987 CreateNewConnection (LibraryMenuType *net, char *conn)
 988 {
 989   LibraryEntryType *entry = GetLibraryEntryMemory (net);
 990
 991   entry->ListEntry = STRDUP (conn);
 992   return (entry);
 993 }
 994
 995 /* ---------------------------------------------------------------------------
 996  * Add an attribute to a list.
 997  */
 998 AttributeType *
 999 CreateNewAttribute (AttributeListType *list, char *name, char *value)
1000 {
1001   if (list->Number >= list->Max)
1002     {
1003       list->Max += 10;
1004       list->List = (AttributeType *)realloc (list->List, list->Max * sizeof (AttributeType));
1005     }
1006   list->List[list->Number].name = STRDUP (name);
1007   list->List[list->Number].value = STRDUP (value);
1008   list->Number++;
1009   return &list->List[list->Number - 1];
1010 }