Index: draw_helpers.c
===================================================================
--- draw_helpers.c	(revision 1021)
+++ draw_helpers.c	(revision 1022)
@@ -2,105 +2,95 @@
 #include "hid.h"
 #include "polygon.h"
 
-static void
-fill_contour (hidGC gc, PLINE *pl)
+static void fill_contour(hidGC gc, PLINE * pl)
 {
-  Coord *x, *y, n, i = 0;
-  VNODE *v;
+	Coord *x, *y, n, i = 0;
+	VNODE *v;
 
-  n = pl->Count;
-  x = (Coord *)malloc (n * sizeof (*x));
-  y = (Coord *)malloc (n * sizeof (*y));
+	n = pl->Count;
+	x = (Coord *) malloc(n * sizeof(*x));
+	y = (Coord *) malloc(n * sizeof(*y));
 
-  for (v = &pl->head; i < n; v = v->next)
-    {
-      x[i] = v->point[0];
-      y[i++] = v->point[1];
-    }
+	for (v = &pl->head; i < n; v = v->next) {
+		x[i] = v->point[0];
+		y[i++] = v->point[1];
+	}
 
-  gui->fill_polygon (gc, n, x, y);
+	gui->fill_polygon(gc, n, x, y);
 
-  free (x);
-  free (y);
+	free(x);
+	free(y);
 }
 
-static void
-thindraw_contour (hidGC gc, PLINE *pl)
+static void thindraw_contour(hidGC gc, PLINE * pl)
 {
-  VNODE *v;
-  Coord last_x, last_y;
-  Coord this_x, this_y;
+	VNODE *v;
+	Coord last_x, last_y;
+	Coord this_x, this_y;
 
-  gui->set_line_width (gc, 0);
-  gui->set_line_cap (gc, Round_Cap);
+	gui->set_line_width(gc, 0);
+	gui->set_line_cap(gc, Round_Cap);
 
-  /* If the contour is round, use an arc drawing routine. */
-  if (pl->is_round)
-    {
-      gui->draw_arc (gc, pl->cx, pl->cy, pl->radius, pl->radius, 0, 360);
-      return;
-    }
+	/* If the contour is round, use an arc drawing routine. */
+	if (pl->is_round) {
+		gui->draw_arc(gc, pl->cx, pl->cy, pl->radius, pl->radius, 0, 360);
+		return;
+	}
 
-  /* Need at least two points in the contour */
-  if (pl->head.next == NULL)
-    return;
+	/* Need at least two points in the contour */
+	if (pl->head.next == NULL)
+		return;
 
-  last_x = pl->head.point[0];
-  last_y = pl->head.point[1];
-  v = pl->head.next;
+	last_x = pl->head.point[0];
+	last_y = pl->head.point[1];
+	v = pl->head.next;
 
-  do
-    {
-      this_x = v->point[0];
-      this_y = v->point[1];
+	do {
+		this_x = v->point[0];
+		this_y = v->point[1];
 
-      gui->draw_line (gc, last_x, last_y, this_x, this_y);
-      /* gui->fill_circle (gc, this_x, this_y, 30); */
+		gui->draw_line(gc, last_x, last_y, this_x, this_y);
+		/* gui->fill_circle (gc, this_x, this_y, 30); */
 
-      last_x = this_x;
-      last_y = this_y;
-    }
-  while ((v = v->next) != pl->head.next);
+		last_x = this_x;
+		last_y = this_y;
+	}
+	while ((v = v->next) != pl->head.next);
 }
 
-static void
-fill_contour_cb (PLINE *pl, void *user_data)
+static void fill_contour_cb(PLINE * pl, void *user_data)
 {
-  hidGC gc = (hidGC)user_data;
-  PLINE *local_pl = pl;
+	hidGC gc = (hidGC) user_data;
+	PLINE *local_pl = pl;
 
-  fill_contour (gc, pl);
-  poly_FreeContours (&local_pl);
+	fill_contour(gc, pl);
+	poly_FreeContours(&local_pl);
 }
 
-static void
-fill_clipped_contour (hidGC gc, PLINE *pl, const BoxType *clip_box)
+static void fill_clipped_contour(hidGC gc, PLINE * pl, const BoxType * clip_box)
 {
-  PLINE *pl_copy;
-  POLYAREA *clip_poly;
-  POLYAREA *piece_poly;
-  POLYAREA *clipped_pieces;
-  POLYAREA *draw_piece;
-  int x;
+	PLINE *pl_copy;
+	POLYAREA *clip_poly;
+	POLYAREA *piece_poly;
+	POLYAREA *clipped_pieces;
+	POLYAREA *draw_piece;
+	int x;
 
-  clip_poly = RectPoly (clip_box->X1, clip_box->X2,
-                        clip_box->Y1, clip_box->Y2);
-  poly_CopyContour (&pl_copy, pl);
-  piece_poly = poly_Create ();
-  poly_InclContour (piece_poly, pl_copy);
-  x = poly_Boolean_free (piece_poly, clip_poly,
-                         &clipped_pieces, PBO_ISECT);
-  if (x != err_ok || clipped_pieces == NULL)
-    return;
+	clip_poly = RectPoly(clip_box->X1, clip_box->X2, clip_box->Y1, clip_box->Y2);
+	poly_CopyContour(&pl_copy, pl);
+	piece_poly = poly_Create();
+	poly_InclContour(piece_poly, pl_copy);
+	x = poly_Boolean_free(piece_poly, clip_poly, &clipped_pieces, PBO_ISECT);
+	if (x != err_ok || clipped_pieces == NULL)
+		return;
 
-  draw_piece = clipped_pieces;
-  do
-    {
-      /* NB: The polygon won't have any holes in it */
-      fill_contour (gc, draw_piece->contours);
-    }
-  while ((draw_piece = draw_piece->f) != clipped_pieces);
-  poly_Free (&clipped_pieces);
+	draw_piece = clipped_pieces;
+	do {
+		/* NB: The polygon won't have any holes in it */
+		fill_contour(gc, draw_piece->contours);
+	}
+	while ((draw_piece = draw_piece->f) != clipped_pieces);
+	poly_Free(&clipped_pieces);
 }
 
 /* If at least 50% of the bounding box of the polygon is on the screen,
@@ -107,196 +97,172 @@
  * lets compute the complete no-holes polygon.
  */
 #define BOUNDS_INSIDE_CLIP_THRESHOLD 0.5
-static int
-should_compute_no_holes (PolygonType *poly, const BoxType *clip_box)
+static int should_compute_no_holes(PolygonType * poly, const BoxType * clip_box)
 {
-  Coord x1, x2, y1, y2;
-  double poly_bounding_area;
-  double clipped_poly_area;
+	Coord x1, x2, y1, y2;
+	double poly_bounding_area;
+	double clipped_poly_area;
 
-  /* If there is no passed clip box, compute the whole thing */
-  if (clip_box == NULL)
-    return 1;
+	/* If there is no passed clip box, compute the whole thing */
+	if (clip_box == NULL)
+		return 1;
 
-  x1 = MAX (poly->BoundingBox.X1, clip_box->X1);
-  x2 = MIN (poly->BoundingBox.X2, clip_box->X2);
-  y1 = MAX (poly->BoundingBox.Y1, clip_box->Y1);
-  y2 = MIN (poly->BoundingBox.Y2, clip_box->Y2);
+	x1 = MAX(poly->BoundingBox.X1, clip_box->X1);
+	x2 = MIN(poly->BoundingBox.X2, clip_box->X2);
+	y1 = MAX(poly->BoundingBox.Y1, clip_box->Y1);
+	y2 = MIN(poly->BoundingBox.Y2, clip_box->Y2);
 
-  /* Check if the polygon is outside the clip box */
-  if ((x2 <= x1) || (y2 <= y1))
-    return 0;
+	/* Check if the polygon is outside the clip box */
+	if ((x2 <= x1) || (y2 <= y1))
+		return 0;
 
-  poly_bounding_area = (double)(poly->BoundingBox.X2 - poly->BoundingBox.X1) *
-                       (double)(poly->BoundingBox.Y2 - poly->BoundingBox.Y1);
+	poly_bounding_area = (double) (poly->BoundingBox.X2 - poly->BoundingBox.X1) *
+		(double) (poly->BoundingBox.Y2 - poly->BoundingBox.Y1);
 
-  clipped_poly_area = (double)(x2 - x1) * (double)(y2 - y1);
+	clipped_poly_area = (double) (x2 - x1) * (double) (y2 - y1);
 
-  if (clipped_poly_area / poly_bounding_area >= BOUNDS_INSIDE_CLIP_THRESHOLD)
-    return 1;
+	if (clipped_poly_area / poly_bounding_area >= BOUNDS_INSIDE_CLIP_THRESHOLD)
+		return 1;
 
-  return 0;
+	return 0;
 }
+
 #undef BOUNDS_INSIDE_CLIP_THRESHOLD
 
-void
-common_fill_pcb_polygon (hidGC gc, PolygonType *poly, const BoxType *clip_box)
+void common_fill_pcb_polygon(hidGC gc, PolygonType * poly, const BoxType * clip_box)
 {
-  if (!poly->NoHolesValid)
-    {
-      /* If enough of the polygon is on-screen, compute the entire
-       * NoHoles version and cache it for later rendering, otherwise
-       * just compute what we need to render now.
-       */
-      if (should_compute_no_holes (poly, clip_box))
-        ComputeNoHoles (poly);
-      else
-        NoHolesPolygonDicer (poly, clip_box, fill_contour_cb, gc);
-    }
-  if (poly->NoHolesValid && poly->NoHoles)
-    {
-      PLINE *pl;
+	if (!poly->NoHolesValid) {
+		/* If enough of the polygon is on-screen, compute the entire
+		 * NoHoles version and cache it for later rendering, otherwise
+		 * just compute what we need to render now.
+		 */
+		if (should_compute_no_holes(poly, clip_box))
+			ComputeNoHoles(poly);
+		else
+			NoHolesPolygonDicer(poly, clip_box, fill_contour_cb, gc);
+	}
+	if (poly->NoHolesValid && poly->NoHoles) {
+		PLINE *pl;
 
-      for (pl = poly->NoHoles; pl != NULL; pl = pl->next)
-        {
-          if (clip_box == NULL)
-            fill_contour (gc, pl);
-          else
-            fill_clipped_contour (gc, pl, clip_box);
-        }
-    }
+		for (pl = poly->NoHoles; pl != NULL; pl = pl->next) {
+			if (clip_box == NULL)
+				fill_contour(gc, pl);
+			else
+				fill_clipped_contour(gc, pl, clip_box);
+		}
+	}
 
-  /* Draw other parts of the polygon if fullpoly flag is set */
-  /* NB: No "NoHoles" cache for these */
-  if (TEST_FLAG (FULLPOLYFLAG, poly))
-    {
-      PolygonType p = *poly;
+	/* Draw other parts of the polygon if fullpoly flag is set */
+	/* NB: No "NoHoles" cache for these */
+	if (TEST_FLAG(FULLPOLYFLAG, poly)) {
+		PolygonType p = *poly;
 
-      for (p.Clipped = poly->Clipped->f;
-           p.Clipped != poly->Clipped;
-           p.Clipped = p.Clipped->f)
-        NoHolesPolygonDicer (&p, clip_box, fill_contour_cb, gc);
-    }
+		for (p.Clipped = poly->Clipped->f; p.Clipped != poly->Clipped; p.Clipped = p.Clipped->f)
+			NoHolesPolygonDicer(&p, clip_box, fill_contour_cb, gc);
+	}
 }
 
-static int
-thindraw_hole_cb (PLINE *pl, void *user_data)
+static int thindraw_hole_cb(PLINE * pl, void *user_data)
 {
-  hidGC gc = (hidGC)user_data;
-  thindraw_contour (gc, pl);
-  return 0;
+	hidGC gc = (hidGC) user_data;
+	thindraw_contour(gc, pl);
+	return 0;
 }
 
-void
-common_thindraw_pcb_polygon (hidGC gc, PolygonType *poly,
-                             const BoxType *clip_box)
+void common_thindraw_pcb_polygon(hidGC gc, PolygonType * poly, const BoxType * clip_box)
 {
-  thindraw_contour (gc, poly->Clipped->contours);
-  PolygonHoles (poly, clip_box, thindraw_hole_cb, gc);
+	thindraw_contour(gc, poly->Clipped->contours);
+	PolygonHoles(poly, clip_box, thindraw_hole_cb, gc);
 }
 
-void
-common_thindraw_pcb_pad (hidGC gc, PadType *pad, bool clear, bool mask)
+void common_thindraw_pcb_pad(hidGC gc, PadType * pad, bool clear, bool mask)
 {
-  Coord w = clear ? (mask ? pad->Mask
-                          : pad->Thickness + pad->Clearance)
-                  : pad->Thickness;
-  Coord x1, y1, x2, y2;
-  Coord t = w / 2;
-  x1 = pad->Point1.X;
-  y1 = pad->Point1.Y;
-  x2 = pad->Point2.X;
-  y2 = pad->Point2.Y;
-  if (x1 > x2 || y1 > y2)
-    {
-      Coord temp_x = x1;
-      Coord temp_y = y1;
-      x1 = x2; x2 = temp_x;
-      y1 = y2; y2 = temp_y;
-    }
-  gui->set_line_cap (gc, Round_Cap);
-  gui->set_line_width (gc, 0);
-  if (TEST_FLAG (SQUAREFLAG, pad))
-    {
-      /* slanted square pad */
-      double tx, ty, theta;
+	Coord w = clear ? (mask ? pad->Mask : pad->Thickness + pad->Clearance)
+		: pad->Thickness;
+	Coord x1, y1, x2, y2;
+	Coord t = w / 2;
+	x1 = pad->Point1.X;
+	y1 = pad->Point1.Y;
+	x2 = pad->Point2.X;
+	y2 = pad->Point2.Y;
+	if (x1 > x2 || y1 > y2) {
+		Coord temp_x = x1;
+		Coord temp_y = y1;
+		x1 = x2;
+		x2 = temp_x;
+		y1 = y2;
+		y2 = temp_y;
+	}
+	gui->set_line_cap(gc, Round_Cap);
+	gui->set_line_width(gc, 0);
+	if (TEST_FLAG(SQUAREFLAG, pad)) {
+		/* slanted square pad */
+		double tx, ty, theta;
 
-      if (x1 == x2 && y1 == y2)
-        theta = 0;
-      else
-        theta = atan2 (y2 - y1, x2 - x1);
+		if (x1 == x2 && y1 == y2)
+			theta = 0;
+		else
+			theta = atan2(y2 - y1, x2 - x1);
 
-      /* T is a vector half a thickness long, in the direction of
-         one of the corners.  */
-      tx = t * cos (theta + M_PI / 4) * sqrt (2.0);
-      ty = t * sin (theta + M_PI / 4) * sqrt (2.0);
+		/* T is a vector half a thickness long, in the direction of
+		   one of the corners.  */
+		tx = t * cos(theta + M_PI / 4) * sqrt(2.0);
+		ty = t * sin(theta + M_PI / 4) * sqrt(2.0);
 
-      gui->draw_line (gc, x1 - tx, y1 - ty, x2 + ty, y2 - tx);
-      gui->draw_line (gc, x2 + ty, y2 - tx, x2 + tx, y2 + ty);
-      gui->draw_line (gc, x2 + tx, y2 + ty, x1 - ty, y1 + tx);
-      gui->draw_line (gc, x1 - ty, y1 + tx, x1 - tx, y1 - ty);
-    }
-  else if (x1 == x2 && y1 == y2)
-    {
-      gui->draw_arc (gc, x1, y1, t, t, 0, 360);
-    }
-  else
-    {
-      /* Slanted round-end pads.  */
-      Coord dx, dy, ox, oy;
-      double h;
+		gui->draw_line(gc, x1 - tx, y1 - ty, x2 + ty, y2 - tx);
+		gui->draw_line(gc, x2 + ty, y2 - tx, x2 + tx, y2 + ty);
+		gui->draw_line(gc, x2 + tx, y2 + ty, x1 - ty, y1 + tx);
+		gui->draw_line(gc, x1 - ty, y1 + tx, x1 - tx, y1 - ty);
+	}
+	else if (x1 == x2 && y1 == y2) {
+		gui->draw_arc(gc, x1, y1, t, t, 0, 360);
+	}
+	else {
+		/* Slanted round-end pads.  */
+		Coord dx, dy, ox, oy;
+		double h;
 
-      dx = x2 - x1;
-      dy = y2 - y1;
-      h = t / sqrt (SQUARE (dx) + SQUARE (dy));
-      ox = dy * h + 0.5 * SGN (dy);
-      oy = -(dx * h + 0.5 * SGN (dx));
+		dx = x2 - x1;
+		dy = y2 - y1;
+		h = t / sqrt(SQUARE(dx) + SQUARE(dy));
+		ox = dy * h + 0.5 * SGN(dy);
+		oy = -(dx * h + 0.5 * SGN(dx));
 
-      gui->draw_line (gc, x1 + ox, y1 + oy, x2 + ox, y2 + oy);
+		gui->draw_line(gc, x1 + ox, y1 + oy, x2 + ox, y2 + oy);
 
-      if (abs (ox) >= pixel_slop || abs (oy) >= pixel_slop)
-        {
-          Angle angle = atan2 (dx, dy) * 57.295779;
-          gui->draw_line (gc, x1 - ox, y1 - oy, x2 - ox, y2 - oy);
-          gui->draw_arc (gc, x1, y1, t, t, angle - 180, 180);
-          gui->draw_arc (gc, x2, y2, t, t, angle, 180);
-        }
-    }
+		if (abs(ox) >= pixel_slop || abs(oy) >= pixel_slop) {
+			Angle angle = atan2(dx, dy) * 57.295779;
+			gui->draw_line(gc, x1 - ox, y1 - oy, x2 - ox, y2 - oy);
+			gui->draw_arc(gc, x1, y1, t, t, angle - 180, 180);
+			gui->draw_arc(gc, x2, y2, t, t, angle, 180);
+		}
+	}
 }
 
-void
-common_fill_pcb_pad (hidGC gc, PadType *pad, bool clear, bool mask)
+void common_fill_pcb_pad(hidGC gc, PadType * pad, bool clear, bool mask)
 {
-  Coord w = clear ? (mask ? pad->Mask
-                          : pad->Thickness + pad->Clearance)
-                  : pad->Thickness;
+	Coord w = clear ? (mask ? pad->Mask : pad->Thickness + pad->Clearance)
+		: pad->Thickness;
 
-  if (pad->Point1.X == pad->Point2.X &&
-      pad->Point1.Y == pad->Point2.Y)
-    {
-      if (TEST_FLAG (SQUAREFLAG, pad))
-        {
-          Coord l, r, t, b;
-          l = pad->Point1.X - w / 2;
-          b = pad->Point1.Y - w / 2;
-          r = l + w;
-          t = b + w;
-          gui->fill_rect (gc, l, b, r, t);
-        }
-      else
-        {
-          gui->fill_circle (gc, pad->Point1.X, pad->Point1.Y, w / 2);
-        }
-    }
-  else
-    {
-      gui->set_line_cap (gc, TEST_FLAG (SQUAREFLAG, pad) ?
-                               Square_Cap : Round_Cap);
-      gui->set_line_width (gc, w);
+	if (pad->Point1.X == pad->Point2.X && pad->Point1.Y == pad->Point2.Y) {
+		if (TEST_FLAG(SQUAREFLAG, pad)) {
+			Coord l, r, t, b;
+			l = pad->Point1.X - w / 2;
+			b = pad->Point1.Y - w / 2;
+			r = l + w;
+			t = b + w;
+			gui->fill_rect(gc, l, b, r, t);
+		}
+		else {
+			gui->fill_circle(gc, pad->Point1.X, pad->Point1.Y, w / 2);
+		}
+	}
+	else {
+		gui->set_line_cap(gc, TEST_FLAG(SQUAREFLAG, pad) ? Square_Cap : Round_Cap);
+		gui->set_line_width(gc, w);
 
-      gui->draw_line (gc, pad->Point1.X, pad->Point1.Y,
-                          pad->Point2.X, pad->Point2.Y);
-    }
+		gui->draw_line(gc, pad->Point1.X, pad->Point1.Y, pad->Point2.X, pad->Point2.Y);
+	}
 }
 
 /* ---------------------------------------------------------------------------
@@ -313,181 +279,158 @@
  *          2 --- 1
  */
 
-typedef struct
-{
-  double X, Y;
-}
-FloatPolyType;
+typedef struct {
+	double X, Y;
+} FloatPolyType;
 
-static void
-draw_square_pin_poly (hidGC gc, Coord X, Coord Y,
-                   Coord Thickness, Coord thin_draw, int style)
+static void draw_square_pin_poly(hidGC gc, Coord X, Coord Y, Coord Thickness, Coord thin_draw, int style)
 {
-  static FloatPolyType p[8] = {
-    { 0.5,               -TAN_22_5_DEGREE_2},
-    { TAN_22_5_DEGREE_2, -0.5              },
-    {-TAN_22_5_DEGREE_2, -0.5              },
-    {-0.5,               -TAN_22_5_DEGREE_2},
-    {-0.5,                TAN_22_5_DEGREE_2},
-    {-TAN_22_5_DEGREE_2,  0.5              },
-    { TAN_22_5_DEGREE_2,  0.5              },
-    { 0.5,                TAN_22_5_DEGREE_2}
-  };
-  static int special_size = 0;
-  static int scaled_x[8];
-  static int scaled_y[8];
-  Coord polygon_x[9];
-  Coord polygon_y[9];
-  double xm[8], ym[8];
-  int i;
+	static FloatPolyType p[8] = {
+		{0.5, -TAN_22_5_DEGREE_2},
+		{TAN_22_5_DEGREE_2, -0.5},
+		{-TAN_22_5_DEGREE_2, -0.5},
+		{-0.5, -TAN_22_5_DEGREE_2},
+		{-0.5, TAN_22_5_DEGREE_2},
+		{-TAN_22_5_DEGREE_2, 0.5},
+		{TAN_22_5_DEGREE_2, 0.5},
+		{0.5, TAN_22_5_DEGREE_2}
+	};
+	static int special_size = 0;
+	static int scaled_x[8];
+	static int scaled_y[8];
+	Coord polygon_x[9];
+	Coord polygon_y[9];
+	double xm[8], ym[8];
+	int i;
 
 	square_pin_factors(style, xm, ym);
 
-  if (Thickness != special_size)
-    {
-      special_size = Thickness;
-      for (i = 0; i < 8; i++)
-        {
-          scaled_x[i] = p[i].X * special_size;
-          scaled_y[i] = p[i].Y * special_size;
-        }
-    }
-  /* add line offset */
-  for (i = 0; i < 8; i++)
-    {
-      polygon_x[i] = X + scaled_x[i]*xm[i];
-      polygon_y[i] = Y + scaled_y[i]*ym[i];
-    }
+	if (Thickness != special_size) {
+		special_size = Thickness;
+		for (i = 0; i < 8; i++) {
+			scaled_x[i] = p[i].X * special_size;
+			scaled_y[i] = p[i].Y * special_size;
+		}
+	}
+	/* add line offset */
+	for (i = 0; i < 8; i++) {
+		polygon_x[i] = X + scaled_x[i] * xm[i];
+		polygon_y[i] = Y + scaled_y[i] * ym[i];
+	}
 
-  if (thin_draw)
-    {
-      int i;
-      gui->set_line_cap (gc, Round_Cap);
-      gui->set_line_width (gc, 0);
-      polygon_x[8] = X + scaled_x[0]*xm[0];
-      polygon_y[8] = Y + scaled_y[0]*ym[0];
-      for (i = 0; i < 8; i++)
-        gui->draw_line (gc, polygon_x[i    ], polygon_y[i    ],
-                            polygon_x[i + 1], polygon_y[i + 1]);
-    }
-  else
-    gui->fill_polygon (gc, 8, polygon_x, polygon_y);
+	if (thin_draw) {
+		int i;
+		gui->set_line_cap(gc, Round_Cap);
+		gui->set_line_width(gc, 0);
+		polygon_x[8] = X + scaled_x[0] * xm[0];
+		polygon_y[8] = Y + scaled_y[0] * ym[0];
+		for (i = 0; i < 8; i++)
+			gui->draw_line(gc, polygon_x[i], polygon_y[i], polygon_x[i + 1], polygon_y[i + 1]);
+	}
+	else
+		gui->fill_polygon(gc, 8, polygon_x, polygon_y);
 }
 
-static void
-draw_octagon_poly (hidGC gc, Coord X, Coord Y,
-                   Coord Thickness, Coord thin_draw)
+static void draw_octagon_poly(hidGC gc, Coord X, Coord Y, Coord Thickness, Coord thin_draw)
 {
-	draw_square_pin_poly (gc, X, Y, Thickness, thin_draw, 17);
+	draw_square_pin_poly(gc, X, Y, Thickness, thin_draw, 17);
 }
 
 
-void
-common_fill_pcb_pv (hidGC fg_gc, hidGC bg_gc, PinType *pv, bool drawHole, bool mask)
+void common_fill_pcb_pv(hidGC fg_gc, hidGC bg_gc, PinType * pv, bool drawHole, bool mask)
 {
-  Coord w = mask ? pv->Mask : pv->Thickness;
-  Coord r = w / 2;
+	Coord w = mask ? pv->Mask : pv->Thickness;
+	Coord r = w / 2;
 
-  if (TEST_FLAG (HOLEFLAG, pv))
-    {
-      if (mask)
-	gui->fill_circle (bg_gc, pv->X, pv->Y, r);
-      if (drawHole)
-        {
-          gui->fill_circle (bg_gc, pv->X, pv->Y, r);
-          gui->set_line_cap (fg_gc, Round_Cap);
-          gui->set_line_width (fg_gc, 0);
-          gui->draw_arc (fg_gc, pv->X, pv->Y, r, r, 0, 360);
-        }
-      return;
-    }
+	if (TEST_FLAG(HOLEFLAG, pv)) {
+		if (mask)
+			gui->fill_circle(bg_gc, pv->X, pv->Y, r);
+		if (drawHole) {
+			gui->fill_circle(bg_gc, pv->X, pv->Y, r);
+			gui->set_line_cap(fg_gc, Round_Cap);
+			gui->set_line_width(fg_gc, 0);
+			gui->draw_arc(fg_gc, pv->X, pv->Y, r, r, 0, 360);
+		}
+		return;
+	}
 
-  if (TEST_FLAG (SQUAREFLAG, pv))
-    {
-			/* use the original code for now */
-			if ((GET_SQUARE(pv) == 0) || (GET_SQUARE(pv) == 1)) {
-				Coord l = pv->X - r;
-				Coord b = pv->Y - r;
-				Coord r = l + w;
-				Coord t = b + w;
-				gui->fill_rect (fg_gc, l, b, r, t);
-			}
-			else
-				draw_square_pin_poly (fg_gc, pv->X, pv->Y, w, false, GET_SQUARE(pv));
-    }
-  else if (TEST_FLAG (OCTAGONFLAG, pv))
-    draw_octagon_poly (fg_gc, pv->X, pv->Y, w, false);
-  else /* draw a round pin or via */
-    gui->fill_circle (fg_gc, pv->X, pv->Y, r);
+	if (TEST_FLAG(SQUAREFLAG, pv)) {
+		/* use the original code for now */
+		if ((GET_SQUARE(pv) == 0) || (GET_SQUARE(pv) == 1)) {
+			Coord l = pv->X - r;
+			Coord b = pv->Y - r;
+			Coord r = l + w;
+			Coord t = b + w;
+			gui->fill_rect(fg_gc, l, b, r, t);
+		}
+		else
+			draw_square_pin_poly(fg_gc, pv->X, pv->Y, w, false, GET_SQUARE(pv));
+	}
+	else if (TEST_FLAG(OCTAGONFLAG, pv))
+		draw_octagon_poly(fg_gc, pv->X, pv->Y, w, false);
+	else													/* draw a round pin or via */
+		gui->fill_circle(fg_gc, pv->X, pv->Y, r);
 
-  /* and the drilling hole  (which is always round) */
-  if (drawHole)
-    gui->fill_circle (bg_gc, pv->X, pv->Y, pv->DrillingHole / 2);
+	/* and the drilling hole  (which is always round) */
+	if (drawHole)
+		gui->fill_circle(bg_gc, pv->X, pv->Y, pv->DrillingHole / 2);
 }
 
-void
-common_thindraw_pcb_pv (hidGC fg_gc, hidGC bg_gc, PinType *pv, bool drawHole, bool mask)
+void common_thindraw_pcb_pv(hidGC fg_gc, hidGC bg_gc, PinType * pv, bool drawHole, bool mask)
 {
-  Coord w = mask ? pv->Mask : pv->Thickness;
-  Coord r = w / 2;
+	Coord w = mask ? pv->Mask : pv->Thickness;
+	Coord r = w / 2;
 
-  if (TEST_FLAG (HOLEFLAG, pv))
-    {
-      if (mask)
-	gui->draw_arc (fg_gc, pv->X, pv->Y, r, r, 0, 360);
-      if (drawHole)
-        {
-	  r = pv->DrillingHole / 2;
-          gui->set_line_cap (bg_gc, Round_Cap);
-          gui->set_line_width (bg_gc, 0);
-          gui->draw_arc (bg_gc, pv->X, pv->Y, r, r, 0, 360);
-        }
-      return;
-    }
+	if (TEST_FLAG(HOLEFLAG, pv)) {
+		if (mask)
+			gui->draw_arc(fg_gc, pv->X, pv->Y, r, r, 0, 360);
+		if (drawHole) {
+			r = pv->DrillingHole / 2;
+			gui->set_line_cap(bg_gc, Round_Cap);
+			gui->set_line_width(bg_gc, 0);
+			gui->draw_arc(bg_gc, pv->X, pv->Y, r, r, 0, 360);
+		}
+		return;
+	}
 
-  if (TEST_FLAG (SQUAREFLAG, pv))
-    {
-      Coord l = pv->X - r;
-      Coord b = pv->Y - r;
-      Coord r = l + w;
-      Coord t = b + w;
+	if (TEST_FLAG(SQUAREFLAG, pv)) {
+		Coord l = pv->X - r;
+		Coord b = pv->Y - r;
+		Coord r = l + w;
+		Coord t = b + w;
 
-      gui->set_line_cap (fg_gc, Round_Cap);
-      gui->set_line_width (fg_gc, 0);
-      gui->draw_line (fg_gc, r, t, r, b);
-      gui->draw_line (fg_gc, l, t, l, b);
-      gui->draw_line (fg_gc, r, t, l, t);
-      gui->draw_line (fg_gc, r, b, l, b);
+		gui->set_line_cap(fg_gc, Round_Cap);
+		gui->set_line_width(fg_gc, 0);
+		gui->draw_line(fg_gc, r, t, r, b);
+		gui->draw_line(fg_gc, l, t, l, b);
+		gui->draw_line(fg_gc, r, t, l, t);
+		gui->draw_line(fg_gc, r, b, l, b);
 
-    }
-  else if (TEST_FLAG (OCTAGONFLAG, pv))
-    {
-      draw_octagon_poly (fg_gc, pv->X, pv->Y, w, true);
-    }
-  else /* draw a round pin or via */
-    {
-      gui->set_line_cap (fg_gc, Round_Cap);
-      gui->set_line_width (fg_gc, 0);
-      gui->draw_arc (fg_gc, pv->X, pv->Y, r, r, 0, 360);
-    }
+	}
+	else if (TEST_FLAG(OCTAGONFLAG, pv)) {
+		draw_octagon_poly(fg_gc, pv->X, pv->Y, w, true);
+	}
+	else {												/* draw a round pin or via */
 
-  /* and the drilling hole  (which is always round */
-  if (drawHole)
-    {
-      gui->set_line_cap (bg_gc, Round_Cap);
-      gui->set_line_width (bg_gc, 0);
-      gui->draw_arc (bg_gc, pv->X, pv->Y, pv->DrillingHole / 2,
-                     pv->DrillingHole / 2, 0, 360);
-    }
+		gui->set_line_cap(fg_gc, Round_Cap);
+		gui->set_line_width(fg_gc, 0);
+		gui->draw_arc(fg_gc, pv->X, pv->Y, r, r, 0, 360);
+	}
+
+	/* and the drilling hole  (which is always round */
+	if (drawHole) {
+		gui->set_line_cap(bg_gc, Round_Cap);
+		gui->set_line_width(bg_gc, 0);
+		gui->draw_arc(bg_gc, pv->X, pv->Y, pv->DrillingHole / 2, pv->DrillingHole / 2, 0, 360);
+	}
 }
 
-void
-common_draw_helpers_init (HID *hid)
+void common_draw_helpers_init(HID * hid)
 {
-  hid->fill_pcb_polygon     = common_fill_pcb_polygon;
-  hid->thindraw_pcb_polygon = common_thindraw_pcb_polygon;
-  hid->fill_pcb_pad         = common_fill_pcb_pad;
-  hid->thindraw_pcb_pad     = common_thindraw_pcb_pad;
-  hid->fill_pcb_pv          = common_fill_pcb_pv;
-  hid->thindraw_pcb_pv      = common_thindraw_pcb_pv;
+	hid->fill_pcb_polygon = common_fill_pcb_polygon;
+	hid->thindraw_pcb_polygon = common_thindraw_pcb_polygon;
+	hid->fill_pcb_pad = common_fill_pcb_pad;
+	hid->thindraw_pcb_pad = common_thindraw_pcb_pad;
+	hid->fill_pcb_pv = common_fill_pcb_pv;
+	hid->thindraw_pcb_pv = common_thindraw_pcb_pv;
 }