src/draw.c

   1 /* $Id$ */
   2
   3 /*
   4  *                            COPYRIGHT
   5  *
   6  *  PCB, interactive printed circuit board design
   7  *  Copyright (C) 1994,1995,1996, 2003, 2004 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
  30 /* drawing routines
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include "global.h"
  38
  39 /*#include "clip.h"*/
  40 #include "compat.h"
  41 #include "crosshair.h"
  42 #include "data.h"
  43 #include "draw.h"
  44 #include "error.h"
  45 #include "mymem.h"
  46 #include "misc.h"
  47 #include "rotate.h"
  48 #include "rtree.h"
  49 #include "search.h"
  50 #include "select.h"
  51 #include "print.h"
  52
  53 #ifdef HAVE_LIBDMALLOC
  54 #include <dmalloc.h>
  55 #endif
  56
  57 #undef NDEBUG
  58 #include <assert.h>
  59
  60 #ifndef MAXINT
  61 #define MAXINT (((unsigned int)(~0))>>1)
  62 #endif
  63
  64 RCSID ("$Id$");
  65
  66 #define SMALL_SMALL_TEXT_SIZE   0
  67 #define SMALL_TEXT_SIZE                 1
  68 #define NORMAL_TEXT_SIZE                2
  69 #define LARGE_TEXT_SIZE                 3
  70 #define N_TEXT_SIZES                    4
  71
  72
  73 /* ---------------------------------------------------------------------------
  74  * some local identifiers
  75  */
  76 static BoxType Block = {MAXINT, MAXINT, -MAXINT, -MAXINT};
  77
  78 static int doing_pinout = 0;
  79 static bool doing_assy = false;
  80
  81 /* ---------------------------------------------------------------------------
  82  * some local prototypes
  83  */
  84 static void DrawEverything (const BoxType *);
  85 static void DrawPPV (int group, const BoxType *);
  86 static void DrawLayerGroup (int, const BoxType *);
  87 static void AddPart (void *);
  88 static void SetPVColor (PinTypePtr, int);
  89 static void DrawEMark (ElementTypePtr, Coord, Coord, bool);
  90 static void DrawMask (int side, const BoxType *);
  91 static void DrawPaste (int side, const BoxType *);
  92 static void DrawRats (const BoxType *);
  93 static void DrawSilk (int side, const BoxType *);
  94
  95 /*--------------------------------------------------------------------------------------
  96  * setup color for pin or via
  97  */
  98 static void
  99 SetPVColor (PinTypePtr Pin, int Type)
 100 {
 101   char *color;
 102
 103   if (Type == VIA_TYPE)
 104     {
 105       if (!doing_pinout
 106           && TEST_FLAG (WARNFLAG | SELECTEDFLAG | FOUNDFLAG, Pin))
 107         {
 108           if (TEST_FLAG (WARNFLAG, Pin))
 109             color = PCB->WarnColor;
 110           else if (TEST_FLAG (SELECTEDFLAG, Pin))
 111             color = PCB->ViaSelectedColor;
 112           else
 113             color = PCB->ConnectedColor;
 114         }
 115       else
 116         color = PCB->ViaColor;
 117     }
 118   else
 119     {
 120       if (!doing_pinout
 121           && TEST_FLAG (WARNFLAG | SELECTEDFLAG | FOUNDFLAG, Pin))
 122         {
 123           if (TEST_FLAG (WARNFLAG, Pin))
 124             color = PCB->WarnColor;
 125           else if (TEST_FLAG (SELECTEDFLAG, Pin))
 126             color = PCB->PinSelectedColor;
 127           else
 128             color = PCB->ConnectedColor;
 129         }
 130       else
 131         color = PCB->PinColor;
 132     }
 133
 134   gui->set_color (Output.fgGC, color);
 135 }
 136
 137 /*---------------------------------------------------------------------------
 138  *  Adds the update rect to the update region
 139  */
 140 static void
 141 AddPart (void *b)
 142 {
 143   BoxType *box = (BoxType *) b;
 144
 145   Block.X1 = MIN (Block.X1, box->X1);
 146   Block.X2 = MAX (Block.X2, box->X2);
 147   Block.Y1 = MIN (Block.Y1, box->Y1);
 148   Block.Y2 = MAX (Block.Y2, box->Y2);
 149 }
 150
 151 /*
 152  * initiate the actual redrawing of the updated area
 153  */
 154 void
 155 Draw (void)
 156 {
 157   if (Block.X1 <= Block.X2 && Block.Y1 <= Block.Y2)
 158     gui->invalidate_lr (Block.X1, Block.X2, Block.Y1, Block.Y2);
 159
 160   /* shrink the update block */
 161   Block.X1 = Block.Y1 =  MAXINT;
 162   Block.X2 = Block.Y2 = -MAXINT;
 163 }
 164
 165 /* ----------------------------------------------------------------------
 166  * redraws all the data by the event handlers
 167  */
 168 void
 169 Redraw (void)
 170 {
 171   gui->invalidate_all ();
 172 }
 173
 174 static void
 175 _draw_pv_name (PinType *pv)
 176 {
 177   BoxType box;
 178   bool vert;
 179   TextType text;
 180
 181   if (!pv->Name || !pv->Name[0])
 182     text.TextString = EMPTY (pv->Number);
 183   else
 184     text.TextString = EMPTY (TEST_FLAG (SHOWNUMBERFLAG, PCB) ? pv->Number : pv->Name);
 185
 186   vert = TEST_FLAG (EDGE2FLAG, pv);
 187
 188   if (vert)
 189     {
 190       box.X1 = pv->X - pv->Thickness    / 2 + Settings.PinoutTextOffsetY;
 191       box.Y1 = pv->Y - pv->DrillingHole / 2 - Settings.PinoutTextOffsetX;
 192     }
 193   else
 194     {
 195       box.X1 = pv->X + pv->DrillingHole / 2 + Settings.PinoutTextOffsetX;
 196       box.Y1 = pv->Y - pv->Thickness    / 2 + Settings.PinoutTextOffsetY;
 197     }
 198
 199   gui->set_color (Output.fgGC, PCB->PinNameColor);
 200
 201   text.Flags = NoFlags ();
 202   /* Set font height to approx 56% of pin thickness */
 203   text.Scale = 56 * pv->Thickness / FONT_CAPHEIGHT;
 204   text.X = box.X1;
 205   text.Y = box.Y1;
 206   text.Direction = vert ? 1 : 0;
 207
 208   if (gui->gui)
 209     doing_pinout++;
 210   DrawTextLowLevel (&text, 0);
 211   if (gui->gui)
 212     doing_pinout--;
 213 }
 214
 215 static void
 216 _draw_pv (PinTypePtr pv, bool draw_hole)
 217 {
 218   if (TEST_FLAG (THINDRAWFLAG, PCB))
 219     gui->thindraw_pcb_pv (Output.fgGC, Output.fgGC, pv, draw_hole, false);
 220   else
 221     gui->fill_pcb_pv (Output.fgGC, Output.bgGC, pv, draw_hole, false);
 222
 223   if (!TEST_FLAG (HOLEFLAG, pv) && TEST_FLAG (DISPLAYNAMEFLAG, pv))
 224     _draw_pv_name (pv);
 225 }
 226
 227 static void
 228 draw_pin (PinTypePtr pin, bool draw_hole)
 229 {
 230   SetPVColor (pin, PIN_TYPE);
 231   _draw_pv (pin, draw_hole);
 232 }
 233
 234 static int
 235 pin_callback (const BoxType * b, void *cl)
 236 {
 237   draw_pin ((PinType *)b, false);
 238   return 1;
 239 }
 240
 241 static void
 242 draw_via (PinTypePtr via, bool draw_hole)
 243 {
 244   SetPVColor (via, VIA_TYPE);
 245   _draw_pv (via, draw_hole);
 246 }
 247
 248 static int
 249 via_callback (const BoxType * b, void *cl)
 250 {
 251   draw_via ((PinType *)b, false);
 252   return 1;
 253 }
 254
 255 static void
 256 draw_pad_name (PadType *pad)
 257 {
 258   BoxType box;
 259   bool vert;
 260   TextType text;
 261
 262   if (!pad->Name || !pad->Name[0])
 263     text.TextString = EMPTY (pad->Number);
 264   else
 265     text.TextString = EMPTY (TEST_FLAG (SHOWNUMBERFLAG, PCB) ? pad->Number : pad->Name);
 266
 267   /* should text be vertical ? */
 268   vert = (pad->Point1.X == pad->Point2.X);
 269
 270   if (vert)
 271     {
 272       box.X1 = pad->Point1.X                      - pad->Thickness / 2;
 273       box.Y1 = MAX (pad->Point1.Y, pad->Point2.Y) + pad->Thickness / 2;
 274       box.X1 += Settings.PinoutTextOffsetY;
 275       box.Y1 -= Settings.PinoutTextOffsetX;
 276     }
 277   else
 278     {
 279       box.X1 = MIN (pad->Point1.X, pad->Point2.X) - pad->Thickness / 2;
 280       box.Y1 = pad->Point1.Y                      - pad->Thickness / 2;
 281       box.X1 += Settings.PinoutTextOffsetX;
 282       box.Y1 += Settings.PinoutTextOffsetY;
 283     }
 284
 285   gui->set_color (Output.fgGC, PCB->PinNameColor);
 286
 287   text.Flags = NoFlags ();
 288   /* Set font height to approx 90% of pin thickness */
 289   text.Scale = 90 * pad->Thickness / FONT_CAPHEIGHT;
 290   text.X = box.X1;
 291   text.Y = box.Y1;
 292   text.Direction = vert ? 1 : 0;
 293
 294   DrawTextLowLevel (&text, 0);
 295 }
 296
 297 static void
 298 _draw_pad (hidGC gc, PadType *pad, bool clear, bool mask)
 299 {
 300   if (clear && !mask && pad->Clearance <= 0)
 301     return;
 302
 303   if (TEST_FLAG (THINDRAWFLAG, PCB) ||
 304       (clear && TEST_FLAG (THINDRAWPOLYFLAG, PCB)))
 305     gui->thindraw_pcb_pad (gc, pad, clear, mask);
 306   else
 307     gui->fill_pcb_pad (gc, pad, clear, mask);
 308 }
 309
 310 static void
 311 draw_pad (PadType *pad)
 312 {
 313   if (doing_pinout)
 314    gui->set_color (Output.fgGC, PCB->PinColor);
 315   else if (TEST_FLAG (WARNFLAG | SELECTEDFLAG | FOUNDFLAG, pad))
 316    {
 317      if (TEST_FLAG (WARNFLAG, pad))
 318        gui->set_color (Output.fgGC, PCB->WarnColor);
 319      else if (TEST_FLAG (SELECTEDFLAG, pad))
 320        gui->set_color (Output.fgGC, PCB->PinSelectedColor);
 321      else
 322        gui->set_color (Output.fgGC, PCB->ConnectedColor);
 323    }
 324   else if (FRONT (pad))
 325    gui->set_color (Output.fgGC, PCB->PinColor);
 326   else
 327    gui->set_color (Output.fgGC, PCB->InvisibleObjectsColor);
 328
 329   _draw_pad (Output.fgGC, pad, false, false);
 330
 331   if (doing_pinout || TEST_FLAG (DISPLAYNAMEFLAG, pad))
 332     draw_pad_name (pad);
 333 }
 334
 335 static int
 336 pad_callback (const BoxType * b, void *cl)
 337 {
 338   PadTypePtr pad = (PadTypePtr) b;
 339   int *side = cl;
 340
 341   if (ON_SIDE (pad, *side))
 342     draw_pad (pad);
 343   return 1;
 344 }
 345
 346 static void
 347 draw_element_name (ElementType *element)
 348 {
 349   if ((TEST_FLAG (HIDENAMESFLAG, PCB) && gui->gui) ||
 350       TEST_FLAG (HIDENAMEFLAG, element))
 351     return;
 352   if (doing_pinout || doing_assy)
 353     gui->set_color (Output.fgGC, PCB->ElementColor);
 354   else if (TEST_FLAG (SELECTEDFLAG, &ELEMENT_TEXT (PCB, element)))
 355     gui->set_color (Output.fgGC, PCB->ElementSelectedColor);
 356   else if (FRONT (element))
 357     gui->set_color (Output.fgGC, PCB->ElementColor);
 358   else
 359     gui->set_color (Output.fgGC, PCB->InvisibleObjectsColor);
 360   DrawTextLowLevel (&ELEMENT_TEXT (PCB, element), PCB->minSlk);
 361 }
 362
 363 static int
 364 name_callback (const BoxType * b, void *cl)
 365 {
 366   TextTypePtr text = (TextTypePtr) b;
 367   ElementTypePtr element = (ElementTypePtr) text->Element;
 368   int *side = cl;
 369
 370   if (TEST_FLAG (HIDENAMEFLAG, element))
 371     return 0;
 372
 373   if (ON_SIDE (element, *side))
 374     draw_element_name (element);
 375   return 0;
 376 }
 377
 378 static void
 379 draw_element_pins_and_pads (ElementType *element)
 380 {
 381   PAD_LOOP (element);
 382   {
 383     if (doing_pinout || doing_assy || FRONT (pad) || PCB->InvisibleObjectsOn)
 384       draw_pad (pad);
 385   }
 386   END_LOOP;
 387   PIN_LOOP (element);
 388   {
 389     draw_pin (pin, true);
 390   }
 391   END_LOOP;
 392 }
 393
 394 static int
 395 EMark_callback (const BoxType * b, void *cl)
 396 {
 397   ElementTypePtr element = (ElementTypePtr) b;
 398
 399   DrawEMark (element, element->MarkX, element->MarkY, !FRONT (element));
 400   return 1;
 401 }
 402
 403 static int
 404 hole_callback (const BoxType * b, void *cl)
 405 {
 406   PinTypePtr pv = (PinTypePtr) b;
 407   int plated = cl ? *(int *) cl : -1;
 408
 409   if ((plated == 0 && !TEST_FLAG (HOLEFLAG, pv)) ||
 410       (plated == 1 &&  TEST_FLAG (HOLEFLAG, pv)))
 411     return 1;
 412
 413   if (TEST_FLAG (THINDRAWFLAG, PCB))
 414     {
 415       if (!TEST_FLAG (HOLEFLAG, pv))
 416         {
 417           gui->set_line_cap (Output.fgGC, Round_Cap);
 418           gui->set_line_width (Output.fgGC, 0);
 419           gui->draw_arc (Output.fgGC,
 420                          pv->X, pv->Y, pv->DrillingHole / 2,
 421                          pv->DrillingHole / 2, 0, 360);
 422         }
 423     }
 424   else
 425     gui->fill_circle (Output.bgGC, pv->X, pv->Y, pv->DrillingHole / 2);
 426
 427   if (TEST_FLAG (HOLEFLAG, pv))
 428     {
 429       if (TEST_FLAG (WARNFLAG, pv))
 430         gui->set_color (Output.fgGC, PCB->WarnColor);
 431       else if (TEST_FLAG (SELECTEDFLAG, pv))
 432         gui->set_color (Output.fgGC, PCB->ViaSelectedColor);
 433       else
 434         gui->set_color (Output.fgGC, Settings.BlackColor);
 435
 436       gui->set_line_cap (Output.fgGC, Round_Cap);
 437       gui->set_line_width (Output.fgGC, 0);
 438       gui->draw_arc (Output.fgGC,
 439                      pv->X, pv->Y, pv->DrillingHole / 2,
 440                      pv->DrillingHole / 2, 0, 360);
 441     }
 442   return 1;
 443 }
 444
 445 static void
 446 DrawHoles (bool draw_plated, bool draw_unplated, const BoxType *drawn_area)
 447 {
 448   int plated = -1;
 449
 450   if ( draw_plated && !draw_unplated) plated = 1;
 451   if (!draw_plated &&  draw_unplated) plated = 0;
 452
 453   r_search (PCB->Data->pin_tree, drawn_area, NULL, hole_callback, &plated);
 454   r_search (PCB->Data->via_tree, drawn_area, NULL, hole_callback, &plated);
 455 }
 456
 457 static void
 458 _draw_line (LineType *line)
 459 {
 460   gui->set_line_cap (Output.fgGC, Trace_Cap);
 461   if (TEST_FLAG (THINDRAWFLAG, PCB))
 462     gui->set_line_width (Output.fgGC, 0);
 463   else
 464     gui->set_line_width (Output.fgGC, line->Thickness);
 465
 466   gui->draw_line (Output.fgGC,
 467                   line->Point1.X, line->Point1.Y,
 468                   line->Point2.X, line->Point2.Y);
 469 }
 470
 471 static void
 472 draw_line (LayerType *layer, LineType *line)
 473 {
 474   if (TEST_FLAG (SELECTEDFLAG | FOUNDFLAG, line))
 475     {
 476       if (TEST_FLAG (SELECTEDFLAG, line))
 477         gui->set_color (Output.fgGC, layer->SelectedColor);
 478       else
 479         gui->set_color (Output.fgGC, PCB->ConnectedColor);
 480     }
 481   else
 482     gui->set_color (Output.fgGC, layer->Color);
 483   _draw_line (line);
 484 }
 485
 486 static int
 487 line_callback (const BoxType * b, void *cl)
 488 {
 489   draw_line ((LayerType *) cl, (LineType *) b);
 490   return 1;
 491 }
 492
 493 static int
 494 rat_callback (const BoxType * b, void *cl)
 495 {
 496   RatType *rat = (RatType *)b;
 497
 498   if (TEST_FLAG (SELECTEDFLAG | FOUNDFLAG, rat))
 499     {
 500       if (TEST_FLAG (SELECTEDFLAG, rat))
 501         gui->set_color (Output.fgGC, PCB->RatSelectedColor);
 502       else
 503         gui->set_color (Output.fgGC, PCB->ConnectedColor);
 504     }
 505   else
 506     gui->set_color (Output.fgGC, PCB->RatColor);
 507
 508   if (Settings.RatThickness < 20)
 509     rat->Thickness = pixel_slop * Settings.RatThickness;
 510   /* rats.c set VIAFLAG if this rat goes to a containing poly: draw a donut */
 511   if (TEST_FLAG(VIAFLAG, rat))
 512     {
 513       int w = rat->Thickness;
 514
 515       if (TEST_FLAG (THINDRAWFLAG, PCB))
 516         gui->set_line_width (Output.fgGC, 0);
 517       else
 518         gui->set_line_width (Output.fgGC, w);
 519       gui->draw_arc (Output.fgGC, rat->Point1.X, rat->Point1.Y,
 520                      w * 2, w * 2, 0, 360);
 521     }
 522   else
 523     _draw_line ((LineType *) rat);
 524   return 1;
 525 }
 526
 527 static void
 528 _draw_arc (ArcType *arc)
 529 {
 530   if (!arc->Thickness)
 531     return;
 532
 533   if (TEST_FLAG (THINDRAWFLAG, PCB))
 534     gui->set_line_width (Output.fgGC, 0);
 535   else
 536     gui->set_line_width (Output.fgGC, arc->Thickness);
 537   gui->set_line_cap (Output.fgGC, Trace_Cap);
 538
 539   gui->draw_arc (Output.fgGC, arc->X, arc->Y, arc->Width,
 540                  arc->Height, arc->StartAngle, arc->Delta);
 541 }
 542
 543 static void
 544 draw_arc (LayerType *layer, ArcType *arc)
 545 {
 546   if (TEST_FLAG (SELECTEDFLAG | FOUNDFLAG, arc))
 547     {
 548       if (TEST_FLAG (SELECTEDFLAG, arc))
 549         gui->set_color (Output.fgGC, layer->SelectedColor);
 550       else
 551         gui->set_color (Output.fgGC, PCB->ConnectedColor);
 552     }
 553   else
 554     gui->set_color (Output.fgGC, layer->Color);
 555
 556   _draw_arc (arc);
 557 }
 558
 559 static int
 560 arc_callback (const BoxType * b, void *cl)
 561 {
 562   draw_arc ((LayerTypePtr) cl, (ArcTypePtr) b);
 563   return 1;
 564 }
 565
 566 static void
 567 draw_element_package (ElementType *element)
 568 {
 569   /* set color and draw lines, arcs, text and pins */
 570   if (doing_pinout || doing_assy)
 571     gui->set_color (Output.fgGC, PCB->ElementColor);
 572   else if (TEST_FLAG (SELECTEDFLAG, element))
 573     gui->set_color (Output.fgGC, PCB->ElementSelectedColor);
 574   else if (FRONT (element))
 575     gui->set_color (Output.fgGC, PCB->ElementColor);
 576   else
 577     gui->set_color (Output.fgGC, PCB->InvisibleObjectsColor);
 578
 579   /* draw lines, arcs, text and pins */
 580   ELEMENTLINE_LOOP (element);
 581   {
 582     _draw_line (line);
 583   }
 584   END_LOOP;
 585   ARC_LOOP (element);
 586   {
 587     _draw_arc (arc);
 588   }
 589   END_LOOP;
 590 }
 591
 592 static int
 593 element_callback (const BoxType * b, void *cl)
 594 {
 595   ElementTypePtr element = (ElementTypePtr) b;
 596   int *side = cl;
 597
 598   if (ON_SIDE (element, *side))
 599     draw_element_package (element);
 600   return 1;
 601 }
 602
 603 /* ---------------------------------------------------------------------------
 604  * prints assembly drawing.
 605  */
 606
 607 static void
 608 PrintAssembly (int side, const BoxType * drawn_area)
 609 {
 610   int side_group = GetLayerGroupNumberByNumber (max_copper_layer + side);
 611
 612   doing_assy = true;
 613   gui->set_draw_faded (Output.fgGC, 1);
 614   DrawLayerGroup (side_group, drawn_area);
 615   gui->set_draw_faded (Output.fgGC, 0);
 616
 617   /* draw package */
 618   DrawSilk (side, drawn_area);
 619   doing_assy = false;
 620 }
 621
 622 /* ---------------------------------------------------------------------------
 623  * initializes some identifiers for a new zoom factor and redraws whole screen
 624  */
 625 static void
 626 DrawEverything (const BoxType *drawn_area)
 627 {
 628   int i, ngroups, side;
 629   int component, solder;
 630   /* This is the list of layer groups we will draw.  */
 631   int do_group[MAX_LAYER];
 632   /* This is the reverse of the order in which we draw them.  */
 633   int drawn_groups[MAX_LAYER];
 634   int plated, unplated;
 635   bool paste_empty;
 636
 637   PCB->Data->SILKLAYER.Color = PCB->ElementColor;
 638   PCB->Data->BACKSILKLAYER.Color = PCB->InvisibleObjectsColor;
 639
 640   memset (do_group, 0, sizeof (do_group));
 641   for (ngroups = 0, i = 0; i < max_copper_layer; i++)
 642     {
 643       LayerType *l = LAYER_ON_STACK (i);
 644       int group = GetLayerGroupNumberByNumber (LayerStack[i]);
 645       if (l->On && !do_group[group])
 646         {
 647           do_group[group] = 1;
 648           drawn_groups[ngroups++] = group;
 649         }
 650     }
 651
 652   component = GetLayerGroupNumberByNumber (component_silk_layer);
 653   solder = GetLayerGroupNumberByNumber (solder_silk_layer);
 654
 655   /*
 656    * first draw all 'invisible' stuff
 657    */
 658   if (!TEST_FLAG (CHECKPLANESFLAG, PCB)
 659       && gui->set_layer ("invisible", SL (INVISIBLE, 0), 0))
 660     {
 661       side = SWAP_IDENT ? COMPONENT_LAYER : SOLDER_LAYER;
 662       if (PCB->ElementOn)
 663         {
 664           r_search (PCB->Data->element_tree, drawn_area, NULL, element_callback, &side);
 665           r_search (PCB->Data->name_tree[NAME_INDEX (PCB)], drawn_area, NULL, name_callback, &side);
 666           DrawLayer (&(PCB->Data->Layer[max_copper_layer + side]), drawn_area);
 667         }
 668       r_search (PCB->Data->pad_tree, drawn_area, NULL, pad_callback, &side);
 669       gui->end_layer ();
 670     }
 671
 672   /* draw all layers in layerstack order */
 673   for (i = ngroups - 1; i >= 0; i--)
 674     {
 675       int group = drawn_groups[i];
 676
 677       if (gui->set_layer (0, group, 0))
 678         {
 679           DrawLayerGroup (group, drawn_area);
 680           gui->end_layer ();
 681         }
 682     }
 683
 684   if (TEST_FLAG (CHECKPLANESFLAG, PCB) && gui->gui)
 685     return;
 686
 687   /* Draw pins, pads, vias below silk */
 688   if (gui->gui)
 689     DrawPPV (SWAP_IDENT ? solder : component, drawn_area);
 690   else
 691     {
 692       CountHoles (&plated, &unplated, drawn_area);
 693
 694       if (plated && gui->set_layer ("plated-drill", SL (PDRILL, 0), 0))
 695         {
 696           DrawHoles (true, false, drawn_area);
 697           gui->end_layer ();
 698         }
 699
 700       if (unplated && gui->set_layer ("unplated-drill", SL (UDRILL, 0), 0))
 701         {
 702           DrawHoles (false, true, drawn_area);
 703           gui->end_layer ();
 704         }
 705     }
 706
 707   /* Draw the solder mask if turned on */
 708   if (gui->set_layer ("componentmask", SL (MASK, TOP), 0))
 709     {
 710       DrawMask (COMPONENT_LAYER, drawn_area);
 711       gui->end_layer ();
 712     }
 713
 714   if (gui->set_layer ("soldermask", SL (MASK, BOTTOM), 0))
 715     {
 716       DrawMask (SOLDER_LAYER, drawn_area);
 717       gui->end_layer ();
 718     }
 719
 720   if (gui->set_layer ("topsilk", SL (SILK, TOP), 0))
 721     {
 722       DrawSilk (COMPONENT_LAYER, drawn_area);
 723       gui->end_layer ();
 724     }
 725
 726   if (gui->set_layer ("bottomsilk", SL (SILK, BOTTOM), 0))
 727     {
 728       DrawSilk (SOLDER_LAYER, drawn_area);
 729       gui->end_layer ();
 730     }
 731
 732   if (gui->gui)
 733     {
 734       /* Draw element Marks */
 735       if (PCB->PinOn)
 736         r_search (PCB->Data->element_tree, drawn_area, NULL, EMark_callback,
 737                   NULL);
 738       /* Draw rat lines on top */
 739       if (gui->set_layer ("rats", SL (RATS, 0), 0))
 740         {
 741           DrawRats(drawn_area);
 742           gui->end_layer ();
 743         }
 744     }
 745
 746   paste_empty = IsPasteEmpty (COMPONENT_LAYER);
 747   if (gui->set_layer ("toppaste", SL (PASTE, TOP), paste_empty))
 748     {
 749       DrawPaste (COMPONENT_LAYER, drawn_area);
 750       gui->end_layer ();
 751     }
 752
 753   paste_empty = IsPasteEmpty (SOLDER_LAYER);
 754   if (gui->set_layer ("bottompaste", SL (PASTE, BOTTOM), paste_empty))
 755     {
 756       DrawPaste (SOLDER_LAYER, drawn_area);
 757       gui->end_layer ();
 758     }
 759
 760   if (gui->set_layer ("topassembly", SL (ASSY, TOP), 0))
 761     {
 762       PrintAssembly (COMPONENT_LAYER, drawn_area);
 763       gui->end_layer ();
 764     }
 765
 766   if (gui->set_layer ("bottomassembly", SL (ASSY, BOTTOM), 0))
 767     {
 768       PrintAssembly (SOLDER_LAYER, drawn_area);
 769       gui->end_layer ();
 770     }
 771
 772   if (gui->set_layer ("fab", SL (FAB, 0), 0))
 773     {
 774       PrintFab (Output.fgGC);
 775       gui->end_layer ();
 776     }
 777 }
 778
 779 static void
 780 DrawEMark (ElementTypePtr e, Coord X, Coord Y, bool invisible)
 781 {
 782   Coord mark_size = EMARK_SIZE;
 783   if (!PCB->InvisibleObjectsOn && invisible)
 784     return;
 785
 786   if (e->Pin != NULL)
 787     {
 788       PinType *pin0 = e->Pin->data;
 789       if (TEST_FLAG (HOLEFLAG, pin0))
 790         mark_size = MIN (mark_size, pin0->DrillingHole / 2);
 791       else
 792         mark_size = MIN (mark_size, pin0->Thickness / 2);
 793     }
 794
 795   if (e->Pad != NULL)
 796     {
 797       PadType *pad0 = e->Pad->data;
 798       mark_size = MIN (mark_size, pad0->Thickness / 2);
 799     }
 800
 801   gui->set_color (Output.fgGC,
 802                   invisible ? PCB->InvisibleMarkColor : PCB->ElementColor);
 803   gui->set_line_cap (Output.fgGC, Trace_Cap);
 804   gui->set_line_width (Output.fgGC, 0);
 805   gui->draw_line (Output.fgGC, X - mark_size, Y, X, Y - mark_size);
 806   gui->draw_line (Output.fgGC, X + mark_size, Y, X, Y - mark_size);
 807   gui->draw_line (Output.fgGC, X - mark_size, Y, X, Y + mark_size);
 808   gui->draw_line (Output.fgGC, X + mark_size, Y, X, Y + mark_size);
 809
 810   /*
 811    * If an element is locked, place a "L" on top of the "diamond".
 812    * This provides a nice visual indication that it is locked that
 813    * works even for color blind users.
 814    */
 815   if (TEST_FLAG (LOCKFLAG, e) )
 816     {
 817       gui->draw_line (Output.fgGC, X, Y, X + 2 * mark_size, Y);
 818       gui->draw_line (Output.fgGC, X, Y, X, Y - 4* mark_size);
 819     }
 820 }
 821
 822 /* ---------------------------------------------------------------------------
 823  * Draws pins pads and vias - Always draws for non-gui HIDs,
 824  * otherwise drawing depends on PCB->PinOn and PCB->ViaOn
 825  */
 826 static void
 827 DrawPPV (int group, const BoxType *drawn_area)
 828 {
 829   int component_group = GetLayerGroupNumberByNumber (component_silk_layer);
 830   int solder_group = GetLayerGroupNumberByNumber (solder_silk_layer);
 831   int side;
 832
 833   if (PCB->PinOn || !gui->gui)
 834     {
 835       /* draw element pins */
 836       r_search (PCB->Data->pin_tree, drawn_area, NULL, pin_callback, NULL);
 837
 838       /* draw element pads */
 839       if (group == component_group)
 840         {
 841           side = COMPONENT_LAYER;
 842           r_search (PCB->Data->pad_tree, drawn_area, NULL, pad_callback, &side);
 843         }
 844
 845       if (group == solder_group)
 846         {
 847           side = SOLDER_LAYER;
 848           r_search (PCB->Data->pad_tree, drawn_area, NULL, pad_callback, &side);
 849         }
 850     }
 851
 852   /* draw vias */
 853   if (PCB->ViaOn || !gui->gui)
 854     {
 855       r_search (PCB->Data->via_tree, drawn_area, NULL, via_callback, NULL);
 856       r_search (PCB->Data->via_tree, drawn_area, NULL, hole_callback, NULL);
 857     }
 858   if (PCB->PinOn || doing_assy)
 859     r_search (PCB->Data->pin_tree, drawn_area, NULL, hole_callback, NULL);
 860 }
 861
 862 static int
 863 clearPin_callback (const BoxType * b, void *cl)
 864 {
 865   PinType *pin = (PinTypePtr) b;
 866   if (TEST_FLAG (THINDRAWFLAG, PCB) || TEST_FLAG (THINDRAWPOLYFLAG, PCB))
 867     gui->thindraw_pcb_pv (Output.pmGC, Output.pmGC, pin, false, true);
 868   else
 869     gui->fill_pcb_pv (Output.pmGC, Output.pmGC, pin, false, true);
 870   return 1;
 871 }
 872
 873 struct poly_info {
 874   const BoxType *drawn_area;
 875   LayerType *layer;
 876 };
 877
 878 static int
 879 poly_callback (const BoxType * b, void *cl)
 880 {
 881   struct poly_info *i = cl;
 882   PolygonType *polygon = (PolygonType *)b;
 883   static char *color;
 884
 885   if (!polygon->Clipped)
 886     return 0;
 887
 888   if (TEST_FLAG (SELECTEDFLAG, polygon))
 889     color = i->layer->SelectedColor;
 890   else if (TEST_FLAG (FOUNDFLAG, polygon))
 891     color = PCB->ConnectedColor;
 892   else
 893     color = i->layer->Color;
 894   gui->set_color (Output.fgGC, color);
 895
 896   if (gui->thindraw_pcb_polygon != NULL &&
 897       (TEST_FLAG (THINDRAWFLAG, PCB) ||
 898        TEST_FLAG (THINDRAWPOLYFLAG, PCB)))
 899     gui->thindraw_pcb_polygon (Output.fgGC, polygon, i->drawn_area);
 900   else
 901     gui->fill_pcb_polygon (Output.fgGC, polygon, i->drawn_area);
 902
 903   /* If checking planes, thin-draw any pieces which have been clipped away */
 904   if (gui->thindraw_pcb_polygon != NULL &&
 905       TEST_FLAG (CHECKPLANESFLAG, PCB) &&
 906       !TEST_FLAG (FULLPOLYFLAG, polygon))
 907     {
 908       PolygonType poly = *polygon;
 909
 910       for (poly.Clipped = polygon->Clipped->f;
 911            poly.Clipped != polygon->Clipped;
 912            poly.Clipped = poly.Clipped->f)
 913         gui->thindraw_pcb_polygon (Output.fgGC, &poly, i->drawn_area);
 914     }
 915
 916   return 1;
 917 }
 918
 919 static int
 920 clearPad_callback (const BoxType * b, void *cl)
 921 {
 922   PadTypePtr pad = (PadTypePtr) b;
 923   int *side = cl;
 924   if (ON_SIDE (pad, *side) && pad->Mask)
 925     _draw_pad (Output.pmGC, pad, true, true);
 926   return 1;
 927 }
 928
 929 /* ---------------------------------------------------------------------------
 930  * Draws silk layer.
 931  */
 932
 933 static void
 934 DrawSilk (int side, const BoxType * drawn_area)
 935 {
 936 #if 0
 937   /* This code is used when you want to mask silk to avoid exposed
 938      pins and pads.  We decided it was a bad idea to do this
 939      unconditionally, but the code remains.  */
 940 #endif
 941
 942 #if 0
 943   if (gui->poly_before)
 944     {
 945       gui->use_mask (HID_MASK_BEFORE);
 946 #endif
 947       DrawLayer (LAYER_PTR (max_copper_layer + side), drawn_area);
 948       /* draw package */
 949       r_search (PCB->Data->element_tree, drawn_area, NULL, element_callback, &side);
 950       r_search (PCB->Data->name_tree[NAME_INDEX (PCB)], drawn_area, NULL, name_callback, &side);
 951 #if 0
 952     }
 953
 954   gui->use_mask (HID_MASK_CLEAR);
 955   r_search (PCB->Data->pin_tree, drawn_area, NULL, clearPin_callback, NULL);
 956   r_search (PCB->Data->via_tree, drawn_area, NULL, clearPin_callback, NULL);
 957   r_search (PCB->Data->pad_tree, drawn_area, NULL, clearPad_callback, &side);
 958
 959   if (gui->poly_after)
 960     {
 961       gui->use_mask (HID_MASK_AFTER);
 962       DrawLayer (LAYER_PTR (max_copper_layer + layer), drawn_area);
 963       /* draw package */
 964       r_search (PCB->Data->element_tree, drawn_area, NULL, element_callback, &side);
 965       r_search (PCB->Data->name_tree[NAME_INDEX (PCB)], drawn_area, NULL, name_callback, &side);
 966     }
 967   gui->use_mask (HID_MASK_OFF);
 968 #endif
 969 }
 970
 971
 972 static void
 973 DrawMaskBoardArea (int mask_type, const BoxType *drawn_area)
 974 {
 975   /* Skip the mask drawing if the GUI doesn't want this type */
 976   if ((mask_type == HID_MASK_BEFORE && !gui->poly_before) ||
 977       (mask_type == HID_MASK_AFTER  && !gui->poly_after))
 978     return;
 979
 980   gui->use_mask (mask_type);
 981   gui->set_color (Output.fgGC, PCB->MaskColor);
 982   if (drawn_area == NULL)
 983     gui->fill_rect (Output.fgGC, 0, 0, PCB->MaxWidth, PCB->MaxHeight);
 984   else
 985     gui->fill_rect (Output.fgGC, drawn_area->X1, drawn_area->Y1,
 986                                  drawn_area->X2, drawn_area->Y2);
 987 }
 988
 989 /* ---------------------------------------------------------------------------
 990  * draws solder mask layer - this will cover nearly everything
 991  */
 992 static void
 993 DrawMask (int side, const BoxType *screen)
 994 {
 995   int thin = TEST_FLAG(THINDRAWFLAG, PCB) || TEST_FLAG(THINDRAWPOLYFLAG, PCB);
 996
 997   if (thin)
 998     gui->set_color (Output.pmGC, PCB->MaskColor);
 999   else
1000     {
1001       DrawMaskBoardArea (HID_MASK_BEFORE, screen);
1002       gui->use_mask (HID_MASK_CLEAR);
1003     }
1004
1005   r_search (PCB->Data->pin_tree, screen, NULL, clearPin_callback, NULL);
1006   r_search (PCB->Data->via_tree, screen, NULL, clearPin_callback, NULL);
1007   r_search (PCB->Data->pad_tree, screen, NULL, clearPad_callback, &side);
1008
1009   if (thin)
1010     gui->set_color (Output.pmGC, "erase");
1011   else
1012     {
1013       DrawMaskBoardArea (HID_MASK_AFTER, screen);
1014       gui->use_mask (HID_MASK_OFF);
1015     }
1016 }
1017
1018 /* ---------------------------------------------------------------------------
1019  * draws solder paste layer for a given side of the board
1020  */
1021 static void
1022 DrawPaste (int side, const BoxType *drawn_area)
1023 {
1024   gui->set_color (Output.fgGC, PCB->ElementColor);
1025   ALLPAD_LOOP (PCB->Data);
1026   {
1027     if (ON_SIDE (pad, side) && !TEST_FLAG (NOPASTEFLAG, pad) && pad->Mask > 0)
1028       {
1029         if (pad->Mask < pad->Thickness)
1030           _draw_pad (Output.fgGC, pad, true, true);
1031         else
1032           _draw_pad (Output.fgGC, pad, false, false);
1033       }
1034   }
1035   ENDALL_LOOP;
1036 }
1037
1038 static void
1039 DrawRats (const BoxType *drawn_area)
1040 {
1041   /*
1042    * XXX lesstif allows positive AND negative drawing in HID_MASK_CLEAR.
1043    * XXX gtk only allows negative drawing.
1044    * XXX using the mask here is to get rat transparency
1045    */
1046   int can_mask = strcmp(gui->name, "lesstif") == 0;
1047
1048   if (can_mask)
1049     gui->use_mask (HID_MASK_CLEAR);
1050   r_search (PCB->Data->rat_tree, drawn_area, NULL, rat_callback, NULL);
1051   if (can_mask)
1052     gui->use_mask (HID_MASK_OFF);
1053 }
1054
1055 static int
1056 text_callback (const BoxType * b, void *cl)
1057 {
1058   LayerType *layer = cl;
1059   TextType *text = (TextType *)b;
1060   int min_silk_line;
1061
1062   if (TEST_FLAG (SELECTEDFLAG, text))
1063     gui->set_color (Output.fgGC, layer->SelectedColor);
1064   else
1065     gui->set_color (Output.fgGC, layer->Color);
1066   if (layer == &PCB->Data->SILKLAYER ||
1067       layer == &PCB->Data->BACKSILKLAYER)
1068     min_silk_line = PCB->minSlk;
1069   else
1070     min_silk_line = PCB->minWid;
1071   DrawTextLowLevel (text, min_silk_line);
1072   return 1;
1073 }
1074
1075 void
1076 DrawLayer (LayerTypePtr Layer, const BoxType * screen)
1077 {
1078   struct poly_info info = {screen, Layer};
1079
1080   /* print the non-clearing polys */
1081   r_search (Layer->polygon_tree, screen, NULL, poly_callback, &info);
1082
1083   if (TEST_FLAG (CHECKPLANESFLAG, PCB))
1084     return;
1085
1086   /* draw all visible lines this layer */
1087   r_search (Layer->line_tree, screen, NULL, line_callback, Layer);
1088
1089   /* draw the layer arcs on screen */
1090   r_search (Layer->arc_tree, screen, NULL, arc_callback, Layer);
1091
1092   /* draw the layer text on screen */
1093   r_search (Layer->text_tree, screen, NULL, text_callback, Layer);
1094
1095   /* We should check for gui->gui here, but it's kinda cool seeing the
1096      auto-outline magically disappear when you first add something to
1097      the "outline" layer.  */
1098   if (IsLayerEmpty (Layer)
1099       && (strcmp (Layer->Name, "outline") == 0
1100           || strcmp (Layer->Name, "route") == 0))
1101     {
1102       gui->set_color (Output.fgGC, Layer->Color);
1103       gui->set_line_width (Output.fgGC, PCB->minWid);
1104       gui->draw_rect (Output.fgGC,
1105                       0, 0,
1106                       PCB->MaxWidth, PCB->MaxHeight);
1107     }
1108 }
1109
1110 /* ---------------------------------------------------------------------------
1111  * draws one layer group.  If the exporter is not a GUI,
1112  * also draws the pins / pads / vias in this layer group.
1113  */
1114 static void
1115 DrawLayerGroup (int group, const BoxType *drawn_area)
1116 {
1117   int i, rv = 1;
1118   int layernum;
1119   LayerTypePtr Layer;
1120   int n_entries = PCB->LayerGroups.Number[group];
1121   Cardinal *layers = PCB->LayerGroups.Entries[group];
1122
1123   for (i = n_entries - 1; i >= 0; i--)
1124     {
1125       layernum = layers[i];
1126       Layer = PCB->Data->Layer + layers[i];
1127       if (strcmp (Layer->Name, "outline") == 0 ||
1128           strcmp (Layer->Name, "route") == 0)
1129         rv = 0;
1130       if (layernum < max_copper_layer && Layer->On)
1131         DrawLayer (Layer, drawn_area);
1132     }
1133   if (n_entries > 1)
1134     rv = 1;
1135
1136   if (rv && !gui->gui)
1137     DrawPPV (group, drawn_area);
1138 }
1139
1140 static void
1141 GatherPVName (PinTypePtr Ptr)
1142 {
1143   BoxType box;
1144   bool vert = TEST_FLAG (EDGE2FLAG, Ptr);
1145
1146   if (vert)
1147     {
1148       box.X1 = Ptr->X - Ptr->Thickness / 2 + Settings.PinoutTextOffsetY;
1149       box.Y1 = Ptr->Y - Ptr->DrillingHole / 2 - Settings.PinoutTextOffsetX;
1150     }
1151   else
1152     {
1153       box.X1 = Ptr->X + Ptr->DrillingHole / 2 + Settings.PinoutTextOffsetX;
1154       box.Y1 = Ptr->Y - Ptr->Thickness / 2 + Settings.PinoutTextOffsetY;
1155     }
1156
1157   if (vert)
1158     {
1159       box.X2 = box.X1;
1160       box.Y2 = box.Y1;
1161     }
1162   else
1163     {
1164       box.X2 = box.X1;
1165       box.Y2 = box.Y1;
1166     }
1167   AddPart (&box);
1168 }
1169
1170 static void
1171 GatherPadName (PadTypePtr Pad)
1172 {
1173   BoxType box;
1174   bool vert;
1175
1176   /* should text be vertical ? */
1177   vert = (Pad->Point1.X == Pad->Point2.X);
1178
1179   if (vert)
1180     {
1181       box.X1 = Pad->Point1.X                      - Pad->Thickness / 2;
1182       box.Y1 = MAX (Pad->Point1.Y, Pad->Point2.Y) + Pad->Thickness / 2;
1183       box.X1 += Settings.PinoutTextOffsetY;
1184       box.Y1 -= Settings.PinoutTextOffsetX;
1185       box.X2 = box.X1;
1186       box.Y2 = box.Y1;
1187     }
1188   else
1189     {
1190       box.X1 = MIN (Pad->Point1.X, Pad->Point2.X) - Pad->Thickness / 2;
1191       box.Y1 = Pad->Point1.Y                      - Pad->Thickness / 2;
1192       box.X1 += Settings.PinoutTextOffsetX;
1193       box.Y1 += Settings.PinoutTextOffsetY;
1194       box.X2 = box.X1;
1195       box.Y2 = box.Y1;
1196     }
1197
1198   AddPart (&box);
1199   return;
1200 }
1201
1202 /* ---------------------------------------------------------------------------
1203  * lowlevel drawing routine for text objects
1204  */
1205 void
1206 DrawTextLowLevel (TextTypePtr Text, Coord min_line_width)
1207 {
1208   Coord x = 0;
1209   unsigned char *string = (unsigned char *) Text->TextString;
1210   Cardinal n;
1211   FontTypePtr font = &PCB->Font;
1212
1213   while (string && *string)
1214     {
1215       /* draw lines if symbol is valid and data is present */
1216       if (*string <= MAX_FONTPOSITION && font->Symbol[*string].Valid)
1217         {
1218           LineTypePtr line = font->Symbol[*string].Line;
1219           LineType newline;
1220
1221           for (n = font->Symbol[*string].LineN; n; n--, line++)
1222             {
1223               /* create one line, scale, move, rotate and swap it */
1224               newline = *line;
1225               newline.Point1.X = SCALE_TEXT (newline.Point1.X + x, Text->Scale);
1226               newline.Point1.Y = SCALE_TEXT (newline.Point1.Y, Text->Scale);
1227               newline.Point2.X = SCALE_TEXT (newline.Point2.X + x, Text->Scale);
1228               newline.Point2.Y = SCALE_TEXT (newline.Point2.Y, Text->Scale);
1229               newline.Thickness = SCALE_TEXT (newline.Thickness, Text->Scale / 2);
1230               if (newline.Thickness < min_line_width)
1231                 newline.Thickness = min_line_width;
1232
1233               RotateLineLowLevel (&newline, 0, 0, Text->Direction);
1234
1235               /* the labels of SMD objects on the bottom
1236                * side haven't been swapped yet, only their offset
1237                */
1238               if (TEST_FLAG (ONSOLDERFLAG, Text))
1239                 {
1240                   newline.Point1.X = SWAP_SIGN_X (newline.Point1.X);
1241                   newline.Point1.Y = SWAP_SIGN_Y (newline.Point1.Y);
1242                   newline.Point2.X = SWAP_SIGN_X (newline.Point2.X);
1243                   newline.Point2.Y = SWAP_SIGN_Y (newline.Point2.Y);
1244                 }
1245               /* add offset and draw line */
1246               newline.Point1.X += Text->X;
1247               newline.Point1.Y += Text->Y;
1248               newline.Point2.X += Text->X;
1249               newline.Point2.Y += Text->Y;
1250               _draw_line (&newline);
1251             }
1252
1253           /* move on to next cursor position */
1254           x += (font->Symbol[*string].Width + font->Symbol[*string].Delta);
1255         }
1256       else
1257         {
1258           /* the default symbol is a filled box */
1259           BoxType defaultsymbol = PCB->Font.DefaultSymbol;
1260           Coord size = (defaultsymbol.X2 - defaultsymbol.X1) * 6 / 5;
1261
1262           defaultsymbol.X1 = SCALE_TEXT (defaultsymbol.X1 + x, Text->Scale);
1263           defaultsymbol.Y1 = SCALE_TEXT (defaultsymbol.Y1, Text->Scale);
1264           defaultsymbol.X2 = SCALE_TEXT (defaultsymbol.X2 + x, Text->Scale);
1265           defaultsymbol.Y2 = SCALE_TEXT (defaultsymbol.Y2, Text->Scale);
1266
1267           RotateBoxLowLevel (&defaultsymbol, 0, 0, Text->Direction);
1268
1269           /* add offset and draw box */
1270           defaultsymbol.X1 += Text->X;
1271           defaultsymbol.Y1 += Text->Y;
1272           defaultsymbol.X2 += Text->X;
1273           defaultsymbol.Y2 += Text->Y;
1274           gui->fill_rect (Output.fgGC,
1275                           defaultsymbol.X1, defaultsymbol.Y1,
1276                           defaultsymbol.X2, defaultsymbol.Y2);
1277
1278           /* move on to next cursor position */
1279           x += size;
1280         }
1281       string++;
1282     }
1283 }
1284
1285 /* ---------------------------------------------------------------------------
1286  * draw a via object
1287  */
1288 void
1289 DrawVia (PinTypePtr Via)
1290 {
1291   AddPart (Via);
1292   if (!TEST_FLAG (HOLEFLAG, Via) && TEST_FLAG (DISPLAYNAMEFLAG, Via))
1293     DrawViaName (Via);
1294 }
1295
1296 /* ---------------------------------------------------------------------------
1297  * draws the name of a via
1298  */
1299 void
1300 DrawViaName (PinTypePtr Via)
1301 {
1302   GatherPVName (Via);
1303 }
1304
1305 /* ---------------------------------------------------------------------------
1306  * draw a pin object
1307  */
1308 void
1309 DrawPin (PinTypePtr Pin)
1310 {
1311   AddPart (Pin);
1312   if ((!TEST_FLAG (HOLEFLAG, Pin) && TEST_FLAG (DISPLAYNAMEFLAG, Pin))
1313       || doing_pinout)
1314     DrawPinName (Pin);
1315 }
1316
1317 /* ---------------------------------------------------------------------------
1318  * draws the name of a pin
1319  */
1320 void
1321 DrawPinName (PinTypePtr Pin)
1322 {
1323   GatherPVName (Pin);
1324 }
1325
1326 /* ---------------------------------------------------------------------------
1327  * draw a pad object
1328  */
1329 void
1330 DrawPad (PadTypePtr Pad)
1331 {
1332   AddPart (Pad);
1333   if (doing_pinout || TEST_FLAG (DISPLAYNAMEFLAG, Pad))
1334     DrawPadName (Pad);
1335 }
1336
1337 /* ---------------------------------------------------------------------------
1338  * draws the name of a pad
1339  */
1340 void
1341 DrawPadName (PadTypePtr Pad)
1342 {
1343   GatherPadName (Pad);
1344 }
1345
1346 /* ---------------------------------------------------------------------------
1347  * draws a line on a layer
1348  */
1349 void
1350 DrawLine (LayerTypePtr Layer, LineTypePtr Line)
1351 {
1352   AddPart (Line);
1353 }
1354
1355 /* ---------------------------------------------------------------------------
1356  * draws a ratline
1357  */
1358 void
1359 DrawRat (RatTypePtr Rat)
1360 {
1361   if (Settings.RatThickness < 20)
1362     Rat->Thickness = pixel_slop * Settings.RatThickness;
1363   /* rats.c set VIAFLAG if this rat goes to a containing poly: draw a donut */
1364   if (TEST_FLAG(VIAFLAG, Rat))
1365     {
1366       Coord w = Rat->Thickness;
1367
1368       BoxType b;
1369
1370       b.X1 = Rat->Point1.X - w * 2 - w / 2;
1371       b.X2 = Rat->Point1.X + w * 2 + w / 2;
1372       b.Y1 = Rat->Point1.Y - w * 2 - w / 2;
1373       b.Y2 = Rat->Point1.Y + w * 2 + w / 2;
1374       AddPart (&b);
1375     }
1376   else
1377     DrawLine (NULL, (LineType *)Rat);
1378 }
1379
1380 /* ---------------------------------------------------------------------------
1381  * draws an arc on a layer
1382  */
1383 void
1384 DrawArc (LayerTypePtr Layer, ArcTypePtr Arc)
1385 {
1386   AddPart (Arc);
1387 }
1388
1389 /* ---------------------------------------------------------------------------
1390  * draws a text on a layer
1391  */
1392 void
1393 DrawText (LayerTypePtr Layer, TextTypePtr Text)
1394 {
1395   AddPart (Text);
1396 }
1397
1398
1399 /* ---------------------------------------------------------------------------
1400  * draws a polygon on a layer
1401  */
1402 void
1403 DrawPolygon (LayerTypePtr Layer, PolygonTypePtr Polygon)
1404 {
1405   AddPart (Polygon);
1406 }
1407
1408 /* ---------------------------------------------------------------------------
1409  * draws an element
1410  */
1411 void
1412 DrawElement (ElementTypePtr Element)
1413 {
1414   DrawElementPackage (Element);
1415   DrawElementName (Element);
1416   DrawElementPinsAndPads (Element);
1417 }
1418
1419 /* ---------------------------------------------------------------------------
1420  * draws the name of an element
1421  */
1422 void
1423 DrawElementName (ElementTypePtr Element)
1424 {
1425   if (TEST_FLAG (HIDENAMEFLAG, Element))
1426     return;
1427   DrawText (NULL, &ELEMENT_TEXT (PCB, Element));
1428 }
1429
1430 /* ---------------------------------------------------------------------------
1431  * draws the package of an element
1432  */
1433 void
1434 DrawElementPackage (ElementTypePtr Element)
1435 {
1436   ELEMENTLINE_LOOP (Element);
1437   {
1438     DrawLine (NULL, line);
1439   }
1440   END_LOOP;
1441   ARC_LOOP (Element);
1442   {
1443     DrawArc (NULL, arc);
1444   }
1445   END_LOOP;
1446 }
1447
1448 /* ---------------------------------------------------------------------------
1449  * draw pins of an element
1450  */
1451 void
1452 DrawElementPinsAndPads (ElementTypePtr Element)
1453 {
1454   PAD_LOOP (Element);
1455   {
1456     if (doing_pinout || doing_assy || FRONT (pad) || PCB->InvisibleObjectsOn)
1457       DrawPad (pad);
1458   }
1459   END_LOOP;
1460   PIN_LOOP (Element);
1461   {
1462     DrawPin (pin);
1463   }
1464   END_LOOP;
1465 }
1466
1467 /* ---------------------------------------------------------------------------
1468  * erase a via
1469  */
1470 void
1471 EraseVia (PinTypePtr Via)
1472 {
1473   AddPart (Via);
1474   if (TEST_FLAG (DISPLAYNAMEFLAG, Via))
1475     EraseViaName (Via);
1476 }
1477
1478 /* ---------------------------------------------------------------------------
1479  * erase a ratline
1480  */
1481 void
1482 EraseRat (RatTypePtr Rat)
1483 {
1484   if (TEST_FLAG(VIAFLAG, Rat))
1485     {
1486       Coord w = Rat->Thickness;
1487
1488       BoxType b;
1489
1490       b.X1 = Rat->Point1.X - w * 2 - w / 2;
1491       b.X2 = Rat->Point1.X + w * 2 + w / 2;
1492       b.Y1 = Rat->Point1.Y - w * 2 - w / 2;
1493       b.Y2 = Rat->Point1.Y + w * 2 + w / 2;
1494       AddPart (&b);
1495     }
1496   else
1497     EraseLine ((LineType *)Rat);
1498 }
1499
1500
1501 /* ---------------------------------------------------------------------------
1502  * erase a via name
1503  */
1504 void
1505 EraseViaName (PinTypePtr Via)
1506 {
1507   GatherPVName (Via);
1508 }
1509
1510 /* ---------------------------------------------------------------------------
1511  * erase a pad object
1512  */
1513 void
1514 ErasePad (PadTypePtr Pad)
1515 {
1516   AddPart (Pad);
1517   if (TEST_FLAG (DISPLAYNAMEFLAG, Pad))
1518     ErasePadName (Pad);
1519 }
1520
1521 /* ---------------------------------------------------------------------------
1522  * erase a pad name
1523  */
1524 void
1525 ErasePadName (PadTypePtr Pad)
1526 {
1527   GatherPadName (Pad);
1528 }
1529
1530 /* ---------------------------------------------------------------------------
1531  * erase a pin object
1532  */
1533 void
1534 ErasePin (PinTypePtr Pin)
1535 {
1536   AddPart (Pin);
1537   if (TEST_FLAG (DISPLAYNAMEFLAG, Pin))
1538     ErasePinName (Pin);
1539 }
1540
1541 /* ---------------------------------------------------------------------------
1542  * erase a pin name
1543  */
1544 void
1545 ErasePinName (PinTypePtr Pin)
1546 {
1547   GatherPVName (Pin);
1548 }
1549
1550 /* ---------------------------------------------------------------------------
1551  * erases a line on a layer
1552  */
1553 void
1554 EraseLine (LineTypePtr Line)
1555 {
1556   AddPart (Line);
1557 }
1558
1559 /* ---------------------------------------------------------------------------
1560  * erases an arc on a layer
1561  */
1562 void
1563 EraseArc (ArcTypePtr Arc)
1564 {
1565   if (!Arc->Thickness)
1566     return;
1567   AddPart (Arc);
1568 }
1569
1570 /* ---------------------------------------------------------------------------
1571  * erases a text on a layer
1572  */
1573 void
1574 EraseText (LayerTypePtr Layer, TextTypePtr Text)
1575 {
1576   AddPart (Text);
1577 }
1578
1579 /* ---------------------------------------------------------------------------
1580  * erases a polygon on a layer
1581  */
1582 void
1583 ErasePolygon (PolygonTypePtr Polygon)
1584 {
1585   AddPart (Polygon);
1586 }
1587
1588 /* ---------------------------------------------------------------------------
1589  * erases an element
1590  */
1591 void
1592 EraseElement (ElementTypePtr Element)
1593 {
1594   ELEMENTLINE_LOOP (Element);
1595   {
1596     EraseLine (line);
1597   }
1598   END_LOOP;
1599   ARC_LOOP (Element);
1600   {
1601     EraseArc (arc);
1602   }
1603   END_LOOP;
1604   EraseElementName (Element);
1605   EraseElementPinsAndPads (Element);
1606 }
1607
1608 /* ---------------------------------------------------------------------------
1609  * erases all pins and pads of an element
1610  */
1611 void
1612 EraseElementPinsAndPads (ElementTypePtr Element)
1613 {
1614   PIN_LOOP (Element);
1615   {
1616     ErasePin (pin);
1617   }
1618   END_LOOP;
1619   PAD_LOOP (Element);
1620   {
1621     ErasePad (pad);
1622   }
1623   END_LOOP;
1624 }
1625
1626 /* ---------------------------------------------------------------------------
1627  * erases the name of an element
1628  */
1629 void
1630 EraseElementName (ElementTypePtr Element)
1631 {
1632   if (TEST_FLAG (HIDENAMEFLAG, Element))
1633     return;
1634   DrawText (NULL, &ELEMENT_TEXT (PCB, Element));
1635 }
1636
1637
1638 void
1639 EraseObject (int type, void *lptr, void *ptr)
1640 {
1641   switch (type)
1642     {
1643     case VIA_TYPE:
1644     case PIN_TYPE:
1645       ErasePin ((PinTypePtr) ptr);
1646       break;
1647     case TEXT_TYPE:
1648     case ELEMENTNAME_TYPE:
1649       EraseText ((LayerTypePtr)lptr, (TextTypePtr) ptr);
1650       break;
1651     case POLYGON_TYPE:
1652       ErasePolygon ((PolygonTypePtr) ptr);
1653       break;
1654     case ELEMENT_TYPE:
1655       EraseElement ((ElementTypePtr) ptr);
1656       break;
1657     case LINE_TYPE:
1658     case ELEMENTLINE_TYPE:
1659     case RATLINE_TYPE:
1660       EraseLine ((LineTypePtr) ptr);
1661       break;
1662     case PAD_TYPE:
1663       ErasePad ((PadTypePtr) ptr);
1664       break;
1665     case ARC_TYPE:
1666     case ELEMENTARC_TYPE:
1667       EraseArc ((ArcTypePtr) ptr);
1668       break;
1669     default:
1670       Message ("hace: Internal ERROR, trying to erase an unknown type\n");
1671     }
1672 }
1673
1674
1675
1676 void
1677 DrawObject (int type, void *ptr1, void *ptr2)
1678 {
1679   switch (type)
1680     {
1681     case VIA_TYPE:
1682       if (PCB->ViaOn)
1683         DrawVia ((PinTypePtr) ptr2);
1684       break;
1685     case LINE_TYPE:
1686       if (((LayerTypePtr) ptr1)->On)
1687         DrawLine ((LayerTypePtr) ptr1, (LineTypePtr) ptr2);
1688       break;
1689     case ARC_TYPE:
1690       if (((LayerTypePtr) ptr1)->On)
1691         DrawArc ((LayerTypePtr) ptr1, (ArcTypePtr) ptr2);
1692       break;
1693     case TEXT_TYPE:
1694       if (((LayerTypePtr) ptr1)->On)
1695         DrawText ((LayerTypePtr) ptr1, (TextTypePtr) ptr2);
1696       break;
1697     case POLYGON_TYPE:
1698       if (((LayerTypePtr) ptr1)->On)
1699         DrawPolygon ((LayerTypePtr) ptr1, (PolygonTypePtr) ptr2);
1700       break;
1701     case ELEMENT_TYPE:
1702       if (PCB->ElementOn &&
1703           (FRONT ((ElementTypePtr) ptr2) || PCB->InvisibleObjectsOn))
1704         DrawElement ((ElementTypePtr) ptr2);
1705       break;
1706     case RATLINE_TYPE:
1707       if (PCB->RatOn)
1708         DrawRat ((RatTypePtr) ptr2);
1709       break;
1710     case PIN_TYPE:
1711       if (PCB->PinOn)
1712         DrawPin ((PinTypePtr) ptr2);
1713       break;
1714     case PAD_TYPE:
1715       if (PCB->PinOn)
1716         DrawPad ((PadTypePtr) ptr2);
1717       break;
1718     case ELEMENTNAME_TYPE:
1719       if (PCB->ElementOn &&
1720           (FRONT ((ElementTypePtr) ptr2) || PCB->InvisibleObjectsOn))
1721         DrawElementName ((ElementTypePtr) ptr1);
1722       break;
1723     }
1724 }
1725
1726 static void
1727 draw_element (ElementTypePtr element)
1728 {
1729   draw_element_package (element);
1730   draw_element_name (element);
1731   draw_element_pins_and_pads (element);
1732 }
1733
1734 /* ---------------------------------------------------------------------------
1735  * HID drawing callback.
1736  */
1737
1738 void
1739 hid_expose_callback (HID * hid, BoxType * region, void *item)
1740 {
1741   HID *old_gui = gui;
1742
1743   gui = hid;
1744   Output.fgGC = gui->make_gc ();
1745   Output.bgGC = gui->make_gc ();
1746   Output.pmGC = gui->make_gc ();
1747
1748   hid->set_color (Output.pmGC, "erase");
1749   hid->set_color (Output.bgGC, "drill");
1750
1751   if (item)
1752     {
1753       doing_pinout = true;
1754       draw_element ((ElementType *)item);
1755       doing_pinout = false;
1756     }
1757   else
1758     DrawEverything (region);
1759
1760   gui->destroy_gc (Output.fgGC);
1761   gui->destroy_gc (Output.bgGC);
1762   gui->destroy_gc (Output.pmGC);
1763   gui = old_gui;
1764 }