Index: trunk/doc-rnd/hacking/renames =================================================================== --- trunk/doc-rnd/hacking/renames (revision 4990) +++ trunk/doc-rnd/hacking/renames (revision 4991) @@ -706,3 +706,34 @@ poly_AndSubtract_free -> pcb_polyarea_and_subtract_free poly_bbox -> pcb_polyarea_bbox Savepcb_polyarea_t -> pcb_polyarea_save +polygon_init -> pcb_polygon_init +polygon_point_idx -> pcb_poly_point_idx +polygon_point_contour -> pcb_poly_contour_point +prev_contour_point -> pcb_poly_contour_prev_point +next_contour_point -> pcb_poly_contour_next_point +GetLowestDistancePolygonPoint -> pcb_poly_get_lowest_distance_point +RemoveExcessPolygonPoints -> pcb_poly_remove_excess_points +GoToPreviousPoint -> pcb_polygon_go_to_prev_point +ClosePolygon -> pcb_polygon_close_poly +CopyAttachedPolygonToLayer -> pcb_polygon_copy_attached_to_layer +PolygonHoles -> pcb_poly_holes +PlowsPolygon -> pcb_poly_plows +ComputeNoHoles -> pcb_poly_compute_no_holes +ContourToPoly -> pcb_poly_from_contour +PolygonToPoly -> pcb_poly_from_poly +RectPoly -> pcb_poly_from_rect +CirclePoly -> pcb_poly_from_circle +OctagonPoly -> pcb_poly_from_octagon +LinePoly -> pcb_poly_from_line +ArcPoly -> pcb_poly_from_arc +PinPoly -> pcb_poly_from_pin +BoxPolyBloated -> pcb_poly_from_box_bloated +ContourToPoly -> pcb_poly_from_contour +PolygonToPoly -> pcb_poly_from_poly +RectPoly -> pcb_poly_from_rect +CirclePoly -> pcb_poly_from_circle +OctagonPoly -> pcb_poly_from_octagon +LinePoly -> pcb_poly_from_line +ArcPoly -> pcb_poly_from_arc +PinPoly -> pcb_poly_from_pin +BoxPolyBloated -> pcb_poly_from_box_bloated Index: trunk/src/action_helper.c =================================================================== --- trunk/src/action_helper.c (revision 4990) +++ trunk/src/action_helper.c (revision 4991) @@ -935,7 +935,7 @@ /* check if this is the last point of a polygon */ if (n >= 3 && points[0].X == Crosshair.AttachedLine.Point2.X && points[0].Y == Crosshair.AttachedLine.Point2.Y) { pcb_hid_actionl("Polygon", "Close", NULL); - ClosePolygon(); + pcb_polygon_close_poly(); break; } @@ -1010,8 +1010,8 @@ if (n >= 3 && points[0].X == Crosshair.AttachedLine.Point2.X && points[0].Y == Crosshair.AttachedLine.Point2.Y) { /* Create pcb_polyarea_ts from the original polygon * and the new hole polygon */ - original = PolygonToPoly((pcb_polygon_t *) Crosshair.AttachedObject.Ptr2); - new_hole = PolygonToPoly(&Crosshair.AttachedPolygon); + original = pcb_poly_from_poly((pcb_polygon_t *) Crosshair.AttachedObject.Ptr2); + new_hole = pcb_poly_from_poly(&Crosshair.AttachedPolygon); /* Subtract the hole from the original polygon shape */ pcb_polyarea_boolean_free(original, new_hole, &result, PBO_SUB); @@ -1203,9 +1203,9 @@ /* get starting point of nearest segment */ if (Crosshair.AttachedObject.Type == PCB_TYPE_POLYGON) { fake.poly = (pcb_polygon_t *) Crosshair.AttachedObject.Ptr2; - polyIndex = GetLowestDistancePolygonPoint(fake.poly, Note.X, Note.Y); + polyIndex = pcb_poly_get_lowest_distance_point(fake.poly, Note.X, Note.Y); fake.line.Point1 = fake.poly->Points[polyIndex]; - fake.line.Point2 = fake.poly->Points[prev_contour_point(fake.poly, polyIndex)]; + fake.line.Point2 = fake.poly->Points[pcb_poly_contour_prev_point(fake.poly, polyIndex)]; Crosshair.AttachedObject.Ptr2 = &fake.line; } Index: trunk/src/crosshair.c =================================================================== --- trunk/src/crosshair.c (revision 4990) +++ trunk/src/crosshair.c (revision 4991) @@ -106,7 +106,7 @@ { pcb_cardinal_t i; for (i = 0; i < polygon->PointN; i++) { - pcb_cardinal_t next = next_contour_point(polygon, i); + pcb_cardinal_t next = pcb_poly_contour_next_point(polygon, i); if (next == 0) { /* last line: sometimes the implicit closing line */ if (i == 1) /* corner case: don't draw two lines on top of each other - with XOR it looks bad */ @@ -417,11 +417,11 @@ polygon = (pcb_polygon_t *) Crosshair.AttachedObject.Ptr2; point = (pcb_point_t *) Crosshair.AttachedObject.Ptr3; - point_idx = polygon_point_idx(polygon, point); + point_idx = pcb_poly_point_idx(polygon, point); /* get previous and following point */ - prev = prev_contour_point(polygon, point_idx); - next = next_contour_point(polygon, point_idx); + prev = pcb_poly_contour_prev_point(polygon, point_idx); + next = pcb_poly_contour_next_point(polygon, point_idx); /* draw the two segments */ gui->draw_line(Crosshair.GC, polygon->Points[prev].X, polygon->Points[prev].Y, point->X + dx, point->Y + dy); Index: trunk/src/find_drc.c =================================================================== --- trunk/src/find_drc.c (revision 4990) +++ trunk/src/find_drc.c (revision 4991) @@ -397,7 +397,7 @@ PCB_LINE_COPPER_LOOP(PCB->Data); { /* check line clearances in polygons */ - PlowsPolygon(PCB->Data, PCB_TYPE_LINE, layer, line, drc_callback); + pcb_poly_plows(PCB->Data, PCB_TYPE_LINE, layer, line, drc_callback); if (IsBad) break; if (line->Thickness < PCB->minWid) { @@ -428,7 +428,7 @@ if (!IsBad) { PCB_ARC_COPPER_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PCB_TYPE_ARC, layer, arc, drc_callback); + pcb_poly_plows(PCB->Data, PCB_TYPE_ARC, layer, arc, drc_callback); if (IsBad) break; if (arc->Thickness < PCB->minWid) { @@ -459,7 +459,7 @@ if (!IsBad) { PCB_PIN_ALL_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PCB_TYPE_PIN, element, pin, drc_callback); + pcb_poly_plows(PCB->Data, PCB_TYPE_PIN, element, pin, drc_callback); if (IsBad) break; if (!PCB_FLAG_TEST(PCB_FLAG_HOLE, pin) && pin->Thickness - pin->DrillingHole < 2 * PCB->minRing) { @@ -513,7 +513,7 @@ if (!IsBad) { PCB_PAD_ALL_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PCB_TYPE_PAD, element, pad, drc_callback); + pcb_poly_plows(PCB->Data, PCB_TYPE_PAD, element, pad, drc_callback); if (IsBad) break; if (pad->Thickness < PCB->minWid) { @@ -544,7 +544,7 @@ if (!IsBad) { PCB_VIA_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PCB_TYPE_VIA, via, via, drc_callback); + pcb_poly_plows(PCB->Data, PCB_TYPE_VIA, via, via, drc_callback); if (IsBad) break; if (!PCB_FLAG_TEST(PCB_FLAG_HOLE, via) && via->Thickness - via->DrillingHole < 2 * PCB->minRing) { Index: trunk/src/find_geo.c =================================================================== --- trunk/src/find_geo.c (revision 4990) +++ trunk/src/find_geo.c (revision 4991) @@ -485,7 +485,7 @@ && Box->Y1 <= Polygon->Clipped->contours->ymax + Bloat && Box->Y2 >= Polygon->Clipped->contours->ymin - Bloat) { pcb_polyarea_t *ap; - if (!(ap = ArcPoly(Arc, Arc->Thickness + Bloat))) + if (!(ap = pcb_poly_from_arc(Arc, Arc->Thickness + Bloat))) return pcb_false; /* error */ return isects(ap, Polygon, pcb_true); } @@ -523,7 +523,7 @@ if (Box->X1 <= Polygon->Clipped->contours->xmax + Bloat && Box->X2 >= Polygon->Clipped->contours->xmin - Bloat && Box->Y1 <= Polygon->Clipped->contours->ymax + Bloat && Box->Y2 >= Polygon->Clipped->contours->ymin - Bloat) { - if (!(lp = LinePoly(Line, Line->Thickness + Bloat))) + if (!(lp = pcb_poly_from_line(Line, Line->Thickness + Bloat))) return pcb_false; /* error */ return isects(lp, Polygon, pcb_true); } @@ -636,8 +636,8 @@ pcb_polyarea_t *pl1, *pl2; int ret; - pl1 = PinPoly(PV1, PIN_SIZE(PV1) + Bloat, 0); - pl2 = PinPoly(PV2, PIN_SIZE(PV2) + Bloat, 0); + pl1 = pcb_poly_from_pin(PV1, PIN_SIZE(PV1) + Bloat, 0); + pl2 = pcb_poly_from_pin(PV2, PIN_SIZE(PV2) + Bloat, 0); ret = pcb_polyarea_touching(pl1, pl2); pcb_polyarea_free(&pl1); pcb_polyarea_free(&pl2); @@ -682,8 +682,8 @@ pcb_polyarea_t *pl, *lp; int ret; - pl = PinPoly(PV, PIN_SIZE(PV), 0); - lp = LinePoly(Line, Line->Thickness + Bloat); + pl = pcb_poly_from_pin(PV, PIN_SIZE(PV), 0); + lp = pcb_poly_from_line(Line, Line->Thickness + Bloat); ret = pcb_polyarea_touching(lp, pl); pcb_polyarea_free(&pl); pcb_polyarea_free(&lp); Index: trunk/src/find_lookup.c =================================================================== --- trunk/src/find_lookup.c (revision 4990) +++ trunk/src/find_lookup.c (revision 4991) @@ -363,7 +363,7 @@ longjmp(i->env, 1); } else if (PCB_FLAG_TEST(PCB_FLAG_OCTAGON, &i->pv)) { - pcb_polyarea_t *oct = OctagonPoly(i->pv.X, i->pv.Y, i->pv.Thickness / 2, PCB_FLAG_SQUARE_GET(&i->pv)); + pcb_polyarea_t *oct = pcb_poly_from_octagon(i->pv.X, i->pv.Y, i->pv.Thickness / 2, PCB_FLAG_SQUARE_GET(&i->pv)); if (isects(oct, polygon, pcb_true) && ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); @@ -678,7 +678,7 @@ longjmp(i->env, 1); } else if (PCB_FLAG_TEST(PCB_FLAG_OCTAGON, pv)) { - pcb_polyarea_t *oct = OctagonPoly(pv->X, pv->Y, PIN_SIZE(pv) / 2, PCB_FLAG_SQUARE_GET(pv)); + pcb_polyarea_t *oct = pcb_poly_from_octagon(pv->X, pv->Y, PIN_SIZE(pv) / 2, PCB_FLAG_SQUARE_GET(pv)); if (isects(oct, &i->polygon, pcb_true) && ADD_PV_TO_LIST(pv, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } Index: trunk/src/hid_draw_helpers.c =================================================================== --- trunk/src/hid_draw_helpers.c (revision 4990) +++ trunk/src/hid_draw_helpers.c (revision 4991) @@ -81,7 +81,7 @@ pcb_polyarea_t *draw_piece; int x; - clip_poly = RectPoly(clip_box->X1, clip_box->X2, clip_box->Y1, clip_box->Y2); + clip_poly = pcb_poly_from_rect(clip_box->X1, clip_box->X2, clip_box->Y1, clip_box->Y2); pcb_poly_contour_copy(&pl_copy, pl); piece_poly = pcb_polyarea_create(); pcb_polyarea_contour_include(piece_poly, pl_copy); @@ -142,7 +142,7 @@ * just compute what we need to render now. */ if (should_compute_no_holes(poly, clip_box)) - ComputeNoHoles(poly); + pcb_poly_compute_no_holes(poly); else NoHolesPolygonDicer(poly, clip_box, fill_contour_cb, gc); } @@ -177,7 +177,7 @@ void pcb_dhlp_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) { thindraw_contour(gc, poly->Clipped->contours); - PolygonHoles(poly, clip_box, thindraw_hole_cb, gc); + pcb_poly_holes(poly, clip_box, thindraw_hole_cb, gc); } void pcb_dhlp_thindraw_pcb_pad(pcb_hid_gc_t gc, pcb_pad_t * pad, pcb_bool clear, pcb_bool mask) Index: trunk/src/main.c =================================================================== --- trunk/src/main.c (revision 4990) +++ trunk/src/main.c (revision 4991) @@ -362,7 +362,7 @@ pcb_funchash_init(); initialize_units(); - polygon_init(); + pcb_polygon_init(); /* This must be called before any other atexit functions * are registered, as it configures an atexit function to Index: trunk/src/obj_pinvia.c =================================================================== --- trunk/src/obj_pinvia.c (revision 4990) +++ trunk/src/obj_pinvia.c (revision 4991) @@ -209,7 +209,7 @@ pcb_coord_t width; if ((PCB_FLAG_SQUARE_GET(Pin) > 1) && (PCB_FLAG_TEST(PCB_FLAG_SQUARE, Pin))) { - pcb_polyarea_t *p = PinPoly(Pin, PIN_SIZE(Pin), Pin->Clearance); + pcb_polyarea_t *p = pcb_poly_from_pin(Pin, PIN_SIZE(Pin), Pin->Clearance); pcb_polyarea_bbox(p, &Pin->BoundingBox); pcb_polyarea_free(&p); } Index: trunk/src/obj_pinvia_therm.c =================================================================== --- trunk/src/obj_pinvia_therm.c (revision 4990) +++ trunk/src/obj_pinvia_therm.c (revision 4991) @@ -79,7 +79,7 @@ v[0] = X + x2; v[1] = Y + y1; pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); - return ContourToPoly(c); + return pcb_poly_from_contour(c); } static pcb_polyarea_t *square_therm(pcb_pin_t *pin, pcb_cardinal_t style) @@ -106,7 +106,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); v[0] = pin->X - out + d; pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); - p = ContourToPoly(c); + p = pcb_poly_from_contour(c); /* right */ v[0] = pin->X + in; v[1] = pin->Y + in - d; @@ -119,7 +119,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); v[1] = pin->Y + out - d; pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f = p2; p2->b = p; /* left */ @@ -134,7 +134,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); v[1] = pin->Y - out + d; pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f->f = p2; p2->b = p->f; /* bottom (actually top since +y is down) */ @@ -149,7 +149,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); v[0] = pin->X + out - d; pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f->f->f = p2; p2->f = p; p2->b = p->f->f; @@ -166,12 +166,12 @@ l.Point1.X = pin->X - d; l.Point2.Y = l.Point1.Y = pin->Y + out; l.Point2.X = pin->X + d; - p = LinePoly(&l, in); + p = pcb_poly_from_line(&l, in); /* right */ l.Point1.X = l.Point2.X = pin->X + out; l.Point1.Y = pin->Y - d; l.Point2.Y = pin->Y + d; - p2 = LinePoly(&l, in); + p2 = pcb_poly_from_line(&l, in); p->f = p2; p2->b = p; /* bottom */ @@ -178,7 +178,7 @@ l.Point1.X = pin->X - d; l.Point2.Y = l.Point1.Y = pin->Y - out; l.Point2.X = pin->X + d; - p2 = LinePoly(&l, in); + p2 = pcb_poly_from_line(&l, in); p->f->f = p2; p2->b = p->f; /* left */ @@ -185,7 +185,7 @@ l.Point1.X = l.Point2.X = pin->X - out; l.Point1.Y = pin->Y - d; l.Point2.Y = pin->Y + d; - p2 = LinePoly(&l, in); + p2 = pcb_poly_from_line(&l, in); p->f->f->f = p2; p2->b = p->f->f; p->b = p2; @@ -224,7 +224,7 @@ } else frac_circle(c, v[0], v[1] - pin->Clearance / 4, v, 2); - p = ContourToPoly(c); + p = pcb_poly_from_contour(c); /* bottom right */ v[0] = pin->X + in; v[1] = pin->Y - d; @@ -248,7 +248,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); if (style == 5) frac_circle(c, v[0] - pin->Clearance / 4, v[1], v, 2); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f = p2; p2->b = p; /* bottom left */ @@ -274,7 +274,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); if (style == 5) frac_circle(c, v[0], v[1] + pin->Clearance / 4, v, 2); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f->f = p2; p2->b = p->f; /* top left */ @@ -300,7 +300,7 @@ pcb_poly_vertex_include(c->head.prev, pcb_poly_node_create(v)); if (style == 5) frac_circle(c, v[0], v[1] + pin->Clearance / 4, v, 2); - p2 = ContourToPoly(c); + p2 = pcb_poly_from_contour(c); p->f->f->f = p2; p2->f = p; p2->b = p->f->f; @@ -315,8 +315,8 @@ pcb_coord_t t = 0.5 * pcb->ThermScale * pin->Clearance; pcb_coord_t w = pin->Thickness + pin->Clearance; - p = OctagonPoly(pin->X, pin->Y, w, PCB_FLAG_SQUARE_GET(pin)); - p2 = OctagonPoly(pin->X, pin->Y, pin->Thickness, PCB_FLAG_SQUARE_GET(pin)); + p = pcb_poly_from_octagon(pin->X, pin->Y, w, PCB_FLAG_SQUARE_GET(pin)); + p2 = pcb_poly_from_octagon(pin->X, pin->Y, pin->Thickness, PCB_FLAG_SQUARE_GET(pin)); /* make full clearance ring */ pcb_polyarea_boolean_free(p, p2, &m, PBO_SUB); switch (style) { @@ -328,9 +328,9 @@ pcb_polyarea_boolean_free(p2, p, &m, PBO_SUB); return m; case 2: - p = RectPoly(pin->X - t, pin->X + t, pin->Y - w, pin->Y + w); + p = pcb_poly_from_rect(pin->X - t, pin->X + t, pin->Y - w, pin->Y + w); pcb_polyarea_boolean_free(m, p, &p2, PBO_SUB); - p = RectPoly(pin->X - w, pin->X + w, pin->Y - t, pin->Y + t); + p = pcb_poly_from_rect(pin->X - w, pin->X + w, pin->Y - t, pin->Y + t); pcb_polyarea_boolean_free(p2, p, &m, PBO_SUB); return m; /* fix me add thermal style 4 */ @@ -340,7 +340,7 @@ pcb_polyarea_t *q; /* cheat by using the square therm's rounded parts */ p = square_therm(pin, style); - q = RectPoly(pin->X - t, pin->X + t, pin->Y - t, pin->Y + t); + q = pcb_poly_from_rect(pin->X - t, pin->X + t, pin->Y - t, pin->Y + t); pcb_polyarea_boolean_free(p, q, &p2, PBO_UNITE); pcb_polyarea_boolean_free(m, p2, &p, PBO_ISECT); return p; @@ -374,8 +374,8 @@ pcb_polyarea_t *m; pcb_coord_t t = (pin->Thickness + pin->Clearance) / 2; pcb_coord_t w = 0.5 * pcb->ThermScale * pin->Clearance; - pa = CirclePoly(pin->X, pin->Y, t); - arc = CirclePoly(pin->X, pin->Y, pin->Thickness / 2); + pa = pcb_poly_from_circle(pin->X, pin->Y, t); + arc = pcb_poly_from_circle(pin->X, pin->Y, pin->Thickness / 2); /* create a thin ring */ pcb_polyarea_boolean_free(pa, arc, &m, PBO_SUB); /* fix me needs error checking */ @@ -383,9 +383,9 @@ /* t is the theoretically required length, but we use twice that * to avoid descritisation errors in our circle approximation. */ - pa = RectPoly(pin->X - t * 2, pin->X + t * 2, pin->Y - w, pin->Y + w); + pa = pcb_poly_from_rect(pin->X - t * 2, pin->X + t * 2, pin->Y - w, pin->Y + w); pcb_polyarea_boolean_free(m, pa, &arc, PBO_SUB); - pa = RectPoly(pin->X - w, pin->X + w, pin->Y - t * 2, pin->Y + t * 2); + pa = pcb_poly_from_rect(pin->X - w, pin->X + w, pin->Y - t * 2, pin->Y + t * 2); } else { /* t is the theoretically required length, but we use twice that @@ -409,23 +409,23 @@ a.Flags = pcb_no_flags(); a.Delta = 90 - (a.Clearance * (1. + 2. * pcb->ThermScale) * 180) / (M_PI * a.Width); a.StartAngle = 90 - a.Delta / 2 + (style == 4 ? 0 : 45); - pa = ArcPoly(&a, a.Clearance); + pa = pcb_poly_from_arc(&a, a.Clearance); if (!pa) return NULL; a.StartAngle += 90; - arc = ArcPoly(&a, a.Clearance); + arc = pcb_poly_from_arc(&a, a.Clearance); if (!arc) return NULL; pa->f = arc; arc->b = pa; a.StartAngle += 90; - arc = ArcPoly(&a, a.Clearance); + arc = pcb_poly_from_arc(&a, a.Clearance); if (!arc) return NULL; pa->f->f = arc; arc->b = pa->f; a.StartAngle += 90; - arc = ArcPoly(&a, a.Clearance); + arc = pcb_poly_from_arc(&a, a.Clearance); if (!arc) return NULL; pa->b = arc; Index: trunk/src/obj_poly.c =================================================================== --- trunk/src/obj_poly.c (revision 4990) +++ trunk/src/obj_poly.c (revision 4991) @@ -306,7 +306,7 @@ * first make sure adding the point is sensible */ line.Thickness = 0; - line.Point1 = Polygon->Points[prev_contour_point(Polygon, ctx->insert.idx)]; + line.Point1 = Polygon->Points[pcb_poly_contour_prev_point(Polygon, ctx->insert.idx)]; line.Point2 = Polygon->Points[ctx->insert.idx]; if (IsPointOnLine((float) ctx->insert.x, (float) ctx->insert.y, 0.0, &line)) return (NULL); @@ -332,7 +332,7 @@ pcb_poly_bbox(Polygon); r_insert_entry(Layer->polygon_tree, (pcb_box_t *) Polygon, 0); InitClip(PCB->Data, Layer, Polygon); - if (ctx->insert.forcible || !RemoveExcessPolygonPoints(Layer, Polygon)) { + if (ctx->insert.forcible || !pcb_poly_remove_excess_points(Layer, Polygon)) { DrawPolygon(Layer, Polygon); pcb_draw(); } @@ -377,7 +377,7 @@ PCB_MOVE(Point->X, Point->Y, ctx->move.dx, ctx->move.dy); pcb_poly_bbox(Polygon); r_insert_entry(Layer->polygon_tree, (pcb_box_t *) Polygon, 0); - RemoveExcessPolygonPoints(Layer, Polygon); + pcb_poly_remove_excess_points(Layer, Polygon); InitClip(PCB->Data, Layer, Polygon); if (Layer->On) { DrawPolygon(Layer, Polygon); @@ -474,8 +474,8 @@ pcb_cardinal_t contour; pcb_cardinal_t contour_start, contour_end, contour_points; - point_idx = polygon_point_idx(Polygon, Point); - contour = polygon_point_contour(Polygon, point_idx); + point_idx = pcb_poly_point_idx(Polygon, Point); + contour = pcb_poly_contour_point(Polygon, point_idx); contour_start = (contour == 0) ? 0 : Polygon->HoleIndex[contour - 1]; contour_end = (contour == Polygon->HoleIndexN) ? Polygon->PointN : Polygon->HoleIndex[contour]; contour_points = contour_end - contour_start; @@ -576,8 +576,8 @@ pcb_cardinal_t contour; pcb_cardinal_t contour_start, contour_end, contour_points; - point_idx = polygon_point_idx(Polygon, Point); - contour = polygon_point_contour(Polygon, point_idx); + point_idx = pcb_poly_point_idx(Polygon, Point); + contour = pcb_poly_contour_point(Polygon, point_idx); contour_start = (contour == 0) ? 0 : Polygon->HoleIndex[contour - 1]; contour_end = (contour == Polygon->HoleIndexN) ? Polygon->PointN : Polygon->HoleIndex[contour]; contour_points = contour_end - contour_start; @@ -604,7 +604,7 @@ pcb_poly_bbox(Polygon); r_insert_entry(Layer->polygon_tree, (pcb_box_t *) Polygon, 0); - RemoveExcessPolygonPoints(Layer, Polygon); + pcb_poly_remove_excess_points(Layer, Polygon); InitClip(PCB->Data, Layer, Polygon); /* redraw polygon if necessary */ Index: trunk/src/polygon.c =================================================================== --- trunk/src/polygon.c (revision 4990) +++ trunk/src/polygon.c (revision 4991) @@ -103,7 +103,7 @@ static double rotate_circle_seg[4]; -void polygon_init(void) +void pcb_polygon_init(void) { double cos_ang = cos(2.0 * M_PI / POLY_CIRC_SEGS_F); double sin_ang = sin(2.0 * M_PI / POLY_CIRC_SEGS_F); @@ -114,7 +114,7 @@ rotate_circle_seg[3] = cos_ang; } -pcb_cardinal_t polygon_point_idx(pcb_polygon_t *polygon, pcb_point_t *point) +pcb_cardinal_t pcb_poly_point_idx(pcb_polygon_t *polygon, pcb_point_t *point) { assert(point >= polygon->Points); assert(point <= polygon->Points + polygon->PointN); @@ -122,7 +122,7 @@ } /* Find contour number: 0 for outer, 1 for first hole etc.. */ -pcb_cardinal_t polygon_point_contour(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t i; pcb_cardinal_t contour = 0; @@ -133,13 +133,13 @@ return contour; } -pcb_cardinal_t next_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_next_point(pcb_polygon_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t contour; pcb_cardinal_t this_contour_start; pcb_cardinal_t next_contour_start; - contour = polygon_point_contour(polygon, point); + contour = pcb_poly_contour_point(polygon, point); this_contour_start = (contour == 0) ? 0 : polygon->HoleIndex[contour - 1]; next_contour_start = (contour == polygon->HoleIndexN) ? polygon->PointN : polygon->HoleIndex[contour]; @@ -151,13 +151,13 @@ return point; } -pcb_cardinal_t prev_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_prev_point(pcb_polygon_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t contour; pcb_cardinal_t prev_contour_end; pcb_cardinal_t this_contour_end; - contour = polygon_point_contour(polygon, point); + contour = pcb_poly_contour_point(polygon, point); prev_contour_end = (contour == 0) ? 0 : polygon->HoleIndex[contour - 1]; this_contour_end = (contour == polygon->HoleIndexN) ? polygon->PointN - 1 : polygon->HoleIndex[contour] - 1; @@ -180,7 +180,7 @@ poly->NoHoles = pline; } -void ComputeNoHoles(pcb_polygon_t * poly) +void pcb_poly_compute_no_holes(pcb_polygon_t * poly) { pcb_poly_contours_free(&poly->NoHoles); if (poly->Clipped) @@ -235,7 +235,7 @@ return p; } -pcb_polyarea_t *ContourToPoly(pcb_pline_t * contour) +pcb_polyarea_t *pcb_poly_from_contour(pcb_pline_t * contour) { pcb_polyarea_t *p; pcb_poly_contour_pre(contour, pcb_true); @@ -292,12 +292,12 @@ return biggest(np); } -pcb_polyarea_t *PolygonToPoly(pcb_polygon_t * p) +pcb_polyarea_t *pcb_poly_from_poly(pcb_polygon_t * p) { return original_poly(p); } -pcb_polyarea_t *RectPoly(pcb_coord_t x1, pcb_coord_t x2, pcb_coord_t y1, pcb_coord_t y2) +pcb_polyarea_t *pcb_poly_from_rect(pcb_coord_t x1, pcb_coord_t x2, pcb_coord_t y1, pcb_coord_t y2) { pcb_pline_t *contour = NULL; pcb_vector_t v; @@ -319,7 +319,7 @@ v[0] = x1; v[1] = y2; pcb_poly_vertex_include(contour->head.prev, pcb_poly_node_create(v)); - return ContourToPoly(contour); + return pcb_poly_from_contour(contour); } /* set up x and y multiplier for an octa poly, depending on square pin style */ @@ -346,7 +346,7 @@ } -pcb_polyarea_t *OctagonPoly(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius, int style) +pcb_polyarea_t *pcb_poly_from_octagon(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius, int style) { pcb_pline_t *contour = NULL; pcb_vector_t v; @@ -388,7 +388,7 @@ v[0] = x + ROUND(radius * 0.5) * xm[0]; v[1] = y - ROUND(radius * PCB_TAN_22_5_DEGREE_2) * ym[0]; pcb_poly_vertex_include(contour->head.prev, pcb_poly_node_create(v)); - return ContourToPoly(contour); + return pcb_poly_from_contour(contour); } /* add vertices in a fractional-circle starting from v @@ -422,7 +422,7 @@ } /* create a circle approximation from lines */ -pcb_polyarea_t *CirclePoly(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius) +pcb_polyarea_t *pcb_poly_from_circle(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius) { pcb_pline_t *contour; pcb_vector_t v; @@ -438,7 +438,7 @@ contour->cx = x; contour->cy = y; contour->radius = radius; - return ContourToPoly(contour); + return pcb_poly_from_contour(contour); } /* make a rounded-corner rectangle with radius t beyond x1,x2,y1,y2 rectangle */ @@ -466,7 +466,7 @@ v[1] = y2 + t; pcb_poly_vertex_include(contour->head.prev, pcb_poly_node_create(v)); frac_circle(contour, x1, y2, v, 4); - return ContourToPoly(contour); + return pcb_poly_from_contour(contour); } #define ARC_ANGLE 5 @@ -533,13 +533,13 @@ v[1] = a->Y + ry * sin(ang * PCB_M180) * (1 - radius_adj); frac_circle(contour, ends->X1, ends->Y1, v, 2); /* now we have the whole contour */ - if (!(np = ContourToPoly(contour))) + if (!(np = pcb_poly_from_contour(contour))) return NULL; return np; } #define MIN_CLEARANCE_BEFORE_BISECT 10. -pcb_polyarea_t *ArcPoly(pcb_arc_t * a, pcb_coord_t thick) +pcb_polyarea_t *pcb_poly_from_arc(pcb_arc_t * a, pcb_coord_t thick) { double delta; pcb_arc_t seg1, seg2; @@ -567,7 +567,7 @@ return ArcPolyNoIntersect(a, thick); } -pcb_polyarea_t *LinePoly(pcb_line_t * L, pcb_coord_t thick) +pcb_polyarea_t *pcb_poly_from_line(pcb_line_t * L, pcb_coord_t thick) { pcb_pline_t *contour = NULL; pcb_polyarea_t *np = NULL; @@ -582,7 +582,7 @@ d = sqrt(PCB_SQUARE(l->Point1.X - l->Point2.X) + PCB_SQUARE(l->Point1.Y - l->Point2.Y)); if (!PCB_FLAG_TEST(PCB_FLAG_SQUARE, l)) if (d == 0) /* line is a point */ - return CirclePoly(l->Point1.X, l->Point1.Y, half); + return pcb_poly_from_circle(l->Point1.X, l->Point1.Y, half); if (d != 0) { d = half / d; dx = (l->Point1.Y - l->Point2.Y) * d; @@ -618,7 +618,7 @@ else frac_circle(contour, l->Point1.X, l->Point1.Y, v, 2); /* now we have the line contour */ - if (!(np = ContourToPoly(contour))) + if (!(np = pcb_poly_from_contour(contour))) return NULL; return np; } @@ -689,7 +689,7 @@ frac_circle(contour, (t->Point1.X + tx), (t->Point1.Y + ty), v, 4); /* now we have the line contour */ - if (!(np = ContourToPoly(contour))) + if (!(np = pcb_poly_from_contour(contour))) return NULL; return np; } @@ -733,7 +733,7 @@ } /* create a polygon of the pin clearance */ -pcb_polyarea_t *PinPoly(pcb_pin_t * pin, pcb_coord_t thick, pcb_coord_t clear) +pcb_polyarea_t *pcb_poly_from_pin(pcb_pin_t * pin, pcb_coord_t thick, pcb_coord_t clear) { int size; @@ -744,7 +744,7 @@ } else { size = (thick + clear + 1) / 2; - return OctagonPoly(pin->X, pin->Y, size + size, PCB_FLAG_SQUARE_GET(pin)); + return pcb_poly_from_octagon(pin->X, pin->Y, size + size, PCB_FLAG_SQUARE_GET(pin)); } } @@ -751,15 +751,15 @@ else { size = (thick + clear + 1) / 2; if (PCB_FLAG_TEST(PCB_FLAG_OCTAGON, pin)) { - return OctagonPoly(pin->X, pin->Y, size + size, PCB_FLAG_SQUARE_GET(pin)); + return pcb_poly_from_octagon(pin->X, pin->Y, size + size, PCB_FLAG_SQUARE_GET(pin)); } } - return CirclePoly(pin->X, pin->Y, size); + return pcb_poly_from_circle(pin->X, pin->Y, size); } -pcb_polyarea_t *BoxPolyBloated(pcb_box_t * box, pcb_coord_t bloat) +pcb_polyarea_t *pcb_poly_from_box_bloated(pcb_box_t * box, pcb_coord_t bloat) { - return RectPoly(box->X1 - bloat, box->X2 + bloat, box->Y1 - bloat, box->Y2 + bloat); + return pcb_poly_from_rect(box->X1 - bloat, box->X2 + bloat, box->Y1 - bloat, box->Y2 + bloat); } /* return the clearance polygon for a pin */ @@ -769,7 +769,7 @@ if (PCB_FLAG_THERM_TEST(layernum, pin)) np = ThermPoly(pcb, pin, layernum); else - np = PinPoly(pin, PIN_SIZE(pin), pin->Clearance); + np = pcb_poly_from_pin(pin, PIN_SIZE(pin), pin->Clearance); return np; } @@ -802,7 +802,7 @@ if (!PCB_FLAG_TEST(PCB_FLAG_CLEARLINE, line)) return 0; - if (!(np = LinePoly(line, line->Thickness + line->Clearance))) + if (!(np = pcb_poly_from_line(line, line->Thickness + line->Clearance))) return -1; return Subtract(np, p, pcb_true); } @@ -813,7 +813,7 @@ if (!PCB_FLAG_TEST(PCB_FLAG_CLEARLINE, arc)) return 0; - if (!(np = ArcPoly(arc, arc->Thickness + arc->Clearance))) + if (!(np = pcb_poly_from_arc(arc, arc->Thickness + arc->Clearance))) return -1; return Subtract(np, p, pcb_true); } @@ -841,7 +841,7 @@ return -1; } else { - if (!(np = LinePoly((pcb_line_t *) pad, pad->Thickness + pad->Clearance))) + if (!(np = pcb_poly_from_line((pcb_line_t *) pad, pad->Thickness + pad->Clearance))) return -1; } return Subtract(np, p, pcb_true); @@ -890,7 +890,7 @@ return R_DIR_FOUND_CONTINUE; } else { - np = PinPoly(pin, PIN_SIZE(pin), pin->Clearance); + np = pcb_poly_from_pin(pin, PIN_SIZE(pin), pin->Clearance); if (!np) longjmp(info->env, 1); } @@ -958,7 +958,7 @@ return R_DIR_NOT_FOUND; polygon = info->polygon; - if (!(np = LinePoly(line, line->Thickness + line->Clearance))) + if (!(np = pcb_poly_from_line(line, line->Thickness + line->Clearance))) longjmp(info->env, 1); pcb_polyarea_boolean_free(info->accumulate, np, &merged, PBO_UNITE); @@ -1089,7 +1089,7 @@ pcb_polyarea_t *np; /* overlap a bit to prevent gaps from rounding errors */ - np = BoxPolyBloated(&pin->BoundingBox, UNSUBTRACT_BLOAT * 400000); + np = pcb_poly_from_box_bloated(&pin->BoundingBox, UNSUBTRACT_BLOAT * 400000); if (!np) return 0; @@ -1108,7 +1108,7 @@ return 0; /* overlap a bit to prevent gaps from rounding errors */ - np = BoxPolyBloated(&arc->BoundingBox, UNSUBTRACT_BLOAT); + np = pcb_poly_from_box_bloated(&arc->BoundingBox, UNSUBTRACT_BLOAT); if (!np) return 0; @@ -1126,7 +1126,7 @@ return 0; /* overlap a bit to prevent notches from rounding errors */ - np = BoxPolyBloated(&line->BoundingBox, UNSUBTRACT_BLOAT); + np = pcb_poly_from_box_bloated(&line->BoundingBox, UNSUBTRACT_BLOAT); if (!np) return 0; @@ -1144,7 +1144,7 @@ return 0; /* overlap a bit to prevent notches from rounding errors */ - np = BoxPolyBloated(&text->BoundingBox, UNSUBTRACT_BLOAT); + np = pcb_poly_from_box_bloated(&text->BoundingBox, UNSUBTRACT_BLOAT); if (!np) return -1; @@ -1159,7 +1159,7 @@ pcb_polyarea_t *np; /* overlap a bit to prevent notches from rounding errors */ - np = BoxPolyBloated(&pad->BoundingBox, UNSUBTRACT_BLOAT); + np = pcb_poly_from_box_bloated(&pad->BoundingBox, UNSUBTRACT_BLOAT); if (!np) return 0; @@ -1194,7 +1194,7 @@ * line between the points on either side of it is redundant. * returns pcb_true if any points are removed */ -pcb_bool RemoveExcessPolygonPoints(pcb_layer_t *Layer, pcb_polygon_t *Polygon) +pcb_bool pcb_poly_remove_excess_points(pcb_layer_t *Layer, pcb_polygon_t *Polygon) { pcb_point_t *p; pcb_cardinal_t n, prev, next; @@ -1205,8 +1205,8 @@ return (pcb_false); for (n = 0; n < Polygon->PointN; n++) { - prev = prev_contour_point(Polygon, n); - next = next_contour_point(Polygon, n); + prev = pcb_poly_contour_prev_point(Polygon, n); + next = pcb_poly_contour_next_point(Polygon, n); p = &Polygon->Points[n]; line.Point1 = Polygon->Points[prev]; @@ -1225,7 +1225,7 @@ * point of the segment with the lowest distance to the passed * coordinates */ -pcb_cardinal_t GetLowestDistancePolygonPoint(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y) +pcb_cardinal_t pcb_poly_get_lowest_distance_point(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y) { double mindistance = (double) MAX_COORD * MAX_COORD; pcb_point_t *ptr1, *ptr2; @@ -1240,7 +1240,7 @@ for (n = 0; n < Polygon->PointN; n++) { double u, dx, dy; - ptr1 = &Polygon->Points[prev_contour_point(Polygon, n)]; + ptr1 = &Polygon->Points[pcb_poly_contour_prev_point(Polygon, n)]; ptr2 = &Polygon->Points[n]; dx = ptr2->X - ptr1->X; @@ -1270,7 +1270,7 @@ /* --------------------------------------------------------------------------- * go back to the previous point of the polygon */ -void GoToPreviousPoint(void) +void pcb_polygon_go_to_prev_point(void) { switch (Crosshair.AttachedPolygon.PointN) { /* do nothing if mode has just been entered */ @@ -1301,7 +1301,7 @@ /* --------------------------------------------------------------------------- * close polygon if possible */ -void ClosePolygon(void) +void pcb_polygon_close_poly(void) { pcb_cardinal_t n = Crosshair.AttachedPolygon.PointN; @@ -1320,7 +1320,7 @@ return; } } - CopyAttachedPolygonToLayer(); + pcb_polygon_copy_attached_to_layer(); pcb_draw(); } else @@ -1330,7 +1330,7 @@ /* --------------------------------------------------------------------------- * moves the data of the attached (new) polygon to the current layer */ -void CopyAttachedPolygonToLayer(void) +void pcb_polygon_copy_attached_to_layer(void) { pcb_polygon_t *polygon; int saveID; @@ -1366,7 +1366,7 @@ * the search. */ int -PolygonHoles(pcb_polygon_t * polygon, const pcb_box_t * range, int (*callback) (pcb_pline_t * contour, void *user_data), void *user_data) +pcb_poly_holes(pcb_polygon_t * polygon, const pcb_box_t * range, int (*callback) (pcb_pline_t * contour, void *user_data), void *user_data) { pcb_polyarea_t *pa = polygon->Clipped; pcb_pline_t *pl; @@ -1457,7 +1457,7 @@ } int -PlowsPolygon(pcb_data_t * Data, int type, void *ptr1, void *ptr2, +pcb_poly_plows(pcb_data_t * Data, int type, void *ptr1, void *ptr2, pcb_r_dir_t (*call_back) (pcb_data_t *data, pcb_layer_t *lay, pcb_polygon_t *poly, int type, void *ptr1, void *ptr2)) { pcb_box_t sb = ((pcb_pin_t *) ptr2)->BoundingBox; @@ -1526,12 +1526,12 @@ { PCB_PIN_LOOP((pcb_element_t *) ptr1); { - PlowsPolygon(Data, PCB_TYPE_PIN, ptr1, pin, call_back); + pcb_poly_plows(Data, PCB_TYPE_PIN, ptr1, pin, call_back); } END_LOOP; PCB_PAD_LOOP((pcb_element_t *) ptr1); { - PlowsPolygon(Data, PCB_TYPE_PAD, ptr1, pad, call_back); + pcb_poly_plows(Data, PCB_TYPE_PAD, ptr1, pad, call_back); } END_LOOP; } @@ -1545,7 +1545,7 @@ if (type == PCB_TYPE_POLYGON) InitClip(PCB->Data, (pcb_layer_t *) ptr1, (pcb_polygon_t *) ptr2); else - PlowsPolygon(Data, type, ptr1, ptr2, add_plow); + pcb_poly_plows(Data, type, ptr1, ptr2, add_plow); } void ClearFromPolygon(pcb_data_t * Data, int type, void *ptr1, void *ptr2) @@ -1553,7 +1553,7 @@ if (type == PCB_TYPE_POLYGON) InitClip(PCB->Data, (pcb_layer_t *) ptr1, (pcb_polygon_t *) ptr2); else - PlowsPolygon(Data, type, ptr1, ptr2, subtract_plow); + pcb_poly_plows(Data, type, ptr1, ptr2, subtract_plow); } pcb_bool isects(pcb_polyarea_t * a, pcb_polygon_t *p, pcb_bool fr) @@ -1589,7 +1589,7 @@ if (r < 1) return pcb_false; - if (!(c = CirclePoly(X, Y, r))) + if (!(c = pcb_poly_from_circle(X, Y, r))) return pcb_false; return isects(c, p, pcb_true); } @@ -1606,7 +1606,7 @@ pcb_bool IsRectangleInPolygon(pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_polygon_t *p) { pcb_polyarea_t *s; - if (!(s = RectPoly(min(X1, X2), max(X1, X2), min(Y1, Y2), max(Y1, Y2)))) + if (!(s = pcb_poly_from_rect(min(X1, X2), max(X1, X2), min(Y1, Y2), max(Y1, Y2)))) return pcb_false; return isects(s, p, pcb_true); } @@ -1630,7 +1630,7 @@ pcb_polyarea_t *poly2, *left, *right; /* make a rectangle of the left region slicing through the middle of the first hole */ - poly2 = RectPoly(p->xmin, (p->next->xmin + p->next->xmax) / 2, p->ymin, p->ymax); + poly2 = pcb_poly_from_rect(p->xmin, (p->next->xmin + p->next->xmax) / 2, p->ymin, p->ymax); pcb_polyarea_and_subtract_free(pa, poly2, &left, &right); if (left) { pcb_polyarea_t *cur, *next; @@ -1666,7 +1666,7 @@ pcb_polyarea_copy1(main_contour, p->Clipped); /* clip to the bounding box */ if (clip) { - pcb_polyarea_t *cbox = RectPoly(clip->X1, clip->X2, clip->Y1, clip->Y2); + pcb_polyarea_t *cbox = pcb_poly_from_rect(clip->X1, clip->X2, clip->Y1, clip->Y2); pcb_polyarea_boolean_free(main_contour, cbox, &main_contour, PBO_ISECT); } if (main_contour == NULL) Index: trunk/src/polygon.h =================================================================== --- trunk/src/polygon.h (revision 4990) +++ trunk/src/polygon.h (revision 4991) @@ -51,29 +51,32 @@ /* Prototypes */ -void polygon_init(void); -pcb_cardinal_t polygon_point_idx(pcb_polygon_t *polygon, pcb_point_t *point); -pcb_cardinal_t polygon_point_contour(pcb_polygon_t *polygon, pcb_cardinal_t point); -pcb_cardinal_t prev_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point); -pcb_cardinal_t next_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point); -pcb_cardinal_t GetLowestDistancePolygonPoint(pcb_polygon_t *, pcb_coord_t, pcb_coord_t); -pcb_bool RemoveExcessPolygonPoints(pcb_layer_t *, pcb_polygon_t *); -void GoToPreviousPoint(void); -void ClosePolygon(void); -void CopyAttachedPolygonToLayer(void); -int PolygonHoles(pcb_polygon_t * ptr, const pcb_box_t * range, int (*callback) (pcb_pline_t *, void *user_data), void *user_data); -int PlowsPolygon(pcb_data_t *, int, void *, void *, +void pcb_polygon_init(void); +pcb_cardinal_t pcb_poly_point_idx(pcb_polygon_t *polygon, pcb_point_t *point); +pcb_cardinal_t pcb_poly_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_contour_prev_point(pcb_polygon_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_contour_next_point(pcb_polygon_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_get_lowest_distance_point(pcb_polygon_t *, pcb_coord_t, pcb_coord_t); +pcb_bool pcb_poly_remove_excess_points(pcb_layer_t *, pcb_polygon_t *); +void pcb_polygon_go_to_prev_point(void); +void pcb_polygon_close_poly(void); +void pcb_polygon_copy_attached_to_layer(void); +int pcb_poly_holes(pcb_polygon_t * ptr, const pcb_box_t * range, int (*callback) (pcb_pline_t *, void *user_data), void *user_data); +int pcb_poly_plows(pcb_data_t *, int, void *, void *, pcb_r_dir_t (*callback) (pcb_data_t *, pcb_layer_t *, pcb_polygon_t *, int, void *, void *)); -void ComputeNoHoles(pcb_polygon_t * poly); -pcb_polyarea_t *ContourToPoly(pcb_pline_t *); -pcb_polyarea_t *PolygonToPoly(pcb_polygon_t *); -pcb_polyarea_t *RectPoly(pcb_coord_t x1, pcb_coord_t x2, pcb_coord_t y1, pcb_coord_t y2); -pcb_polyarea_t *CirclePoly(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius); -pcb_polyarea_t *OctagonPoly(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius, int style); -pcb_polyarea_t *LinePoly(pcb_line_t * l, pcb_coord_t thick); -pcb_polyarea_t *ArcPoly(pcb_arc_t * l, pcb_coord_t thick); -pcb_polyarea_t *PinPoly(pcb_pin_t * l, pcb_coord_t thick, pcb_coord_t clear); -pcb_polyarea_t *BoxPolyBloated(pcb_box_t * box, pcb_coord_t radius); +void pcb_poly_compute_no_holes(pcb_polygon_t * poly); + +/* helpers: create complex shaped polygons */ +pcb_polyarea_t *pcb_poly_from_contour(pcb_pline_t *); +pcb_polyarea_t *pcb_poly_from_poly(pcb_polygon_t *); +pcb_polyarea_t *pcb_poly_from_rect(pcb_coord_t x1, pcb_coord_t x2, pcb_coord_t y1, pcb_coord_t y2); +pcb_polyarea_t *pcb_poly_from_circle(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius); +pcb_polyarea_t *pcb_poly_from_octagon(pcb_coord_t x, pcb_coord_t y, pcb_coord_t radius, int style); +pcb_polyarea_t *pcb_poly_from_line(pcb_line_t * l, pcb_coord_t thick); +pcb_polyarea_t *pcb_poly_from_arc(pcb_arc_t * l, pcb_coord_t thick); +pcb_polyarea_t *pcb_poly_from_pin(pcb_pin_t * l, pcb_coord_t thick, pcb_coord_t clear); +pcb_polyarea_t *pcb_poly_from_box_bloated(pcb_box_t * box, pcb_coord_t radius); + void frac_circle(pcb_pline_t *, pcb_coord_t, pcb_coord_t, pcb_vector_t, int); int InitClip(pcb_data_t * d, pcb_layer_t * l, pcb_polygon_t * p); void RestoreToPolygon(pcb_data_t *, int, void *, void *); Index: trunk/src/polygon_act.c =================================================================== --- trunk/src/polygon_act.c (revision 4990) +++ trunk/src/polygon_act.c (revision 4991) @@ -123,12 +123,12 @@ switch (pcb_funchash_get(function, NULL)) { /* close open polygon if possible */ case F_Close: - ClosePolygon(); + pcb_polygon_close_poly(); break; /* go back to the previous point */ case F_PreviousPoint: - GoToPreviousPoint(); + pcb_polygon_go_to_prev_point(); break; } pcb_notify_crosshair_change(pcb_true); Index: trunk/src/undo.c =================================================================== --- trunk/src/undo.c (revision 4990) +++ trunk/src/undo.c (revision 4991) @@ -725,7 +725,7 @@ * If so, we need to flag as such when re-adding the point * so it goes back in the correct place */ - point_idx = polygon_point_idx(polygon, pnt); + point_idx = pcb_poly_point_idx(polygon, pnt); for (hole = 0; hole < polygon->HoleIndexN; hole++) if (point_idx == polygon->HoleIndex[hole] - 1) last_in_contour = pcb_true; Index: trunk/src/undo_act.c =================================================================== --- trunk/src/undo_act.c (revision 4990) +++ trunk/src/undo_act.c (revision 4991) @@ -137,7 +137,7 @@ pcb_notify_crosshair_change(pcb_false); if ((conf_core.editor.mode == PCB_MODE_POLYGON || conf_core.editor.mode == PCB_MODE_POLYGON_HOLE) && Crosshair.AttachedPolygon.PointN) { - GoToPreviousPoint(); + pcb_polygon_go_to_prev_point(); pcb_notify_crosshair_change(pcb_true); return 0; } Index: trunk/src_plugins/jostle/jostle.c =================================================================== --- trunk/src_plugins/jostle/jostle.c (revision 4990) +++ trunk/src_plugins/jostle/jostle.c (revision 4991) @@ -286,7 +286,7 @@ line = Createpcb_vector_tLineOnLayer(layer, a, b, orig->Thickness, orig->Clearance, orig->Flags); if (line && expandp) { - pcb_polyarea_t *p = LinePoly(line, line->Thickness + line->Clearance); + pcb_polyarea_t *p = pcb_poly_from_line(line, line->Thickness + line->Clearance); pcb_polyarea_boolean_free(*expandp, p, expandp, PBO_UNITE); } return line; @@ -392,7 +392,7 @@ pcb_fprintf(stderr, "\tinside2 %ms,%ms\n", p[0], p[1]); inside++; } - lp = LinePoly(line, line->Thickness); + lp = pcb_poly_from_line(line, line->Thickness); if (!pcb_polyarea_touching(lp, info->brush)) { /* not a factor */ return 0; @@ -409,7 +409,7 @@ * Cut the brush with the line to figure out which side to go * around. Use a very fine line. XXX can still graze. */ - lp = LinePoly(line, 1); + lp = pcb_poly_from_line(line, 1); if (!pcb_polyarea_m_copy0(©, info->brush)) return 0; r = pcb_polyarea_boolean_free(copy, lp, &tmp, PBO_SUB); @@ -422,7 +422,7 @@ * to get the glancing sliver?? */ pcb_fprintf(stderr, "try isect??\n"); - lp = LinePoly(line, line->Thickness); + lp = pcb_poly_from_line(line, line->Thickness); r = pcb_polyarea_boolean_free(tmp, lp, &tmp, PBO_ISECT); if (r != err_ok) { fprintf(stderr, "Error while jostling PBO_ISECT: %d\n", r); @@ -515,7 +515,7 @@ x = Crosshair.X; y = Crosshair.Y; fprintf(stderr, "%d, %d, %f\n", (int) x, (int) y, value); - info.brush = CirclePoly(x, y, value / 2); + info.brush = pcb_poly_from_circle(x, y, value / 2); info.layer = CURRENT; PCB_LINE_LOOP(info.layer); { Index: trunk/src_plugins/polystitch/polystitch.c =================================================================== --- trunk/src_plugins/polystitch/polystitch.c (revision 4990) +++ trunk/src_plugins/polystitch/polystitch.c (revision 4991) @@ -219,7 +219,7 @@ outer_poly->NoHolesValid = 0; pcb_poly_bbox(outer_poly); r_insert_entry(poly_layer->polygon_tree, (pcb_box_t *) outer_poly, 0); - RemoveExcessPolygonPoints(poly_layer, outer_poly); + pcb_poly_remove_excess_points(poly_layer, outer_poly); InitClip(PCB->Data, poly_layer, outer_poly); DrawPolygon(poly_layer, outer_poly); pcb_draw();