src/draw.c

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