Index: trunk/doc/developer/renames =================================================================== --- trunk/doc/developer/renames (revision 12227) +++ trunk/doc/developer/renames (revision 12228) @@ -1746,3 +1746,4 @@ DrawElementPackage -> pcb_elem_package_invalidate_draw DrawElementName -> pcb_elem_name_invalidate_draw DrawElement -> pcb_elem_invalidate_draw +pcb_polygon_t -> pcb_poly_t Index: trunk/src/action_helper.c =================================================================== --- trunk/src/action_helper.c (revision 12227) +++ trunk/src/action_helper.c (revision 12228) @@ -100,8 +100,8 @@ *y = ((pcb_element_t *) ptr2)->MarkY; break; case PCB_TYPE_POLYGON: - *x = ((pcb_polygon_t *) ptr2)->Points[0].X; - *y = ((pcb_polygon_t *) ptr2)->Points[0].Y; + *x = ((pcb_poly_t *) ptr2)->Points[0].X; + *y = ((pcb_poly_t *) ptr2)->Points[0].Y; break; case PCB_TYPE_LINE_POINT: @@ -298,7 +298,7 @@ for(n = pcb_r_first(l->polygon_tree, &it); n != NULL; n = pcb_r_next(&it)) { if (PCB_FLAG_TEST(PCB_FLAG_WARN, (pcb_any_obj_t *)n)) { PCB_FLAG_CLEAR(PCB_FLAG_WARN, (pcb_any_obj_t *)n); - pcb_poly_invalidate_draw(l, (pcb_polygon_t *)n); + pcb_poly_invalidate_draw(l, (pcb_poly_t *)n); } } pcb_r_end(&it); Index: trunk/src/crosshair.c =================================================================== --- trunk/src/crosshair.c (revision 12227) +++ trunk/src/crosshair.c (revision 12228) @@ -91,7 +91,7 @@ /* --------------------------------------------------------------------------- * creates a tmp polygon with coordinates converted to screen system */ -void XORPolygon(pcb_polygon_t *polygon, pcb_coord_t dx, pcb_coord_t dy, int dash_last) +void XORPolygon(pcb_poly_t *polygon, pcb_coord_t dx, pcb_coord_t dy, int dash_last) { pcb_cardinal_t i; for (i = 0; i < polygon->PointN; i++) { @@ -393,7 +393,7 @@ case PCB_TYPE_POLYGON: { - pcb_polygon_t *polygon = (pcb_polygon_t *) pcb_crosshair.AttachedObject.Ptr2; + pcb_poly_t *polygon = (pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2; /* the tmp polygon has n+1 points because the first * and the last one are set to the same coordinates @@ -492,11 +492,11 @@ case PCB_TYPE_POLYGON_POINT: { - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_point_t *point; pcb_cardinal_t point_idx, prev, next; - polygon = (pcb_polygon_t *) pcb_crosshair.AttachedObject.Ptr2; + polygon = (pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2; point = (pcb_point_t *) pcb_crosshair.AttachedObject.Ptr3; point_idx = pcb_poly_point_idx(polygon, point); Index: trunk/src/crosshair.h =================================================================== --- trunk/src/crosshair.h (revision 12227) +++ trunk/src/crosshair.h (revision 12228) @@ -75,7 +75,7 @@ MaxX, MaxY; pcb_attached_line_t AttachedLine; /* data of new lines... */ pcb_attached_box_t AttachedBox; - pcb_polygon_t AttachedPolygon; + pcb_poly_t AttachedPolygon; pcb_attached_object_t AttachedObject; /* data of attached objects */ pcb_route_t Route; /* Calculated line route in LINE or MOVE(LINE) mode */ enum pcb_crosshair_shape_e shape; /* shape of crosshair */ @@ -127,7 +127,7 @@ /*** utility for plugins ***/ void XORDrawAttachedLine(pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_coord_t); -void XORPolygon(pcb_polygon_t *polygon, pcb_coord_t dx, pcb_coord_t dy, int dash_last); +void XORPolygon(pcb_poly_t *polygon, pcb_coord_t dx, pcb_coord_t dy, int dash_last); Index: trunk/src/data.c =================================================================== --- trunk/src/data.c (revision 12227) +++ trunk/src/data.c (revision 12228) @@ -234,7 +234,7 @@ pcb_poly_free_fields(polygon); } PCB_END_LOOP; - list_map0(&layer->Polygon, pcb_polygon_t, pcb_poly_free); + list_map0(&layer->Polygon, pcb_poly_t, pcb_poly_free); if (!layer->is_bound) { if (layer->line_tree) pcb_r_destroy_tree(&layer->line_tree); Index: trunk/src/data.h =================================================================== --- trunk/src/data.h (revision 12227) +++ trunk/src/data.h (revision 12228) @@ -93,7 +93,7 @@ typedef void (*pcb_line_cb_t)(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_line_t *line); typedef void (*pcb_arc_cb_t)(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_arc_t *arc); typedef void (*pcb_text_cb_t)(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_text_t *text); -typedef void (*pcb_poly_cb_t)(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly); +typedef void (*pcb_poly_cb_t)(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly); /* element callbacks */ typedef int (*pcb_element_cb_t)(void *ctx, pcb_board_t *pcb, pcb_element_t *element, int enter); Index: trunk/src/draw.c =================================================================== --- trunk/src/draw.c (revision 12227) +++ trunk/src/draw.c (revision 12228) @@ -591,7 +591,7 @@ pcb_text_invalidate_erase((pcb_layer_t *) lptr, (pcb_text_t *) ptr); break; case PCB_TYPE_POLYGON: - pcb_poly_invalidate_erase((pcb_polygon_t *) ptr); + pcb_poly_invalidate_erase((pcb_poly_t *) ptr); break; case PCB_TYPE_ELEMENT: pcb_elem_invalidate_erase((pcb_element_t *) ptr); @@ -638,7 +638,7 @@ break; case PCB_OBJ_POLYGON: if (obj->parent.layer->meta.real.vis) - pcb_poly_invalidate_draw(obj->parent.layer, (pcb_polygon_t *)obj); + pcb_poly_invalidate_draw(obj->parent.layer, (pcb_poly_t *)obj); break; case PCB_OBJ_ELEMENT: if (pcb_silk_on(PCB) && (PCB_FRONT((pcb_element_t *)obj) || PCB->InvisibleObjectsOn)) @@ -676,7 +676,7 @@ switch(obj->type) { case PCB_OBJ_LINE: pcb_line_draw_label((pcb_line_t *)obj); return; case PCB_OBJ_ARC: pcb_arc_draw_label((pcb_arc_t *)obj); return; - case PCB_OBJ_POLYGON: pcb_poly_draw_label((pcb_polygon_t *)obj); return; + case PCB_OBJ_POLYGON: pcb_poly_draw_label((pcb_poly_t *)obj); return; case PCB_OBJ_TEXT: pcb_text_draw_label((pcb_text_t *)obj); return; default: break; } Index: trunk/src/find.c =================================================================== --- trunk/src/find.c (revision 12227) +++ trunk/src/find.c (revision 12228) @@ -108,7 +108,7 @@ (((pcb_rat_t **)RatList.Data)[(I)]) #define POLYGONLIST_ENTRY(L,I) \ - (((pcb_polygon_t **)PolygonList[(L)].Data)[(I)]) + (((pcb_poly_t **)PolygonList[(L)].Data)[(I)]) #define PVLIST_ENTRY(I) \ (((pcb_pin_t **)PVList.Data)[(I)]) @@ -158,11 +158,11 @@ static pcb_bool LookupPVConnectionsToPVList(void); static pcb_bool LookupLOConnectionsToLine(pcb_line_t *, pcb_cardinal_t, pcb_bool); static pcb_bool LookupLOConnectionsToPad(pcb_pad_t *, pcb_cardinal_t); -static pcb_bool LookupLOConnectionsToPolygon(pcb_polygon_t *, pcb_cardinal_t); +static pcb_bool LookupLOConnectionsToPolygon(pcb_poly_t *, pcb_cardinal_t); static pcb_bool LookupLOConnectionsToArc(pcb_arc_t *, pcb_cardinal_t); static pcb_bool LookupLOConnectionsToRatEnd(pcb_point_t *, pcb_cardinal_t); static pcb_bool IsRatPointOnLineSpec(pcb_point_t *, pcb_line_t *); -static pcb_bool IsRatPointOnPoly(pcb_point_t *Point, pcb_polygon_t *polygon); +static pcb_bool IsRatPointOnPoly(pcb_point_t *Point, pcb_poly_t *polygon); static pcb_bool IsRatPointOnArcSpec(pcb_point_t *Point, pcb_arc_t *arc); static pcb_bool ArcArcIntersect(pcb_arc_t *, pcb_arc_t *); static pcb_bool PrintElementConnections(pcb_element_t *, FILE *, pcb_bool); Index: trunk/src/find.h =================================================================== --- trunk/src/find.h (revision 12227) +++ trunk/src/find.h (revision 12228) @@ -66,7 +66,7 @@ pcb_bool pcb_intersect_line_pin(pcb_pin_t *, pcb_line_t *); pcb_bool pcb_intersect_line_pad(pcb_line_t *, pcb_pad_t *); pcb_bool pcb_intersect_arc_pad(pcb_arc_t *, pcb_pad_t *); -pcb_bool pcb_is_poly_in_poly(pcb_polygon_t *, pcb_polygon_t *); +pcb_bool pcb_is_poly_in_poly(pcb_poly_t *, pcb_poly_t *); void pcb_lookup_element_conns(pcb_element_t *, FILE *); void pcb_lookup_conns_to_all_elements(FILE *); void pcb_lookup_conn(pcb_coord_t, pcb_coord_t, pcb_bool, pcb_coord_t, int); @@ -85,9 +85,9 @@ void pcb_save_find_flag(int); void pcb_restore_find_flag(void); int pcb_drc_all(void); -pcb_bool pcb_is_line_in_poly(pcb_line_t *, pcb_polygon_t *); -pcb_bool pcb_is_arc_in_poly(pcb_arc_t *, pcb_polygon_t *); -pcb_bool pcb_is_pad_in_poly(pcb_pad_t *, pcb_polygon_t *); +pcb_bool pcb_is_line_in_poly(pcb_line_t *, pcb_poly_t *); +pcb_bool pcb_is_arc_in_poly(pcb_arc_t *, pcb_poly_t *); +pcb_bool pcb_is_pad_in_poly(pcb_pad_t *, pcb_poly_t *); pcb_cardinal_t pcb_lookup_conn_by_obj(void *ctx, pcb_any_obj_t *obj, pcb_bool AndDraw, pcb_cardinal_t (*cb)(void *ctx, pcb_any_obj_t *obj)); Index: trunk/src/find_deadcode.c =================================================================== --- trunk/src/find_deadcode.c (revision 12227) +++ trunk/src/find_deadcode.c (revision 12228) @@ -98,7 +98,7 @@ /* handle normal layers */ if (layer < pcb_max_copper_layer) { gdl_iterator_t it; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; /* find the first line that touches coordinates */ Index: trunk/src/find_drc.c =================================================================== --- trunk/src/find_drc.c (revision 12227) +++ trunk/src/find_drc.c (revision 12228) @@ -146,7 +146,7 @@ } case PCB_TYPE_POLYGON: { - pcb_polygon_t *polygon = (pcb_polygon_t *) thing_ptr3; + pcb_poly_t *polygon = (pcb_poly_t *) thing_ptr3; *x = (polygon->Clipped->contours->xmin + polygon->Clipped->contours->xmax) / 2; *y = (polygon->Clipped->contours->ymin + polygon->Clipped->contours->ymax) / 2; break; @@ -223,7 +223,7 @@ } /* DRC clearance callback */ -static pcb_r_dir_t drc_callback(pcb_data_t *data, pcb_layer_t *layer, pcb_polygon_t *polygon, int type, void *ptr1, void *ptr2) +static pcb_r_dir_t drc_callback(pcb_data_t *data, pcb_layer_t *layer, pcb_poly_t *polygon, int type, void *ptr1, void *ptr2) { const char *message; pcb_coord_t x, y; Index: trunk/src/find_geo.c =================================================================== --- trunk/src/find_geo.c (revision 12227) +++ trunk/src/find_geo.c (revision 12228) @@ -276,7 +276,7 @@ /* --------------------------------------------------------------------------- * Tests if rat line point is connected to a polygon */ -static pcb_bool IsRatPointOnPoly(pcb_point_t *Point, pcb_polygon_t *polygon) +static pcb_bool IsRatPointOnPoly(pcb_point_t *Point, pcb_poly_t *polygon) { pcb_coord_t cx, cy; @@ -529,7 +529,7 @@ * - check the two end points of the arc. If none of them matches * - check all segments of the polygon against the arc. */ -pcb_bool pcb_is_arc_in_poly(pcb_arc_t *Arc, pcb_polygon_t *Polygon) +pcb_bool pcb_is_arc_in_poly(pcb_arc_t *Arc, pcb_poly_t *Polygon) { pcb_box_t *Box = (pcb_box_t *) Arc; @@ -558,7 +558,7 @@ * - check the two end points of the line. If none of them matches * - check all segments of the polygon against the line. */ -pcb_bool pcb_is_line_in_poly(pcb_line_t *Line, pcb_polygon_t *Polygon) +pcb_bool pcb_is_line_in_poly(pcb_line_t *Line, pcb_poly_t *Polygon) { pcb_box_t *Box = (pcb_box_t *) Line; pcb_polyarea_t *lp; @@ -593,7 +593,7 @@ * * The polygon is assumed to already have been proven non-clearing */ -pcb_bool pcb_is_pad_in_poly(pcb_pad_t *pad, pcb_polygon_t *polygon) +pcb_bool pcb_is_pad_in_poly(pcb_pad_t *pad, pcb_poly_t *polygon) { return pcb_is_line_in_poly((pcb_line_t *) pad, polygon); } @@ -604,7 +604,7 @@ * First check all points out of P1 against P2 and vice versa. * If both fail check all lines of P1 against the ones of P2 */ -pcb_bool pcb_is_poly_in_poly(pcb_polygon_t *P1, pcb_polygon_t *P2) +pcb_bool pcb_is_poly_in_poly(pcb_poly_t *P1, pcb_poly_t *P2) { if (!P1->Clipped || !P2->Clipped) return pcb_false; Index: trunk/src/find_lookup.c =================================================================== --- trunk/src/find_lookup.c (revision 12227) +++ trunk/src/find_lookup.c (revision 12228) @@ -142,7 +142,7 @@ return pcb_false; } -static pcb_bool ADD_POLYGON_TO_LIST(pcb_cardinal_t L, pcb_polygon_t *Ptr, int from_type, void *from_ptr, pcb_found_conn_type_t type) +static pcb_bool ADD_POLYGON_TO_LIST(pcb_cardinal_t L, pcb_poly_t *Ptr, int from_type, void *from_ptr, pcb_found_conn_type_t type) { if (PolygonList[L].Data == NULL) return pcb_false; @@ -265,7 +265,7 @@ } if ((layer->polygon_tree != NULL) && (layer->polygon_tree->size > 0)) { PolygonList[i].Size = layer->polygon_tree->size; - PolygonList[i].Data = (void **) calloc(PolygonList[i].Size, sizeof(pcb_polygon_t *)); + PolygonList[i].Data = (void **) calloc(PolygonList[i].Size, sizeof(pcb_poly_t *)); } } @@ -358,7 +358,7 @@ static pcb_r_dir_t LOCtoPVpoly_callback(const pcb_box_t * b, void *cl) { - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; struct pv_info *i = (struct pv_info *) cl; /* if the pin doesn't have a therm and polygon is clearing @@ -622,7 +622,7 @@ pcb_line_t line; pcb_pad_t pad; pcb_arc_t arc; - pcb_polygon_t polygon; + pcb_poly_t polygon; pcb_rat_t rat; jmp_buf env; }; @@ -789,7 +789,7 @@ /* now all polygons */ info.layer = layer; while (PolygonList[layer].Location < PolygonList[layer].Number) { - pcb_polygon_t *orig_poly = (POLYGONLIST_ENTRY(layer, PolygonList[layer].Location)); + pcb_poly_t *orig_poly = (POLYGONLIST_ENTRY(layer, PolygonList[layer].Location)); info.polygon = *orig_poly; EXPAND_BOUNDS(&info.polygon); @@ -970,7 +970,7 @@ pcb_rtree_it_t it; pcb_box_t *b; for(b = pcb_r_first(PCB->Data->Layer[layer].polygon_tree, &it); b != NULL; b = pcb_r_next(&it)) { - pcb_polygon_t *polygon = (pcb_polygon_t *)b; + pcb_poly_t *polygon = (pcb_poly_t *)b; if (!PCB_FLAG_TEST(TheFlag, polygon) && pcb_is_arc_in_poly(Arc, polygon) && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_ARC, Arc, PCB_FCT_COPPER)) return pcb_true; @@ -1094,7 +1094,7 @@ pcb_rtree_it_t it; pcb_box_t *b; for(b = pcb_r_first(PCB->Data->Layer[layer].polygon_tree, &it); b != NULL; b = pcb_r_next(&it)) { - pcb_polygon_t *polygon = (pcb_polygon_t *)b; + pcb_poly_t *polygon = (pcb_poly_t *)b; if (!PCB_FLAG_TEST(TheFlag, polygon) && pcb_is_line_in_poly(Line, polygon) && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_LINE, Line, PCB_FCT_COPPER)) return pcb_true; @@ -1150,7 +1150,7 @@ static pcb_r_dir_t LOCtoRatPoly_callback(const pcb_box_t * b, void *cl) { - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; struct rat_info *i = (struct rat_info *) cl; if (!PCB_FLAG_TEST(TheFlag, polygon) && polygon->Clipped && IsRatPointOnPoly(i->Point, polygon)) { @@ -1250,7 +1250,7 @@ static pcb_r_dir_t LOCtoPadPoly_callback(const pcb_box_t * b, void *cl) { - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; struct lo_info *i = (struct lo_info *) cl; @@ -1427,7 +1427,7 @@ * looks up LOs that are connected to the given polygon * on the given layergroup. All found connections are added to the list */ -static pcb_bool LookupLOConnectionsToPolygon(pcb_polygon_t *Polygon, pcb_cardinal_t LayerGroup) +static pcb_bool LookupLOConnectionsToPolygon(pcb_poly_t *Polygon, pcb_cardinal_t LayerGroup) { pcb_cardinal_t entry; struct lo_info info; @@ -1455,7 +1455,7 @@ pcb_rtree_it_t it; pcb_box_t *b; for(b = pcb_r_first(PCB->Data->Layer[layer].polygon_tree, &it); b != NULL; b = pcb_r_next(&it)) { - pcb_polygon_t *polygon = (pcb_polygon_t *)b; + pcb_poly_t *polygon = (pcb_poly_t *)b; if (!PCB_FLAG_TEST(TheFlag, polygon) && pcb_is_poly_in_poly(polygon, Polygon) && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_POLYGON, Polygon, PCB_FCT_COPPER)) Index: trunk/src/find_misc.c =================================================================== --- trunk/src/find_misc.c (revision 12227) +++ trunk/src/find_misc.c (revision 12228) @@ -189,7 +189,7 @@ case PCB_OBJ_POLYGON: { pcb_layer_id_t layer = pcb_layer_id(PCB->Data, obj->parent.layer); - if (ADD_POLYGON_TO_LIST(layer, (pcb_polygon_t *)obj, 0, NULL, PCB_FCT_START)) + if (ADD_POLYGON_TO_LIST(layer, (pcb_poly_t *)obj, 0, NULL, PCB_FCT_START)) return pcb_true; break; } Index: trunk/src/font.c =================================================================== --- trunk/src/font.c (revision 12227) +++ trunk/src/font.c (revision 12228) @@ -111,7 +111,7 @@ pcb_symbol_t *symbol; pcb_line_t *line; pcb_arc_t *arc; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_coord_t totalminy = PCB_MAX_COORD; /* calculate cell with and height (is at least PCB_DEFAULT_CELLSIZE) @@ -221,9 +221,9 @@ return (line); } -pcb_polygon_t *pcb_font_new_poly_in_sym(pcb_symbol_t *Symbol, int num_points) +pcb_poly_t *pcb_font_new_poly_in_sym(pcb_symbol_t *Symbol, int num_points) { - pcb_polygon_t *p = calloc(sizeof(pcb_polygon_t), 1); + pcb_poly_t *p = calloc(sizeof(pcb_poly_t), 1); if (num_points > 0) { p->PointN = p->PointMax = num_points; p->Points = malloc(sizeof(pcb_point_t) * num_points); @@ -319,7 +319,7 @@ { int i; for (i = 0; i <= PCB_MAX_FONTPOSITION; i++) { - pcb_polygon_t *p; + pcb_poly_t *p; pcb_arc_t *a; free(f->Symbol[i].Line); @@ -397,7 +397,7 @@ memcpy(dst, src, sizeof(pcb_font_t)); for (i = 0; i <= PCB_MAX_FONTPOSITION; i++) { - pcb_polygon_t *p_src; + pcb_poly_t *p_src; pcb_arc_t *a_src; if (src->Symbol[i].Line) { @@ -407,7 +407,7 @@ memset(&dst->Symbol[i].polys, 0, sizeof(polylist_t)); for(p_src = polylist_first(&src->Symbol[i].polys); p_src != NULL; p_src = polylist_next(p_src)) { - pcb_polygon_t *p_dst = pcb_font_new_poly_in_sym(&dst->Symbol[i], p_src->PointN); + pcb_poly_t *p_dst = pcb_font_new_poly_in_sym(&dst->Symbol[i], p_src->PointN); memcpy(p_dst->Points, p_src->Points, p_src->PointN * sizeof(pcb_point_t)); } Index: trunk/src/font.h =================================================================== --- trunk/src/font.h (revision 12227) +++ trunk/src/font.h (revision 12228) @@ -75,7 +75,7 @@ pcb_line_t *pcb_font_new_line_in_sym(pcb_symbol_t *Symbol, pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_coord_t Thickness); pcb_arc_t *pcb_font_new_arc_in_sym(pcb_symbol_t *Symbol, pcb_coord_t cx, pcb_coord_t cy, pcb_coord_t r, pcb_angle_t start, pcb_angle_t delta, pcb_coord_t thickness); -pcb_polygon_t *pcb_font_new_poly_in_sym(pcb_symbol_t *Symbol, int num_points); +pcb_poly_t *pcb_font_new_poly_in_sym(pcb_symbol_t *Symbol, int num_points); void pcb_font_free(pcb_font_t *f); Index: trunk/src/global_typedefs.h =================================================================== --- trunk/src/global_typedefs.h (revision 12227) +++ trunk/src/global_typedefs.h (revision 12228) @@ -40,7 +40,7 @@ typedef struct pcb_point_s pcb_point_t; typedef struct pcb_rat_line_s pcb_rat_t; -typedef struct pcb_polygon_s pcb_polygon_t; +typedef struct pcb_polygon_s pcb_poly_t; typedef struct pcb_pad_s pcb_pad_t; typedef struct pcb_padstack_s pcb_padstack_t; typedef struct pcb_pin_s pcb_pin_t; Index: trunk/src/hid.h =================================================================== --- trunk/src/hid.h (revision 12227) +++ trunk/src/hid.h (revision 12228) @@ -286,8 +286,8 @@ void (*draw_rect) (pcb_hid_gc_t gc_, pcb_coord_t x1_, pcb_coord_t y1_, pcb_coord_t x2_, pcb_coord_t y2_); void (*fill_circle) (pcb_hid_gc_t gc_, pcb_coord_t cx_, pcb_coord_t cy_, pcb_coord_t radius_); void (*fill_polygon) (pcb_hid_gc_t gc_, int n_coords_, pcb_coord_t * x_, pcb_coord_t * y_); - void (*fill_pcb_polygon) (pcb_hid_gc_t gc_, pcb_polygon_t * poly, const pcb_box_t * clip_box); - void (*thindraw_pcb_polygon) (pcb_hid_gc_t gc_, pcb_polygon_t * poly, const pcb_box_t * clip_box); + void (*fill_pcb_polygon) (pcb_hid_gc_t gc_, pcb_poly_t * poly, const pcb_box_t * clip_box); + void (*thindraw_pcb_polygon) (pcb_hid_gc_t gc_, pcb_poly_t * poly, const pcb_box_t * clip_box); void (*fill_pcb_pad) (pcb_hid_gc_t gc_, pcb_pad_t * pad, pcb_bool clip, pcb_bool mask); void (*thindraw_pcb_pad) (pcb_hid_gc_t gc_, pcb_pad_t * pad, pcb_bool clip, pcb_bool mask); void (*fill_pcb_pv) (pcb_hid_gc_t fg_gc, pcb_hid_gc_t bg_gc, pcb_pin_t * pv, pcb_bool drawHole, pcb_bool mask); Index: trunk/src/hid_draw_helpers.c =================================================================== --- trunk/src/hid_draw_helpers.c (revision 12227) +++ trunk/src/hid_draw_helpers.c (revision 12228) @@ -102,7 +102,7 @@ * lets compute the complete no-holes polygon. */ #define BOUNDS_INSIDE_CLIP_THRESHOLD 0.5 -static int should_compute_no_holes(pcb_polygon_t * poly, const pcb_box_t * clip_box) +static int should_compute_no_holes(pcb_poly_t * poly, const pcb_box_t * clip_box) { pcb_coord_t x1, x2, y1, y2; double poly_bounding_area; @@ -134,7 +134,7 @@ #undef BOUNDS_INSIDE_CLIP_THRESHOLD -void pcb_dhlp_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +void pcb_dhlp_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { if (!poly->NoHolesValid) { /* If enough of the polygon is on-screen, compute the entire @@ -160,7 +160,7 @@ /* Draw other parts of the polygon if fullpoly flag is set */ /* NB: No "NoHoles" cache for these */ if (PCB_FLAG_TEST(PCB_FLAG_FULLPOLY, poly)) { - pcb_polygon_t p = *poly; + pcb_poly_t p = *poly; for (p.Clipped = poly->Clipped->f; p.Clipped != poly->Clipped; p.Clipped = p.Clipped->f) pcb_poly_no_holes_dicer(&p, clip_box, fill_contour_cb, gc); @@ -174,7 +174,7 @@ return 0; } -void pcb_dhlp_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +void pcb_dhlp_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { thindraw_contour(gc, poly->Clipped->contours); pcb_poly_holes(poly, clip_box, thindraw_hole_cb, gc); Index: trunk/src/hid_draw_helpers.h =================================================================== --- trunk/src/hid_draw_helpers.h (revision 12227) +++ trunk/src/hid_draw_helpers.h (revision 12228) @@ -1,7 +1,7 @@ #ifndef PCB_HID_DRAW_HELPERS_H #define PCB_HID_DRAW_HELPERS_H -void pcb_dhlp_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box); -void pcb_dhlp_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box); +void pcb_dhlp_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box); +void pcb_dhlp_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box); void pcb_dhlp_fill_pcb_pad(pcb_hid_gc_t gc, pcb_pad_t * pad, pcb_bool clear, pcb_bool mask); void pcb_dhlp_thindraw_pcb_pad(pcb_hid_gc_t gc, pcb_pad_t * pad, pcb_bool clear, pcb_bool mask); void pcb_dhlp_fill_pcb_pv(pcb_hid_gc_t gc, pcb_pin_t * pv, pcb_bool drawHole, pcb_bool mask); Index: trunk/src/hid_nogui.c =================================================================== --- trunk/src/hid_nogui.c (revision 12227) +++ trunk/src/hid_nogui.c (revision 12228) @@ -125,7 +125,7 @@ CRASH("fill_polygon"); } -static void nogui_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +static void nogui_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { CRASH("fill_pcb_polygon"); } Index: trunk/src/layer.c =================================================================== --- trunk/src/layer.c (revision 12227) +++ trunk/src/layer.c (revision 12228) @@ -406,7 +406,7 @@ { pcb_line_t *li; pcb_text_t *te; - pcb_polygon_t *po; + pcb_poly_t *po; pcb_arc_t *ar; memcpy(dst, src, sizeof(pcb_layer_t)); Index: trunk/src/obj_any.h =================================================================== --- trunk/src/obj_any.h (revision 12227) +++ trunk/src/obj_any.h (revision 12228) @@ -39,7 +39,7 @@ pcb_point_t *point; pcb_line_t *line; pcb_text_t *text; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_arc_t *arc; pcb_rat_t *rat; pcb_pad_t *pad; Index: trunk/src/obj_elem.c =================================================================== --- trunk/src/obj_elem.c (revision 12227) +++ trunk/src/obj_elem.c (revision 12228) @@ -276,7 +276,7 @@ } /* see if a polygon is a rectangle. If so, canonicalize it. */ -static int polygon_is_rectangle(pcb_polygon_t *poly) +static int polygon_is_rectangle(pcb_poly_t *poly) { int i, best; pcb_point_t temp[4]; Index: trunk/src/obj_padstack_proto.c =================================================================== --- trunk/src/obj_padstack_proto.c (revision 12227) +++ trunk/src/obj_padstack_proto.c (revision 12228) @@ -120,7 +120,7 @@ int go; n++; - pcb_poly_island_first((*(pcb_polygon_t **)o), &it); + pcb_poly_island_first((*(pcb_poly_t **)o), &it); pcb_poly_contour(&it); for(go = pcb_poly_vect_first(&it, &x, &y), len = 0; go; go = pcb_poly_vect_next(&it, &x, &y)) len++; @@ -136,7 +136,7 @@ } dst->shape[n].data.poly.len = len; dst->shape[n].shape = PCB_PSSH_POLY; - dst->shape[n].clearance = (*(pcb_polygon_t **)o)->Clearance; + dst->shape[n].clearance = (*(pcb_poly_t **)o)->Clearance; } break; default: continue; Index: trunk/src/obj_poly.c =================================================================== --- trunk/src/obj_poly.c (revision 12227) +++ trunk/src/obj_poly.c (revision 12228) @@ -56,11 +56,11 @@ /*** allocation ***/ /* get next slot for a polygon object, allocates memory if necessary */ -pcb_polygon_t *pcb_poly_alloc(pcb_layer_t * layer) +pcb_poly_t *pcb_poly_alloc(pcb_layer_t * layer) { - pcb_polygon_t *new_obj; + pcb_poly_t *new_obj; - new_obj = calloc(sizeof(pcb_polygon_t), 1); + new_obj = calloc(sizeof(pcb_poly_t), 1); new_obj->type = PCB_OBJ_POLYGON; new_obj->Attributes.post_change = pcb_obj_attrib_post_change; PCB_SET_PARENT(new_obj, layer, layer); @@ -70,7 +70,7 @@ return new_obj; } -void pcb_poly_free(pcb_polygon_t * data) +void pcb_poly_free(pcb_poly_t * data) { polylist_remove(data); free(data); @@ -77,7 +77,7 @@ } /* gets the next slot for a point in a polygon struct, allocates memory if necessary */ -pcb_point_t *pcb_poly_point_alloc(pcb_polygon_t *Polygon) +pcb_point_t *pcb_poly_point_alloc(pcb_poly_t *Polygon) { pcb_point_t *points = Polygon->Points; @@ -92,7 +92,7 @@ } /* gets the next slot for a point in a polygon struct, allocates memory if necessary */ -pcb_cardinal_t *pcb_poly_holeidx_new(pcb_polygon_t *Polygon) +pcb_cardinal_t *pcb_poly_holeidx_new(pcb_poly_t *Polygon) { pcb_cardinal_t *holeindex = Polygon->HoleIndex; @@ -107,7 +107,7 @@ } /* frees memory used by a polygon */ -void pcb_poly_free_fields(pcb_polygon_t * polygon) +void pcb_poly_free_fields(pcb_poly_t * polygon) { if (polygon == NULL) return; @@ -119,13 +119,13 @@ pcb_polyarea_free(&polygon->Clipped); pcb_poly_contours_free(&polygon->NoHoles); - reset_obj_mem(pcb_polygon_t, polygon); + reset_obj_mem(pcb_poly_t, polygon); } /*** utility ***/ /* rotates a polygon in 90 degree steps */ -void pcb_poly_rotate90(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y, unsigned Number) +void pcb_poly_rotate90(pcb_poly_t *Polygon, pcb_coord_t X, pcb_coord_t Y, unsigned Number) { PCB_POLY_POINT_LOOP(Polygon); { @@ -135,7 +135,7 @@ pcb_box_rotate90(&Polygon->BoundingBox, X, Y, Number); } -void pcb_poly_rotate(pcb_layer_t *layer, pcb_polygon_t *polygon, pcb_coord_t X, pcb_coord_t Y, double cosa, double sina) +void pcb_poly_rotate(pcb_layer_t *layer, pcb_poly_t *polygon, pcb_coord_t X, pcb_coord_t Y, double cosa, double sina) { pcb_r_delete_entry(layer->polygon_tree, (pcb_box_t *) polygon); PCB_POLY_POINT_LOOP(polygon); @@ -147,7 +147,7 @@ pcb_r_insert_entry(layer->polygon_tree, (pcb_box_t *) polygon, 0); } -void pcb_poly_mirror(pcb_layer_t *layer, pcb_polygon_t *polygon, pcb_coord_t y_offs) +void pcb_poly_mirror(pcb_layer_t *layer, pcb_poly_t *polygon, pcb_coord_t y_offs) { if (layer->polygon_tree != NULL) pcb_r_delete_entry(layer->polygon_tree, (pcb_box_t *)polygon); @@ -162,7 +162,7 @@ pcb_r_insert_entry(layer->polygon_tree, (pcb_box_t *)polygon, 0); } -void pcb_poly_flip_side(pcb_layer_t *layer, pcb_polygon_t *polygon) +void pcb_poly_flip_side(pcb_layer_t *layer, pcb_poly_t *polygon) { pcb_r_delete_entry(layer->polygon_tree, (pcb_box_t *) polygon); PCB_POLY_POINT_LOOP(polygon); @@ -178,7 +178,7 @@ /* sets the bounding box of a polygons */ -void pcb_poly_bbox(pcb_polygon_t *Polygon) +void pcb_poly_bbox(pcb_poly_t *Polygon) { Polygon->BoundingBox.X1 = Polygon->BoundingBox.Y1 = PCB_MAX_COORD; Polygon->BoundingBox.X2 = Polygon->BoundingBox.Y2 = 0; @@ -195,9 +195,9 @@ } /* creates a new polygon from the old formats rectangle data */ -pcb_polygon_t *pcb_poly_new_from_rectangle(pcb_layer_t *Layer, pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_coord_t Clearance, pcb_flag_t Flags) +pcb_poly_t *pcb_poly_new_from_rectangle(pcb_layer_t *Layer, pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_coord_t Clearance, pcb_flag_t Flags) { - pcb_polygon_t *polygon = pcb_poly_new(Layer, Clearance, Flags); + pcb_poly_t *polygon = pcb_poly_new(Layer, Clearance, Flags); if (!polygon) return (polygon); @@ -210,13 +210,13 @@ return (polygon); } -pcb_polygon_t *pcb_poly_new_from_poly(pcb_layer_t *Layer, pcb_polygon_t *src, pcb_coord_t offs, pcb_coord_t Clearance, pcb_flag_t Flags) +pcb_poly_t *pcb_poly_new_from_poly(pcb_layer_t *Layer, pcb_poly_t *src, pcb_coord_t offs, pcb_coord_t Clearance, pcb_flag_t Flags) { pcb_coord_t x, y; pcb_poly_it_t it; pcb_pline_t *pl; int go; - pcb_polygon_t *polygon = pcb_poly_new(Layer, Clearance, Flags); + pcb_poly_t *polygon = pcb_poly_new(Layer, Clearance, Flags); if (!polygon) return (polygon); @@ -236,7 +236,7 @@ -void pcb_add_polygon_on_layer(pcb_layer_t *Layer, pcb_polygon_t *polygon) +void pcb_add_polygon_on_layer(pcb_layer_t *Layer, pcb_poly_t *polygon) { pcb_poly_bbox(polygon); if (!Layer->polygon_tree) @@ -247,9 +247,9 @@ } /* creates a new polygon on a layer */ -pcb_polygon_t *pcb_poly_new(pcb_layer_t *Layer, pcb_coord_t Clearance, pcb_flag_t Flags) +pcb_poly_t *pcb_poly_new(pcb_layer_t *Layer, pcb_coord_t Clearance, pcb_flag_t Flags) { - pcb_polygon_t *polygon = pcb_poly_alloc(Layer); + pcb_poly_t *polygon = pcb_poly_alloc(Layer); /* copy values */ polygon->Flags = Flags; @@ -261,7 +261,7 @@ return (polygon); } -static pcb_polygon_t *pcb_poly_copy_meta(pcb_polygon_t *dst, pcb_polygon_t *src) +static pcb_poly_t *pcb_poly_copy_meta(pcb_poly_t *dst, pcb_poly_t *src) { if (dst == NULL) return NULL; @@ -269,10 +269,10 @@ return dst; } -pcb_polygon_t *pcb_poly_dup(pcb_layer_t *dst, pcb_polygon_t *src) +pcb_poly_t *pcb_poly_dup(pcb_layer_t *dst, pcb_poly_t *src) { pcb_board_t *pcb; - pcb_polygon_t *p = pcb_poly_new(dst, src->Clearance, src->Flags); + pcb_poly_t *p = pcb_poly_new(dst, src->Clearance, src->Flags); pcb_poly_copy(p, src, 0, 0); pcb_add_polygon_on_layer(dst, p); pcb_poly_copy_meta(p, src); @@ -283,10 +283,10 @@ return p; } -pcb_polygon_t *pcb_poly_dup_at(pcb_layer_t *dst, pcb_polygon_t *src, pcb_coord_t dx, pcb_coord_t dy) +pcb_poly_t *pcb_poly_dup_at(pcb_layer_t *dst, pcb_poly_t *src, pcb_coord_t dx, pcb_coord_t dy) { pcb_board_t *pcb; - pcb_polygon_t *p = pcb_poly_new(dst, src->Clearance, src->Flags); + pcb_poly_t *p = pcb_poly_new(dst, src->Clearance, src->Flags); pcb_poly_copy(p, src, dx, dy); pcb_add_polygon_on_layer(dst, p); pcb_poly_copy_meta(p, src); @@ -298,7 +298,7 @@ } /* creates a new point in a polygon */ -pcb_point_t *pcb_poly_point_new(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y) +pcb_point_t *pcb_poly_point_new(pcb_poly_t *Polygon, pcb_coord_t X, pcb_coord_t Y) { pcb_point_t *point = pcb_poly_point_alloc(Polygon); @@ -310,7 +310,7 @@ } /* creates a new hole in a polygon */ -pcb_polygon_t *pcb_poly_hole_new(pcb_polygon_t * Polygon) +pcb_poly_t *pcb_poly_hole_new(pcb_poly_t * Polygon) { pcb_cardinal_t *holeindex = pcb_poly_holeidx_new(Polygon); *holeindex = Polygon->PointN; @@ -318,7 +318,7 @@ } /* copies data from one polygon to another; 'Dest' has to exist */ -pcb_polygon_t *pcb_poly_copy(pcb_polygon_t *Dest, pcb_polygon_t *Src, pcb_coord_t dx, pcb_coord_t dy) +pcb_poly_t *pcb_poly_copy(pcb_poly_t *Dest, pcb_poly_t *Src, pcb_coord_t dx, pcb_coord_t dy) { pcb_cardinal_t hole = 0; pcb_cardinal_t n; @@ -353,7 +353,7 @@ return area; } -double pcb_poly_area(const pcb_polygon_t *poly) +double pcb_poly_area(const pcb_poly_t *poly) { double area; @@ -375,10 +375,10 @@ /*** ops ***/ /* copies a polygon to buffer */ -void *pcb_polyop_add_to_buffer(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_add_to_buffer(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_layer_t *layer = &ctx->buffer.dst->Layer[pcb_layer_id(ctx->buffer.src, Layer)]; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; polygon = pcb_poly_new(layer, Polygon->Clearance, Polygon->Flags); pcb_poly_copy(polygon, Polygon, 0, 0); @@ -398,7 +398,7 @@ /* moves a polygon to buffer. Doesn't allocate memory for the points */ -void *pcb_polyop_move_to_buffer(pcb_opctx_t *ctx, pcb_layer_t * layer, pcb_polygon_t * polygon) +void *pcb_polyop_move_to_buffer(pcb_opctx_t *ctx, pcb_layer_t * layer, pcb_poly_t * polygon) { pcb_layer_t *lay = &ctx->buffer.dst->Layer[pcb_layer_id(ctx->buffer.src, layer)]; @@ -422,7 +422,7 @@ } /* Handle attempts to change the clearance of a polygon. */ -void *pcb_polyop_change_clear_size(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *poly) +void *pcb_polyop_change_clear_size(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *poly) { static int shown_this_message = 0; if (!shown_this_message) { @@ -437,7 +437,7 @@ } /* changes the CLEARPOLY flag of a polygon */ -void *pcb_polyop_change_clear(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_change_clear(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { if (PCB_FLAG_TEST(PCB_FLAG_LOCK, Polygon)) return (NULL); @@ -450,7 +450,7 @@ } /* inserts a point into a polygon */ -void *pcb_polyop_insert_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_insert_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_point_t save; pcb_cardinal_t n; @@ -500,7 +500,7 @@ } /* changes the clearance flag of a polygon */ -void *pcb_polyop_change_join(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *poly) +void *pcb_polyop_change_join(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *poly) { if (PCB_FLAG_TEST(PCB_FLAG_LOCK, poly)) return (NULL); @@ -520,7 +520,7 @@ } /* low level routine to move a polygon */ -void pcb_poly_move(pcb_polygon_t *Polygon, pcb_coord_t DX, pcb_coord_t DY) +void pcb_poly_move(pcb_poly_t *Polygon, pcb_coord_t DX, pcb_coord_t DY) { PCB_POLY_POINT_LOOP(Polygon); { @@ -531,7 +531,7 @@ } /* moves a polygon */ -void *pcb_polyop_move_noclip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_move_noclip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { if (Layer->meta.real.vis) { pcb_poly_invalidate_erase(Polygon); @@ -547,7 +547,7 @@ return Polygon; } -void *pcb_polyop_move(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_move(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_poly_pprestore(Polygon); pcb_polyop_move_noclip(ctx, Layer, Polygon); @@ -555,7 +555,7 @@ return Polygon; } -void *pcb_polyop_clip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_clip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { if (ctx->clip.restore) pcb_poly_pprestore(Polygon); @@ -564,7 +564,7 @@ return Polygon; } /* moves a polygon-point */ -void *pcb_polyop_move_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point) +void *pcb_polyop_move_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point) { pcb_poly_pprestore(Polygon); if (Layer->meta.real.vis) { @@ -585,7 +585,7 @@ } /* moves a polygon between layers; lowlevel routines */ -void *pcb_polyop_move_to_layer_low(pcb_opctx_t *ctx, pcb_layer_t * Source, pcb_polygon_t * polygon, pcb_layer_t * Destination) +void *pcb_polyop_move_to_layer_low(pcb_opctx_t *ctx, pcb_layer_t * Source, pcb_poly_t * polygon, pcb_layer_t * Destination) { pcb_r_delete_entry(Source->polygon_tree, (pcb_box_t *) polygon); @@ -605,7 +605,7 @@ struct mptlc { pcb_layer_id_t snum, dnum; int type; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; } mptlc; pcb_r_dir_t mptl_pin_callback(const pcb_box_t * b, void *cl) @@ -624,9 +624,9 @@ } /* moves a polygon between layers */ -void *pcb_polyop_move_to_layer(pcb_opctx_t *ctx, pcb_layer_t * Layer, pcb_polygon_t * Polygon) +void *pcb_polyop_move_to_layer(pcb_opctx_t *ctx, pcb_layer_t * Layer, pcb_poly_t * Polygon) { - pcb_polygon_t *newone; + pcb_poly_t *newone; struct mptlc d; if (PCB_FLAG_TEST(PCB_FLAG_LOCK, Polygon)) { @@ -657,7 +657,7 @@ /* destroys a polygon from a layer */ -void *pcb_polyop_destroy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_destroy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_r_delete_entry(Layer->polygon_tree, (pcb_box_t *) Polygon); pcb_poly_free_fields(Polygon); @@ -668,7 +668,7 @@ } /* removes a polygon-point from a polygon and destroys the data */ -void *pcb_polyop_destroy_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point) +void *pcb_polyop_destroy_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point) { pcb_cardinal_t point_idx; pcb_cardinal_t i; @@ -705,7 +705,7 @@ } /* removes a polygon from a layer */ -void *pcb_polyop_remove(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_remove(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { /* erase from screen */ pcb_poly_pprestore(Polygon); @@ -719,7 +719,7 @@ return NULL; } -void *pcb_poly_remove(pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_poly_remove(pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_opctx_t ctx; @@ -732,7 +732,7 @@ /* Removes a contour from a polygon. If removing the outer contour, it removes the whole polygon. */ -void *pcb_polyop_remove_counter(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_cardinal_t contour) +void *pcb_polyop_remove_counter(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_cardinal_t contour) { pcb_cardinal_t contour_start, contour_end, contour_points; pcb_cardinal_t i; @@ -779,7 +779,7 @@ } /* removes a polygon-point from a polygon */ -void *pcb_polyop_remove_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point) +void *pcb_polyop_remove_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point) { pcb_cardinal_t point_idx; pcb_cardinal_t i; @@ -831,9 +831,9 @@ } /* copies a polygon */ -void *pcb_polyop_copy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_copy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { - pcb_polygon_t *polygon; + pcb_poly_t *polygon; polygon = pcb_poly_new(Layer, Polygon->Clearance, pcb_no_flags()); pcb_poly_copy(polygon, Polygon, ctx->copy.DeltaX, ctx->copy.DeltaY); @@ -848,7 +848,7 @@ return (polygon); } -void *pcb_polyop_rotate90(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_rotate90(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_poly_pprestore(Polygon); if (Layer->meta.real.vis) @@ -865,7 +865,7 @@ return Polygon; } -void *pcb_polyop_change_flag(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void *pcb_polyop_change_flag(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon) { static pcb_flag_values_t pcb_poly_flags = 0; if (pcb_poly_flags == 0) @@ -894,7 +894,7 @@ /*** iteration helpers ***/ -void pcb_poly_map_contours(pcb_polygon_t *p, void *ctx, pcb_poly_map_cb_t *cb) +void pcb_poly_map_contours(pcb_poly_t *p, void *ctx, pcb_poly_map_cb_t *cb) { pcb_polyarea_t *pa; pcb_pline_t *pl; @@ -916,7 +916,7 @@ } while(pa != p->Clipped); } -void *pcb_polyop_invalidate_label(pcb_opctx_t *ctx, pcb_layer_t *layer, pcb_polygon_t *poly) +void *pcb_polyop_invalidate_label(pcb_opctx_t *ctx, pcb_layer_t *layer, pcb_poly_t *poly) { pcb_poly_name_invalidate_draw(poly); return poly; @@ -924,7 +924,7 @@ /*** draw ***/ -static pcb_bool is_poly_term_vert(const pcb_polygon_t *poly) +static pcb_bool is_poly_term_vert(const pcb_poly_t *poly) { pcb_coord_t dx, dy; @@ -940,7 +940,7 @@ } -void pcb_poly_name_invalidate_draw(pcb_polygon_t *poly) +void pcb_poly_name_invalidate_draw(pcb_poly_t *poly) { if (poly->term != NULL) { pcb_text_t text; @@ -950,7 +950,7 @@ } } -void pcb_poly_draw_label(pcb_polygon_t *poly) +void pcb_poly_draw_label(pcb_poly_t *poly) { if (poly->term != NULL) pcb_term_label_draw((poly->BoundingBox.X1 + poly->BoundingBox.X2)/2, (poly->BoundingBox.Y1 + poly->BoundingBox.Y2)/2, @@ -957,7 +957,7 @@ 100.0, is_poly_term_vert(poly), pcb_true, poly->term, poly->intconn); } -void pcb_poly_draw_(pcb_polygon_t *polygon, const pcb_box_t *drawn_area, int allow_term_gfx) +void pcb_poly_draw_(pcb_poly_t *polygon, const pcb_box_t *drawn_area, int allow_term_gfx) { if ((pcb_gui->thindraw_pcb_polygon != NULL) && (conf_core.editor.thin_draw || conf_core.editor.thin_draw_poly || conf_core.editor.wireframe_draw)) { @@ -989,7 +989,7 @@ /* If checking planes, thin-draw any pieces which have been clipped away */ if (pcb_gui->thindraw_pcb_polygon != NULL && conf_core.editor.check_planes && !PCB_FLAG_TEST(PCB_FLAG_FULLPOLY, polygon)) { - pcb_polygon_t poly = *polygon; + pcb_poly_t poly = *polygon; for (poly.Clipped = polygon->Clipped->f; poly.Clipped != polygon->Clipped; poly.Clipped = poly.Clipped->f) pcb_gui->thindraw_pcb_polygon(Output.fgGC, &poly, drawn_area); @@ -1001,7 +1001,7 @@ } } -static void pcb_poly_draw(pcb_layer_t *layer, pcb_polygon_t *polygon, const pcb_box_t *drawn_area, int allow_term_gfx) +static void pcb_poly_draw(pcb_layer_t *layer, pcb_poly_t *polygon, const pcb_box_t *drawn_area, int allow_term_gfx) { static const char *color; char buf[sizeof("#XXXXXX")]; @@ -1027,7 +1027,7 @@ pcb_r_dir_t pcb_poly_draw_callback(const pcb_box_t * b, void *cl) { pcb_draw_info_t *i = cl; - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; if (!polygon->Clipped) return PCB_R_DIR_NOT_FOUND; @@ -1043,7 +1043,7 @@ pcb_r_dir_t pcb_poly_draw_term_callback(const pcb_box_t * b, void *cl) { pcb_draw_info_t *i = cl; - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; if (!polygon->Clipped) return PCB_R_DIR_NOT_FOUND; @@ -1057,13 +1057,13 @@ } /* erases a polygon on a layer */ -void pcb_poly_invalidate_erase(pcb_polygon_t *Polygon) +void pcb_poly_invalidate_erase(pcb_poly_t *Polygon) { pcb_draw_invalidate(Polygon); pcb_flag_erase(&Polygon->Flags); } -void pcb_poly_invalidate_draw(pcb_layer_t *Layer, pcb_polygon_t *Polygon) +void pcb_poly_invalidate_draw(pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_draw_invalidate(Polygon); } Index: trunk/src/obj_poly.h =================================================================== --- trunk/src/obj_poly.h (revision 12227) +++ trunk/src/obj_poly.h (revision 12228) @@ -49,34 +49,34 @@ -pcb_polygon_t *pcb_poly_alloc(pcb_layer_t * layer); -void pcb_poly_free(pcb_polygon_t * data); -pcb_point_t *pcb_poly_point_alloc(pcb_polygon_t *Polygon); -pcb_cardinal_t *pcb_poly_holeidx_new(pcb_polygon_t *Polygon); -void pcb_poly_free_fields(pcb_polygon_t * polygon); +pcb_poly_t *pcb_poly_alloc(pcb_layer_t * layer); +void pcb_poly_free(pcb_poly_t * data); +pcb_point_t *pcb_poly_point_alloc(pcb_poly_t *Polygon); +pcb_cardinal_t *pcb_poly_holeidx_new(pcb_poly_t *Polygon); +void pcb_poly_free_fields(pcb_poly_t * polygon); -void pcb_poly_bbox(pcb_polygon_t *Polygon); -pcb_polygon_t *pcb_poly_new_from_rectangle(pcb_layer_t *Layer, pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_coord_t Clearance, pcb_flag_t Flags); -pcb_polygon_t *pcb_poly_new_from_poly(pcb_layer_t *Layer, pcb_polygon_t *src, pcb_coord_t offs, pcb_coord_t Clearance, pcb_flag_t Flags); -pcb_polygon_t *pcb_poly_new(pcb_layer_t *Layer, pcb_coord_t Clearance, pcb_flag_t Flags); -pcb_polygon_t *pcb_poly_dup(pcb_layer_t *dst, pcb_polygon_t *src); -pcb_polygon_t *pcb_poly_dup_at(pcb_layer_t *dst, pcb_polygon_t *src, pcb_coord_t dx, pcb_coord_t dy); -pcb_point_t *pcb_poly_point_new(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y); -pcb_polygon_t *pcb_poly_hole_new(pcb_polygon_t * Polygon); -void *pcb_poly_remove(pcb_layer_t *Layer, pcb_polygon_t *Polygon); +void pcb_poly_bbox(pcb_poly_t *Polygon); +pcb_poly_t *pcb_poly_new_from_rectangle(pcb_layer_t *Layer, pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_coord_t Clearance, pcb_flag_t Flags); +pcb_poly_t *pcb_poly_new_from_poly(pcb_layer_t *Layer, pcb_poly_t *src, pcb_coord_t offs, pcb_coord_t Clearance, pcb_flag_t Flags); +pcb_poly_t *pcb_poly_new(pcb_layer_t *Layer, pcb_coord_t Clearance, pcb_flag_t Flags); +pcb_poly_t *pcb_poly_dup(pcb_layer_t *dst, pcb_poly_t *src); +pcb_poly_t *pcb_poly_dup_at(pcb_layer_t *dst, pcb_poly_t *src, pcb_coord_t dx, pcb_coord_t dy); +pcb_point_t *pcb_poly_point_new(pcb_poly_t *Polygon, pcb_coord_t X, pcb_coord_t Y); +pcb_poly_t *pcb_poly_hole_new(pcb_poly_t * Polygon); +void *pcb_poly_remove(pcb_layer_t *Layer, pcb_poly_t *Polygon); -void pcb_poly_rotate90(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y, unsigned Number); -void pcb_poly_rotate(pcb_layer_t *layer, pcb_polygon_t *poly, pcb_coord_t X, pcb_coord_t Y, double cosa, double sina); -void pcb_poly_mirror(pcb_layer_t *layer, pcb_polygon_t *polygon, pcb_coord_t y_offs); -void pcb_poly_flip_side(pcb_layer_t *layer, pcb_polygon_t *polygon); +void pcb_poly_rotate90(pcb_poly_t *Polygon, pcb_coord_t X, pcb_coord_t Y, unsigned Number); +void pcb_poly_rotate(pcb_layer_t *layer, pcb_poly_t *poly, pcb_coord_t X, pcb_coord_t Y, double cosa, double sina); +void pcb_poly_mirror(pcb_layer_t *layer, pcb_poly_t *polygon, pcb_coord_t y_offs); +void pcb_poly_flip_side(pcb_layer_t *layer, pcb_poly_t *polygon); -void pcb_poly_move(pcb_polygon_t *Polygon, pcb_coord_t DX, pcb_coord_t DY); -pcb_polygon_t *pcb_poly_copy(pcb_polygon_t *Dest, pcb_polygon_t *Src, pcb_coord_t dx, pcb_coord_t dy); +void pcb_poly_move(pcb_poly_t *Polygon, pcb_coord_t DX, pcb_coord_t DY); +pcb_poly_t *pcb_poly_copy(pcb_poly_t *Dest, pcb_poly_t *Src, pcb_coord_t dx, pcb_coord_t dy); /* Add objects without creating them or making any "sanity modifications" to them */ -void pcb_add_polygon_on_layer(pcb_layer_t *Layer, pcb_polygon_t *polygon); +void pcb_add_polygon_on_layer(pcb_layer_t *Layer, pcb_poly_t *polygon); -double pcb_poly_area(const pcb_polygon_t *poly); +double pcb_poly_area(const pcb_poly_t *poly); /*** helpers for iterating over countours */ @@ -91,13 +91,13 @@ } pcb_poly_event_t; /* return non-zero to quit mapping immediatley */ -typedef int pcb_poly_map_cb_t(pcb_polygon_t *p, void *ctx, pcb_poly_event_t ev, pcb_coord_t x, pcb_coord_t y); +typedef int pcb_poly_map_cb_t(pcb_poly_t *p, void *ctx, pcb_poly_event_t ev, pcb_coord_t x, pcb_coord_t y); /* call cb for each point of each island and cutout */ -void pcb_poly_map_contours(pcb_polygon_t *p, void *ctx, pcb_poly_map_cb_t *cb); +void pcb_poly_map_contours(pcb_poly_t *p, void *ctx, pcb_poly_map_cb_t *cb); typedef struct pcb_poly_it_s { - const pcb_polygon_t *p; + const pcb_poly_t *p; pcb_polyarea_t *pa; pcb_pline_t *cntr; pcb_vnode_t *v; @@ -104,7 +104,7 @@ } pcb_poly_it_t; /* Set the iterator to the first island of the polygon; returns NULL if no contour available */ -static inline PCB_FUNC_UNUSED pcb_polyarea_t *pcb_poly_island_first(const pcb_polygon_t *p, pcb_poly_it_t *it) +static inline PCB_FUNC_UNUSED pcb_polyarea_t *pcb_poly_island_first(const pcb_poly_t *p, pcb_poly_it_t *it) { it->p = p; it->pa = p->Clipped; @@ -197,7 +197,7 @@ /*** loops ***/ #define PCB_POLY_LOOP(layer) do { \ - pcb_polygon_t *polygon; \ + pcb_poly_t *polygon; \ gdl_iterator_t __it__; \ linelist_foreach(&(layer)->Polygon, &__it__, polygon) { Index: trunk/src/obj_poly_draw.h =================================================================== --- trunk/src/obj_poly_draw.h (revision 12227) +++ trunk/src/obj_poly_draw.h (revision 12228) @@ -32,8 +32,8 @@ pcb_r_dir_t pcb_poly_draw_term_callback(const pcb_box_t * b, void *cl); #endif -void pcb_poly_invalidate_erase(pcb_polygon_t *Polygon); -void pcb_poly_invalidate_draw(pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void pcb_poly_name_invalidate_draw(pcb_polygon_t *poly); -void pcb_poly_draw_label(pcb_polygon_t *poly); +void pcb_poly_invalidate_erase(pcb_poly_t *Polygon); +void pcb_poly_invalidate_draw(pcb_layer_t *Layer, pcb_poly_t *Polygon); +void pcb_poly_name_invalidate_draw(pcb_poly_t *poly); +void pcb_poly_draw_label(pcb_poly_t *poly); Index: trunk/src/obj_poly_list.h =================================================================== --- trunk/src/obj_poly_list.h (revision 12227) +++ trunk/src/obj_poly_list.h (revision 12228) @@ -28,7 +28,7 @@ /* List of Lines */ #define TDL(x) polylist_ ## x #define TDL_LIST_T polylist_t -#define TDL_ITEM_T pcb_polygon_t +#define TDL_ITEM_T pcb_poly_t #define TDL_FIELD link #define TDL_SIZE_T size_t #define TDL_FUNC Index: trunk/src/obj_poly_op.h =================================================================== --- trunk/src/obj_poly_op.h (revision 12227) +++ trunk/src/obj_poly_op.h (revision 12228) @@ -28,26 +28,26 @@ #include "operation.h" -void *pcb_polyop_add_to_buffer(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_move_to_buffer(pcb_opctx_t *ctx, pcb_layer_t * layer, pcb_polygon_t * polygon); -void *pcb_polyop_change_clear_size(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *poly); -void *pcb_polyop_change_clear(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_insert_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_move(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_move_noclip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_clip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_move_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point); -void *pcb_polyop_move_to_layer_low(pcb_opctx_t *ctx, pcb_layer_t * Source, pcb_polygon_t * polygon, pcb_layer_t * Destination); -void *pcb_polyop_move_to_layer(pcb_opctx_t *ctx, pcb_layer_t * Layer, pcb_polygon_t * Polygon); -void *pcb_polyop_destroy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_destroy_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point); -void *pcb_polyop_remove(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_remove_counter(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_cardinal_t contour); -void *pcb_polyop_remove_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon, pcb_point_t *Point); -void *pcb_polyop_copy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_rotate90(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_change_flag(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *Polygon); -void *pcb_polyop_invalidate_label(pcb_opctx_t *ctx, pcb_layer_t *layer, pcb_polygon_t *poly); -void *pcb_polyop_change_join(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_polygon_t *poly); +void *pcb_polyop_add_to_buffer(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_move_to_buffer(pcb_opctx_t *ctx, pcb_layer_t * layer, pcb_poly_t * polygon); +void *pcb_polyop_change_clear_size(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *poly); +void *pcb_polyop_change_clear(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_insert_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_move(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_move_noclip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_clip(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_move_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point); +void *pcb_polyop_move_to_layer_low(pcb_opctx_t *ctx, pcb_layer_t * Source, pcb_poly_t * polygon, pcb_layer_t * Destination); +void *pcb_polyop_move_to_layer(pcb_opctx_t *ctx, pcb_layer_t * Layer, pcb_poly_t * Polygon); +void *pcb_polyop_destroy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_destroy_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point); +void *pcb_polyop_remove(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_remove_counter(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_cardinal_t contour); +void *pcb_polyop_remove_point(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon, pcb_point_t *Point); +void *pcb_polyop_copy(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_rotate90(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_change_flag(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *Polygon); +void *pcb_polyop_invalidate_label(pcb_opctx_t *ctx, pcb_layer_t *layer, pcb_poly_t *poly); +void *pcb_polyop_change_join(pcb_opctx_t *ctx, pcb_layer_t *Layer, pcb_poly_t *poly); Index: trunk/src/obj_subc.c =================================================================== --- trunk/src/obj_subc.c (revision 12227) +++ trunk/src/obj_subc.c (revision 12228) @@ -182,9 +182,9 @@ sc->aux_cache[0] = NULL; } -static pcb_polygon_t *sqline2term(pcb_layer_t *dst, pcb_line_t *line) +static pcb_poly_t *sqline2term(pcb_layer_t *dst, pcb_line_t *line) { - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_coord_t x[4], y[4]; int n; @@ -211,7 +211,7 @@ pcb_layer_t *target = (source->meta.bound.type & PCB_LYT_TOP) ? top : bottom; switch(o->type) { case PCB_OBJ_POLYGON: - pcb_polyop_move_to_layer_low(NULL, source, (pcb_polygon_t *)o, target); + pcb_polyop_move_to_layer_low(NULL, source, (pcb_poly_t *)o, target); break; case PCB_OBJ_LINE: pcb_lineop_move_to_layer_low(NULL, source, (pcb_line_t *)o, target); @@ -254,7 +254,7 @@ pcb_layer_t *dst, *src; pcb_line_t *line; pcb_text_t *text; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc; pcb_layer_type_t ltype; @@ -412,7 +412,7 @@ if (mask > 0) { if (PCB_FLAG_TEST(PCB_FLAG_SQUARE, via)) { pcb_line_t line; - pcb_polygon_t *poly; + pcb_poly_t *poly; memset(&line, 0, sizeof(line)); line.Point1.X = line.Point2.X = via->X; line.Point1.Y = line.Point2.Y = via->Y; @@ -499,7 +499,7 @@ pcb_layer_t *ly = sc->data->Layer + n; pcb_line_t *line; pcb_text_t *text; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc; gdl_iterator_t it; @@ -671,7 +671,7 @@ for(n = 0; n < src->data->LayerN; n++) { pcb_layer_t *sl = src->data->Layer + n; pcb_layer_t *dl = sc->data->Layer + n; - pcb_polygon_t *poly, *npoly; + pcb_poly_t *poly, *npoly; gdl_iterator_t it; polylist_foreach(&sl->Polygon, &it, poly) { @@ -744,7 +744,7 @@ pcb_layer_t *sl = sc->data->Layer + n; pcb_line_t *line; pcb_text_t *text; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc; gdl_iterator_t it; @@ -842,7 +842,7 @@ { pcb_line_t *line; pcb_text_t *text; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc; gdl_iterator_t it; int chg = 0; Index: trunk/src/obj_term.c =================================================================== --- trunk/src/obj_term.c (revision 12227) +++ trunk/src/obj_term.c (revision 12228) @@ -218,7 +218,7 @@ pcb_attribute_remove(&r->obj->Attributes, "term"); if (r->obj->type == PCB_OBJ_POLYGON) - pcb_poly_init_clip(r->obj->parent.layer->parent, r->obj->parent.layer, (pcb_polygon_t *)r->obj); + pcb_poly_init_clip(r->obj->parent.layer->parent, r->obj->parent.layer, (pcb_poly_t *)r->obj); return res; } @@ -270,7 +270,7 @@ undo_term_rename_swap(r); if (obj->type == PCB_OBJ_POLYGON) - pcb_poly_init_clip(obj->parent.layer->parent, obj->parent.layer, (pcb_polygon_t *)obj); + pcb_poly_init_clip(obj->parent.layer->parent, obj->parent.layer, (pcb_poly_t *)obj); pcb_undo_inc_serial(); return PCB_TERM_ERR_SUCCESS; Index: trunk/src/obj_text.c =================================================================== --- trunk/src/obj_text.c (revision 12227) +++ trunk/src/obj_text.c (revision 12228) @@ -200,7 +200,7 @@ pcb_coord_t min_final_radius; pcb_coord_t min_unscaled_radius; pcb_bool first_time = pcb_true; - pcb_polygon_t *poly; + pcb_poly_t *poly; s = rendered; @@ -674,7 +674,7 @@ /*** draw ***/ #define MAX_SIMPLE_POLY_POINTS 256 -static void draw_text_poly(pcb_text_t *Text, pcb_polygon_t *poly, pcb_coord_t x0, int xordraw, pcb_coord_t xordx, pcb_coord_t xordy) +static void draw_text_poly(pcb_text_t *Text, pcb_poly_t *poly, pcb_coord_t x0, int xordraw, pcb_coord_t xordx, pcb_coord_t xordy) { pcb_coord_t x[MAX_SIMPLE_POLY_POINTS], y[MAX_SIMPLE_POLY_POINTS]; int max, n; @@ -727,7 +727,7 @@ if (*string <= PCB_MAX_FONTPOSITION && font->Symbol[*string].Valid) { pcb_line_t *line = font->Symbol[*string].Line; pcb_line_t newline; - pcb_polygon_t *p; + pcb_poly_t *p; pcb_arc_t *a, newarc; for (n = font->Symbol[*string].LineN; n; n--, line++) { Index: trunk/src/operation.c =================================================================== --- trunk/src/operation.c (revision 12227) +++ trunk/src/operation.c (revision 12228) @@ -67,12 +67,12 @@ case PCB_TYPE_POLYGON: if (F->Polygon) - return (F->Polygon(ctx, (pcb_layer_t *) Ptr1, (pcb_polygon_t *) Ptr2)); + return (F->Polygon(ctx, (pcb_layer_t *) Ptr1, (pcb_poly_t *) Ptr2)); break; case PCB_TYPE_POLYGON_POINT: if (F->Point) - return (F->Point(ctx, (pcb_layer_t *) Ptr1, (pcb_polygon_t *) Ptr2, (pcb_point_t *) Ptr3)); + return (F->Point(ctx, (pcb_layer_t *) Ptr1, (pcb_poly_t *) Ptr2, (pcb_point_t *) Ptr3)); break; case PCB_TYPE_VIA: Index: trunk/src/operation.h =================================================================== --- trunk/src/operation.h (revision 12227) +++ trunk/src/operation.h (revision 12228) @@ -131,7 +131,7 @@ typedef struct { void *(*Line)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_line_t *); void *(*Text)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_text_t *); - void *(*Polygon)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_polygon_t *); + void *(*Polygon)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_poly_t *); void *(*Via)(pcb_opctx_t *ctx, pcb_pin_t *); void *(*Element)(pcb_opctx_t *ctx, pcb_element_t *); void *(*ElementName)(pcb_opctx_t *ctx, pcb_element_t *); @@ -138,7 +138,7 @@ void *(*Pin)(pcb_opctx_t *ctx, pcb_element_t *, pcb_pin_t *); void *(*Pad)(pcb_opctx_t *ctx, pcb_element_t *, pcb_pad_t *); void *(*LinePoint)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_line_t *, pcb_point_t *); - void *(*Point)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_polygon_t *, pcb_point_t *); + void *(*Point)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_poly_t *, pcb_point_t *); void *(*Arc)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_arc_t *); void *(*Rat)(pcb_opctx_t *ctx, pcb_rat_t *); void *(*ArcPoint)(pcb_opctx_t *ctx, pcb_layer_t *, pcb_arc_t *, int *end_id); Index: trunk/src/polygon.c =================================================================== --- trunk/src/polygon.c (revision 12227) +++ trunk/src/polygon.c (revision 12228) @@ -60,7 +60,7 @@ static double rotate_circle_seg[4]; -static int Unsubtract(pcb_polyarea_t * np1, pcb_polygon_t * p); +static int Unsubtract(pcb_polyarea_t * np1, pcb_poly_t * p); void pcb_polygon_init(void) { @@ -73,7 +73,7 @@ rotate_circle_seg[3] = cos_ang; } -pcb_cardinal_t pcb_poly_point_idx(pcb_polygon_t *polygon, pcb_point_t *point) +pcb_cardinal_t pcb_poly_point_idx(pcb_poly_t *polygon, pcb_point_t *point) { assert(point >= polygon->Points); assert(point <= polygon->Points + polygon->PointN); @@ -81,7 +81,7 @@ } /* Find contour number: 0 for outer, 1 for first hole etc.. */ -pcb_cardinal_t pcb_poly_contour_point(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_point(pcb_poly_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t i; pcb_cardinal_t contour = 0; @@ -92,7 +92,7 @@ return contour; } -pcb_cardinal_t pcb_poly_contour_next_point(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_next_point(pcb_poly_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t contour; pcb_cardinal_t this_contour_start; @@ -110,7 +110,7 @@ return point; } -pcb_cardinal_t pcb_poly_contour_prev_point(pcb_polygon_t *polygon, pcb_cardinal_t point) +pcb_cardinal_t pcb_poly_contour_prev_point(pcb_poly_t *polygon, pcb_cardinal_t point) { pcb_cardinal_t contour; pcb_cardinal_t prev_contour_end; @@ -132,7 +132,7 @@ static void add_noholes_polyarea(pcb_pline_t * pline, void *user_data) { - pcb_polygon_t *poly = (pcb_polygon_t *) user_data; + pcb_poly_t *poly = (pcb_poly_t *) user_data; /* Prepend the pline into the NoHoles linked list */ pline->next = poly->NoHoles; @@ -139,7 +139,7 @@ poly->NoHoles = pline; } -void pcb_poly_compute_no_holes(pcb_polygon_t * poly) +void pcb_poly_compute_no_holes(pcb_poly_t * poly) { pcb_poly_contours_free(&poly->NoHoles); if (poly->Clipped) @@ -206,7 +206,7 @@ return p; } -static pcb_polyarea_t *original_poly(pcb_polygon_t * p) +static pcb_polyarea_t *original_poly(pcb_poly_t * p) { pcb_pline_t *contour = NULL; pcb_polyarea_t *np = NULL; @@ -251,7 +251,7 @@ return biggest(np); } -pcb_polyarea_t *pcb_poly_from_poly(pcb_polygon_t * p) +pcb_polyarea_t *pcb_poly_from_poly(pcb_poly_t * p) { return original_poly(p); } @@ -721,7 +721,7 @@ } /* clear np1 from the polygon - should be inline with -O3 */ -static int Subtract(pcb_polyarea_t * np1, pcb_polygon_t * p, pcb_bool fnp) +static int Subtract(pcb_polyarea_t * np1, pcb_poly_t * p, pcb_bool fnp) { pcb_polyarea_t *merged = NULL, *np = np1; int x; @@ -758,7 +758,7 @@ return 1; } -int pcb_poly_subtract(pcb_polyarea_t *np1, pcb_polygon_t *p, pcb_bool fnp) +int pcb_poly_subtract(pcb_polyarea_t *np1, pcb_poly_t *p, pcb_bool fnp) { return Subtract(np1, p, fnp); } @@ -807,7 +807,7 @@ } /* remove the pin clearance from the polygon */ -static int SubtractPin(pcb_data_t * d, pcb_pin_t * pin, pcb_layer_t * l, pcb_polygon_t * p) +static int SubtractPin(pcb_data_t * d, pcb_pin_t * pin, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; pcb_layer_id_t i; @@ -829,7 +829,7 @@ return Subtract(np, p, pcb_true); } -static int SubtractLine(pcb_line_t * line, pcb_polygon_t * p) +static int SubtractLine(pcb_line_t * line, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -840,7 +840,7 @@ return Subtract(np, p, pcb_true); } -static int SubtractArc(pcb_arc_t * arc, pcb_polygon_t * p) +static int SubtractArc(pcb_arc_t * arc, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -851,7 +851,7 @@ return Subtract(np, p, pcb_true); } -static int SubtractText(pcb_text_t * text, pcb_polygon_t * p) +static int SubtractText(pcb_text_t * text, pcb_poly_t * p) { pcb_polyarea_t *np; const pcb_box_t *b = &text->BoundingBox; @@ -863,7 +863,7 @@ return Subtract(np, p, pcb_true); } -static int SubtractPad(pcb_pad_t * pad, pcb_polygon_t * p) +static int SubtractPad(pcb_pad_t * pad, pcb_poly_t * p) { pcb_polyarea_t *np = NULL; @@ -884,7 +884,7 @@ const pcb_box_t *other; pcb_data_t *data; pcb_layer_t *layer; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_bool solder; pcb_polyarea_t *accumulate; int batch_size; @@ -891,7 +891,7 @@ jmp_buf env; }; -static void subtract_accumulated(struct cpInfo *info, pcb_polygon_t *polygon) +static void subtract_accumulated(struct cpInfo *info, pcb_poly_t *polygon) { if (info->accumulate == NULL) return; @@ -904,7 +904,7 @@ { pcb_pin_t *pin = (pcb_pin_t *) b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_polyarea_t *np; pcb_polyarea_t *merged; pcb_layer_id_t i; @@ -943,7 +943,7 @@ { pcb_arc_t *arc = (pcb_arc_t *) b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; /* don't subtract the object that was put back! */ if (b == info->other) @@ -989,7 +989,7 @@ /* Construct a poly area that represents the enlarged subpoly - so it can be subtracted from the parent poly to form the clearance for subpoly */ -static pcb_polyarea_t *SubtractPolyPoly_construct(pcb_polygon_t *subpoly) +static pcb_polyarea_t *SubtractPolyPoly_construct(pcb_poly_t *subpoly) { pcb_poly_it_t it; pcb_polyarea_t *ret = NULL, *pa, *lin, *tmp; @@ -1033,7 +1033,7 @@ return ret; } -static int SubtractPolyPoly(pcb_polygon_t *subpoly, pcb_polygon_t *frompoly) +static int SubtractPolyPoly(pcb_poly_t *subpoly, pcb_poly_t *frompoly) { pcb_polyarea_t *pa; @@ -1050,7 +1050,7 @@ } -static int UnsubtractPolyPoly(pcb_polygon_t *subpoly, pcb_polygon_t *frompoly) +static int UnsubtractPolyPoly(pcb_poly_t *subpoly, pcb_poly_t *frompoly) { pcb_polyarea_t *pa; @@ -1069,9 +1069,9 @@ static pcb_r_dir_t poly_sub_callback(const pcb_box_t *b, void *cl) { - pcb_polygon_t *subpoly = (pcb_polygon_t *)b; + pcb_poly_t *subpoly = (pcb_poly_t *)b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; polygon = info->polygon; @@ -1095,7 +1095,7 @@ { pcb_pad_t *pad = (pcb_pad_t *) b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; /* don't subtract the object that was put back! */ if (b == info->other) @@ -1115,7 +1115,7 @@ { pcb_line_t *line = (pcb_line_t *) b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_polyarea_t *np; pcb_polyarea_t *merged; @@ -1143,7 +1143,7 @@ { pcb_text_t *text = (pcb_text_t *) b; struct cpInfo *info = (struct cpInfo *) cl; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; /* don't subtract the object that was put back! */ if (b == info->other) @@ -1156,7 +1156,7 @@ return PCB_R_DIR_FOUND_CONTINUE; } -static int clearPoly(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t * polygon, const pcb_box_t * here, pcb_coord_t expand) +static int clearPoly(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t * polygon, const pcb_box_t * here, pcb_coord_t expand) { int r = 0, seen; pcb_box_t region; @@ -1219,7 +1219,7 @@ return r; } -static int Unsubtract(pcb_polyarea_t * np1, pcb_polygon_t * p) +static int Unsubtract(pcb_polyarea_t * np1, pcb_poly_t * p) { pcb_polyarea_t *merged = NULL, *np = np1; pcb_polyarea_t *orig_poly, *clipped_np; @@ -1254,7 +1254,7 @@ return 0; } -static int UnsubtractPin(pcb_pin_t * pin, pcb_layer_t * l, pcb_polygon_t * p) +static int UnsubtractPin(pcb_pin_t * pin, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -1270,7 +1270,7 @@ return 1; } -static int UnsubtractArc(pcb_arc_t * arc, pcb_layer_t * l, pcb_polygon_t * p) +static int UnsubtractArc(pcb_arc_t * arc, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -1288,7 +1288,7 @@ return 1; } -static int UnsubtractLine(pcb_line_t * line, pcb_layer_t * l, pcb_polygon_t * p) +static int UnsubtractLine(pcb_line_t * line, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -1306,7 +1306,7 @@ return 1; } -static int UnsubtractText(pcb_text_t * text, pcb_layer_t * l, pcb_polygon_t * p) +static int UnsubtractText(pcb_text_t * text, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -1324,7 +1324,7 @@ return 1; } -static int UnsubtractPad(pcb_pad_t * pad, pcb_layer_t * l, pcb_polygon_t * p) +static int UnsubtractPad(pcb_pad_t * pad, pcb_layer_t * l, pcb_poly_t * p) { pcb_polyarea_t *np; @@ -1341,7 +1341,7 @@ static pcb_bool inhibit = pcb_false; -int pcb_poly_init_clip(pcb_data_t *Data, pcb_layer_t *layer, pcb_polygon_t * p) +int pcb_poly_init_clip(pcb_data_t *Data, pcb_layer_t *layer, pcb_poly_t * p) { pcb_board_t *pcb; @@ -1378,7 +1378,7 @@ * line between the points on either side of it is redundant. * returns pcb_true if any points are removed */ -pcb_bool pcb_poly_remove_excess_points(pcb_layer_t *Layer, pcb_polygon_t *Polygon) +pcb_bool pcb_poly_remove_excess_points(pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_point_t *p; pcb_cardinal_t n, prev, next; @@ -1409,7 +1409,7 @@ * point of the segment with the lowest distance to the passed * coordinates */ -pcb_cardinal_t pcb_poly_get_lowest_distance_point(pcb_polygon_t *Polygon, pcb_coord_t X, pcb_coord_t Y) +pcb_cardinal_t pcb_poly_get_lowest_distance_point(pcb_poly_t *Polygon, pcb_coord_t X, pcb_coord_t Y) { double mindistance = (double) PCB_MAX_COORD * PCB_MAX_COORD; pcb_point_t *ptr1, *ptr2; @@ -1511,9 +1511,9 @@ pcb_message(PCB_MSG_ERROR, _("A polygon has to have at least 3 points\n")); } -static void poly_copy_data(pcb_polygon_t *dst, pcb_polygon_t *src) +static void poly_copy_data(pcb_poly_t *dst, pcb_poly_t *src) { - pcb_polygon_t p; + pcb_poly_t p; memcpy(dst, src, ((char *)&p.link - (char *)&p)); } @@ -1522,7 +1522,7 @@ */ void pcb_polygon_copy_attached_to_layer(void) { - pcb_polygon_t *polygon; + pcb_poly_t *polygon; int saveID; /* move data to layer and clear attached struct */ @@ -1537,7 +1537,7 @@ if (conf_core.editor.clear_polypoly) PCB_FLAG_SET(PCB_FLAG_CLEARPOLYPOLY, polygon); - memset(&pcb_crosshair.AttachedPolygon, 0, sizeof(pcb_polygon_t)); + memset(&pcb_crosshair.AttachedPolygon, 0, sizeof(pcb_poly_t)); pcb_add_polygon_on_layer(CURRENT, polygon); @@ -1593,7 +1593,7 @@ /* Create pcb_polyarea_ts from the original polygon * and the new hole polygon */ - original = pcb_poly_from_poly((pcb_polygon_t *) pcb_crosshair.AttachedObject.Ptr2); + original = pcb_poly_from_poly((pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2); new_hole = pcb_poly_from_poly(&pcb_crosshair.AttachedPolygon); /* Subtract the hole from the original polygon shape */ @@ -1603,7 +1603,7 @@ * and place them on the page. Delete the original polygon. */ pcb_undo_save_serial(); - Flags = ((pcb_polygon_t *) pcb_crosshair.AttachedObject.Ptr2)->Flags; + Flags = ((pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2)->Flags; pcb_poly_to_polygons_on_layer(PCB->Data, (pcb_layer_t *) pcb_crosshair.AttachedObject.Ptr1, result, Flags); pcb_remove_object(PCB_TYPE_POLYGON, pcb_crosshair.AttachedObject.Ptr1, pcb_crosshair.AttachedObject.Ptr2, pcb_crosshair.AttachedObject.Ptr3); @@ -1611,7 +1611,7 @@ pcb_undo_inc_serial(); /* reset state of attached line */ - memset(&pcb_crosshair.AttachedPolygon, 0, sizeof(pcb_polygon_t)); + memset(&pcb_crosshair.AttachedPolygon, 0, sizeof(pcb_poly_t)); pcb_crosshair.AttachedLine.State = PCB_CH_STATE_FIRST; pcb_crosshair.AttachedObject.State = PCB_CH_STATE_FIRST; pcb_added_lines = 0; @@ -1622,7 +1622,7 @@ * the search. */ int -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_poly_holes(pcb_poly_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; @@ -1646,10 +1646,10 @@ void *ptr1, *ptr2; pcb_layer_t *layer; pcb_data_t *data; - pcb_r_dir_t (*callback) (pcb_data_t *, pcb_layer_t *, pcb_polygon_t *, int, void *, void *); + pcb_r_dir_t (*callback) (pcb_data_t *, pcb_layer_t *, pcb_poly_t *, int, void *, void *); }; -static pcb_r_dir_t subtract_plow(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *ptr1, void *ptr2) +static pcb_r_dir_t subtract_plow(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *ptr1, void *ptr2) { if (!Polygon->Clipped) return 0; @@ -1669,7 +1669,7 @@ return PCB_R_DIR_FOUND_CONTINUE; case PCB_TYPE_POLYGON: if (ptr2 != Polygon) { - SubtractPolyPoly((pcb_polygon_t *) ptr2, Polygon); + SubtractPolyPoly((pcb_poly_t *) ptr2, Polygon); Polygon->NoHolesValid = 0; return PCB_R_DIR_FOUND_CONTINUE; } @@ -1686,7 +1686,7 @@ return PCB_R_DIR_NOT_FOUND; } -static pcb_r_dir_t add_plow(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *ptr1, void *ptr2) +static pcb_r_dir_t add_plow(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *ptr1, void *ptr2) { switch (type) { case PCB_TYPE_PIN: @@ -1701,7 +1701,7 @@ return PCB_R_DIR_FOUND_CONTINUE; case PCB_TYPE_POLYGON: if (ptr2 != Polygon) { - UnsubtractPolyPoly((pcb_polygon_t *) ptr2, Polygon); + UnsubtractPolyPoly((pcb_poly_t *) ptr2, Polygon); return PCB_R_DIR_FOUND_CONTINUE; } break; @@ -1715,7 +1715,7 @@ return PCB_R_DIR_NOT_FOUND; } -int pcb_poly_sub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *obj) +int pcb_poly_sub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *obj) { if (subtract_plow(Data, Layer, Polygon, type, NULL, obj) == PCB_R_DIR_FOUND_CONTINUE) return 0; @@ -1722,7 +1722,7 @@ return -1; } -int pcb_poly_unsub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *obj) +int pcb_poly_unsub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *obj) { if (add_plow(Data, Layer, Polygon, type, NULL, obj) == PCB_R_DIR_FOUND_CONTINUE) return 0; @@ -1733,7 +1733,7 @@ static pcb_r_dir_t plow_callback(const pcb_box_t * b, void *cl) { struct plow_info *plow = (struct plow_info *) cl; - pcb_polygon_t *polygon = (pcb_polygon_t *) b; + pcb_poly_t *polygon = (pcb_poly_t *) b; if (PCB_FLAG_TEST(PCB_FLAG_CLEARPOLY, polygon)) return plow->callback(plow->data, plow->layer, polygon, plow->type, plow->ptr1, plow->ptr2); @@ -1742,7 +1742,7 @@ int 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_r_dir_t (*call_back) (pcb_data_t *data, pcb_layer_t *lay, pcb_poly_t *poly, int type, void *ptr1, void *ptr2)) { pcb_box_t sb = ((pcb_pin_t *) ptr2)->BoundingBox; int r = 0, seen; @@ -1780,7 +1780,7 @@ } break; case PCB_TYPE_POLYGON: - if (!PCB_POLY_HAS_CLEARANCE((pcb_polygon_t *) ptr2)) + if (!PCB_POLY_HAS_CLEARANCE((pcb_poly_t *) ptr2)) return 0; goto doit; @@ -1847,7 +1847,7 @@ void pcb_poly_restore_to_poly(pcb_data_t * Data, int type, void *ptr1, void *ptr2) { if (type == PCB_TYPE_POLYGON) - pcb_poly_init_clip(PCB->Data, (pcb_layer_t *) ptr1, (pcb_polygon_t *) ptr2); + pcb_poly_init_clip(PCB->Data, (pcb_layer_t *) ptr1, (pcb_poly_t *) ptr2); pcb_poly_plows(Data, type, ptr1, ptr2, add_plow); } @@ -1854,11 +1854,11 @@ void pcb_poly_clear_from_poly(pcb_data_t * Data, int type, void *ptr1, void *ptr2) { if (type == PCB_TYPE_POLYGON) - pcb_poly_init_clip(Data, (pcb_layer_t *) ptr1, (pcb_polygon_t *) ptr2); + pcb_poly_init_clip(Data, (pcb_layer_t *) ptr1, (pcb_poly_t *) ptr2); pcb_poly_plows(Data, type, ptr1, ptr2, subtract_plow); } -pcb_bool pcb_poly_isects_poly(pcb_polyarea_t * a, pcb_polygon_t *p, pcb_bool fr) +pcb_bool pcb_poly_isects_poly(pcb_polyarea_t * a, pcb_poly_t *p, pcb_bool fr) { pcb_polyarea_t *x; pcb_bool ans; @@ -1871,7 +1871,7 @@ } -pcb_bool pcb_poly_is_point_in_p(pcb_coord_t X, pcb_coord_t Y, pcb_coord_t r, pcb_polygon_t *p) +pcb_bool pcb_poly_is_point_in_p(pcb_coord_t X, pcb_coord_t Y, pcb_coord_t r, pcb_poly_t *p) { pcb_polyarea_t *c; pcb_vector_t v; @@ -1881,7 +1881,7 @@ return pcb_true; if (PCB_FLAG_TEST(PCB_FLAG_FULLPOLY, p)) { - pcb_polygon_t tmp = *p; + pcb_poly_t tmp = *p; /* Check all clipped-away regions that are now drawn because of full-poly */ for (tmp.Clipped = p->Clipped->f; tmp.Clipped != p->Clipped; tmp.Clipped = tmp.Clipped->f) @@ -1897,7 +1897,7 @@ } -pcb_bool pcb_poly_is_point_in_p_ignore_holes(pcb_coord_t X, pcb_coord_t Y, pcb_polygon_t *p) +pcb_bool pcb_poly_is_point_in_p_ignore_holes(pcb_coord_t X, pcb_coord_t Y, pcb_poly_t *p) { pcb_vector_t v; v[0] = X; @@ -1905,7 +1905,7 @@ return pcb_poly_contour_inside(p->Clipped->contours, v); } -pcb_bool pcb_poly_is_rect_in_p(pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_polygon_t *p) +pcb_bool pcb_poly_is_rect_in_p(pcb_coord_t X1, pcb_coord_t Y1, pcb_coord_t X2, pcb_coord_t Y2, pcb_poly_t *p) { pcb_polyarea_t *s; if (!(s = pcb_poly_from_rect(min(X1, X2), max(X1, X2), min(Y1, Y2), max(Y1, Y2)))) @@ -1959,7 +1959,7 @@ } } -void pcb_poly_no_holes_dicer(pcb_polygon_t *p, const pcb_box_t * clip, void (*emit) (pcb_pline_t *, void *), void *user_data) +void pcb_poly_no_holes_dicer(pcb_poly_t *p, const pcb_box_t * clip, void (*emit) (pcb_pline_t *, void *), void *user_data) { pcb_polyarea_t *main_contour, *cur, *next; @@ -1987,7 +1987,7 @@ } /* make a polygon split into multiple parts into multiple polygons */ -pcb_bool pcb_poly_morph(pcb_layer_t *layer, pcb_polygon_t *poly) +pcb_bool pcb_poly_morph(pcb_layer_t *layer, pcb_poly_t *poly) { pcb_polyarea_t *p, *start; pcb_bool many = pcb_false; @@ -2016,7 +2016,7 @@ inhibit = pcb_true; do { pcb_vnode_t *v; - pcb_polygon_t *newone; + pcb_poly_t *newone; if (p->contours->area > PCB->IsleArea) { newone = pcb_poly_new(layer, poly->Clearance, flags); @@ -2074,7 +2074,7 @@ debug_pline(pl); } -void debug_polygon(pcb_polygon_t * p) +void debug_polygon(pcb_poly_t * p) { pcb_cardinal_t i; pcb_polyarea_t *pa; @@ -2102,7 +2102,7 @@ */ void pcb_poly_to_polygons_on_layer(pcb_data_t * Destination, pcb_layer_t * Layer, pcb_polyarea_t * Input, pcb_flag_t Flags) { - pcb_polygon_t *Polygon; + pcb_poly_t *Polygon; pcb_polyarea_t *pa; pcb_pline_t *pline; pcb_vnode_t *node; Index: trunk/src/polygon.h =================================================================== --- trunk/src/polygon.h (revision 12227) +++ trunk/src/polygon.h (revision 12228) @@ -52,25 +52,25 @@ /* Prototypes */ 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 *); +pcb_cardinal_t pcb_poly_point_idx(pcb_poly_t *polygon, pcb_point_t *point); +pcb_cardinal_t pcb_poly_contour_point(pcb_poly_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_contour_prev_point(pcb_poly_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_contour_next_point(pcb_poly_t *polygon, pcb_cardinal_t point); +pcb_cardinal_t pcb_poly_get_lowest_distance_point(pcb_poly_t *, pcb_coord_t, pcb_coord_t); +pcb_bool pcb_poly_remove_excess_points(pcb_layer_t *, pcb_poly_t *); void pcb_polygon_go_to_prev_point(void); void pcb_polygon_close_poly(void); void pcb_polygon_copy_attached_to_layer(void); void pcb_polygon_close_hole(void); void pcb_polygon_hole_create_from_attached(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_holes(pcb_poly_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 pcb_poly_compute_no_holes(pcb_polygon_t * poly); + pcb_r_dir_t (*callback) (pcb_data_t *, pcb_layer_t *, pcb_poly_t *, int, void *, void *)); +void pcb_poly_compute_no_holes(pcb_poly_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_poly(pcb_poly_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); @@ -80,16 +80,16 @@ pcb_polyarea_t *pcb_poly_from_box_bloated(pcb_box_t * box, pcb_coord_t radius); void pcb_poly_frac_circle(pcb_pline_t *, pcb_coord_t, pcb_coord_t, pcb_vector_t, int); -int pcb_poly_init_clip(pcb_data_t * d, pcb_layer_t * l, pcb_polygon_t * p); +int pcb_poly_init_clip(pcb_data_t * d, pcb_layer_t * l, pcb_poly_t * p); void pcb_poly_restore_to_poly(pcb_data_t *, int, void *, void *); void pcb_poly_clear_from_poly(pcb_data_t *, int, void *, void *); -pcb_bool pcb_poly_is_point_in_p(pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_polygon_t *); -pcb_bool pcb_poly_is_point_in_p_ignore_holes(pcb_coord_t, pcb_coord_t, pcb_polygon_t *); -pcb_bool pcb_poly_is_rect_in_p(pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_polygon_t *); -pcb_bool pcb_poly_isects_poly(pcb_polyarea_t *, pcb_polygon_t *, pcb_bool); -pcb_bool pcb_poly_morph(pcb_layer_t *, pcb_polygon_t *); -void pcb_poly_no_holes_dicer(pcb_polygon_t * p, const pcb_box_t * clip, void (*emit) (pcb_pline_t *, void *), void *user_data); +pcb_bool pcb_poly_is_point_in_p(pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_poly_t *); +pcb_bool pcb_poly_is_point_in_p_ignore_holes(pcb_coord_t, pcb_coord_t, pcb_poly_t *); +pcb_bool pcb_poly_is_rect_in_p(pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_coord_t, pcb_poly_t *); +pcb_bool pcb_poly_isects_poly(pcb_polyarea_t *, pcb_poly_t *, pcb_bool); +pcb_bool pcb_poly_morph(pcb_layer_t *, pcb_poly_t *); +void pcb_poly_no_holes_dicer(pcb_poly_t * p, const pcb_box_t * clip, void (*emit) (pcb_pline_t *, void *), void *user_data); void pcb_poly_to_polygons_on_layer(pcb_data_t *, pcb_layer_t *, pcb_polyarea_t *, pcb_flag_t); void pcb_poly_square_pin_factors(int style, double *xm, double *ym); @@ -98,11 +98,11 @@ /* clear np1 from the polygon; also free np1 if fnp is true. Returns 1 on success. */ -int pcb_poly_subtract(pcb_polyarea_t *np1, pcb_polygon_t *p, pcb_bool fnp); +int pcb_poly_subtract(pcb_polyarea_t *np1, pcb_poly_t *p, pcb_bool fnp); /* Subtract or unsubtract obj from poly; Layer is used for looking up thermals */ -int pcb_poly_sub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *obj); -int pcb_poly_unsub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_polygon_t *Polygon, int type, void *obj); +int pcb_poly_sub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *obj); +int pcb_poly_unsub_obj(pcb_data_t *Data, pcb_layer_t *Layer, pcb_poly_t *Polygon, int type, void *obj); #endif Index: trunk/src/polygon_act.c =================================================================== --- trunk/src/polygon_act.c (revision 12227) +++ trunk/src/polygon_act.c (revision 12228) @@ -69,7 +69,7 @@ pcb_gui->get_coords(_("Select an Object"), &x, &y); if ((type = pcb_search_screen(x, y, PCB_TYPE_POLYGON, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { - pcb_poly_morph((pcb_layer_t *) ptr1, (pcb_polygon_t *) ptr3); + pcb_poly_morph((pcb_layer_t *) ptr1, (pcb_poly_t *) ptr3); pcb_draw(); pcb_undo_inc_serial(); } Index: trunk/src/rats.c =================================================================== --- trunk/src/rats.c (revision 12227) +++ trunk/src/rats.c (revision 12228) @@ -247,7 +247,7 @@ pcb_r_end(&it); for(n = pcb_r_first(l->polygon_tree, &it); n != NULL; n = pcb_r_next(&it)) - PCB_FLAG_CLEAR(PCB_FLAG_DRC | PCB_FLAG_DRC_INTCONN, (pcb_polygon_t *)n); + PCB_FLAG_CLEAR(PCB_FLAG_DRC | PCB_FLAG_DRC_INTCONN, (pcb_poly_t *)n); pcb_r_end(&it); for(n = pcb_r_first(l->text_tree, &it); n != NULL; n = pcb_r_next(&it)) @@ -626,7 +626,7 @@ pcb_rat_t *line; register float distance, temp; register pcb_connection_t *conn1, *conn2, *firstpoint, *secondpoint; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_bool changed = pcb_false; pcb_bool havepoints; pcb_cardinal_t n, m, j; @@ -698,7 +698,7 @@ * via in the Net to make that connection. */ if (conn1->obj->type == PCB_OBJ_POLYGON && - (polygon = (pcb_polygon_t *) conn1->obj) && + (polygon = (pcb_poly_t *) conn1->obj) && !(distance == 0 && firstpoint && firstpoint->obj->type == PCB_OBJ_VIA) && pcb_poly_is_point_in_p_ignore_holes(conn2->X, conn2->Y, polygon)) { distance = 0; @@ -708,7 +708,7 @@ havepoints = pcb_true; } else if (conn2->obj->type == PCB_OBJ_POLYGON && - (polygon = (pcb_polygon_t *) conn2->obj) && + (polygon = (pcb_poly_t *) conn2->obj) && !(distance == 0 && firstpoint && firstpoint->obj->type == PCB_OBJ_VIA) && pcb_poly_is_point_in_p_ignore_holes(conn1->X, conn1->Y, polygon)) { distance = 0; Index: trunk/src/search.c =================================================================== --- trunk/src/search.c (revision 12227) +++ trunk/src/search.c (revision 12228) @@ -59,7 +59,7 @@ static pcb_bool SearchArcByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_arc_t **, pcb_arc_t **); static pcb_bool SearchRatLineByLocation(unsigned long, unsigned long, pcb_rat_t **, pcb_rat_t **, pcb_rat_t **); static pcb_bool SearchTextByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_text_t **, pcb_text_t **); -static pcb_bool SearchPolygonByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_polygon_t **, pcb_polygon_t **); +static pcb_bool SearchPolygonByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_poly_t **, pcb_poly_t **); static pcb_bool SearchPinByLocation(unsigned long, unsigned long, pcb_element_t **, pcb_pin_t **, pcb_pin_t **); static pcb_bool SearchPadByLocation(unsigned long, unsigned long, pcb_element_t **, pcb_pad_t **, pcb_pad_t **, pcb_bool); static pcb_bool SearchViaByLocation(unsigned long, unsigned long, pcb_pin_t **, pcb_pin_t **, pcb_pin_t **); @@ -66,7 +66,7 @@ static pcb_bool SearchElementNameByLocation(unsigned long, unsigned long, pcb_element_t **, pcb_text_t **, pcb_text_t **, pcb_bool); static pcb_bool SearchLinePointByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_line_t **, pcb_point_t **); static pcb_bool SearchArcPointByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_arc_t **, int **); -static pcb_bool SearchPointByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_polygon_t **, pcb_point_t **); +static pcb_bool SearchPointByLocation(unsigned long, unsigned long, pcb_layer_t **, pcb_poly_t **, pcb_point_t **); static pcb_bool SearchElementByLocation(unsigned long, unsigned long, pcb_element_t **, pcb_element_t **, pcb_element_t **, pcb_bool); static pcb_bool SearchSubcByLocation(unsigned long, unsigned long, pcb_subc_t **, pcb_subc_t **, pcb_subc_t **, pcb_bool); @@ -341,7 +341,7 @@ static pcb_r_dir_t polygon_callback(const pcb_box_t * box, void *cl) { - pcb_polygon_t *polygon = (pcb_polygon_t *) box; + pcb_poly_t *polygon = (pcb_poly_t *) box; struct ans_info *i = (struct ans_info *) cl; TEST_OBJST(i->objst, i->req_flag, l, polygon, polygon); @@ -357,7 +357,7 @@ /* --------------------------------------------------------------------------- * searches a polygon on the SearchLayer */ -static pcb_bool SearchPolygonByLocation(unsigned long objst, unsigned long req_flag, pcb_layer_t ** Layer, pcb_polygon_t ** Polygon, pcb_polygon_t ** Dummy) +static pcb_bool SearchPolygonByLocation(unsigned long objst, unsigned long req_flag, pcb_layer_t ** Layer, pcb_poly_t ** Polygon, pcb_poly_t ** Dummy) { struct ans_info info; @@ -474,7 +474,7 @@ * searches a polygon-point on all layers that are switched on * in layerstack order */ -static pcb_bool SearchPointByLocation(unsigned long objst, unsigned long req_flag, pcb_layer_t ** Layer, pcb_polygon_t ** Polygon, pcb_point_t ** Point) +static pcb_bool SearchPointByLocation(unsigned long objst, unsigned long req_flag, pcb_layer_t ** Layer, pcb_poly_t ** Polygon, pcb_point_t ** Point) { double d, least; pcb_bool found = pcb_false; @@ -1196,7 +1196,7 @@ if (SearchLayer->meta.real.vis) { if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && Type & PCB_TYPE_POLYGON_POINT && - SearchPointByLocation(objst, req_flag, (pcb_layer_t **) Result1, (pcb_polygon_t **) Result2, (pcb_point_t **) Result3)) + SearchPointByLocation(objst, req_flag, (pcb_layer_t **) Result1, (pcb_poly_t **) Result2, (pcb_point_t **) Result3)) return (PCB_TYPE_POLYGON_POINT); if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && @@ -1222,9 +1222,9 @@ return (PCB_TYPE_TEXT); if (Type & PCB_TYPE_POLYGON && - SearchPolygonByLocation(objst, req_flag, (pcb_layer_t **) Result1, (pcb_polygon_t **) Result2, (pcb_polygon_t **) Result3)) { + SearchPolygonByLocation(objst, req_flag, (pcb_layer_t **) Result1, (pcb_poly_t **) Result2, (pcb_poly_t **) Result3)) { if (HigherAvail) { - pcb_box_t *box = &(*(pcb_polygon_t **) Result2)->BoundingBox; + pcb_box_t *box = &(*(pcb_poly_t **) Result2)->BoundingBox; double area = (double) (box->X2 - box->X1) * (double) (box->X2 - box->X1); if (HigherBound < area) break; Index: trunk/src/select.c =================================================================== --- trunk/src/select.c (revision 12227) +++ trunk/src/select.c (revision 12228) @@ -171,7 +171,7 @@ case PCB_TYPE_POLYGON: { - pcb_polygon_t *poly = (pcb_polygon_t *) ptr2; + pcb_poly_t *poly = (pcb_poly_t *) ptr2; layer = (pcb_layer_t *) ptr1; pcb_undo_add_obj_to_flag(ptr2); @@ -505,7 +505,7 @@ case PCB_OBJ_RAT: case PCB_OBJ_LINE: return PCB_LINE_NEAR_BOX((pcb_line_t *)obj, box); case PCB_OBJ_TEXT: return PCB_TEXT_NEAR_BOX((pcb_text_t *)obj, box); - case PCB_OBJ_POLYGON: return PCB_POLYGON_NEAR_BOX((pcb_polygon_t *)obj, box); + case PCB_OBJ_POLYGON: return PCB_POLYGON_NEAR_BOX((pcb_poly_t *)obj, box); case PCB_OBJ_ARC: return PCB_ARC_NEAR_BOX((pcb_arc_t *)obj, box); case PCB_OBJ_PAD: return PCB_PAD_NEAR_BOX((pcb_pad_t *)obj, box); case PCB_OBJ_PIN: Index: trunk/src/tool_insert.c =================================================================== --- trunk/src/tool_insert.c (revision 12227) +++ trunk/src/tool_insert.c (revision 12228) @@ -39,7 +39,7 @@ static struct { - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_line_t line; } fake; @@ -57,7 +57,7 @@ &pcb_crosshair.AttachedObject.Ptr1, &pcb_crosshair.AttachedObject.Ptr2, &pcb_crosshair.AttachedObject.Ptr3); if (pcb_crosshair.AttachedObject.Type != PCB_TYPE_NONE) { - if (PCB_FLAG_TEST(PCB_FLAG_LOCK, (pcb_polygon_t *) + if (PCB_FLAG_TEST(PCB_FLAG_LOCK, (pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2)) { pcb_message(PCB_MSG_WARNING, _("Sorry, the object is locked\n")); pcb_crosshair.AttachedObject.Type = PCB_TYPE_NONE; @@ -66,7 +66,7 @@ else { /* get starting point of nearest segment */ if (pcb_crosshair.AttachedObject.Type == PCB_TYPE_POLYGON) { - fake.poly = (pcb_polygon_t *) pcb_crosshair.AttachedObject.Ptr2; + fake.poly = (pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2; 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[pcb_poly_contour_prev_point(fake.poly, polyIndex)]; Index: trunk/src/tool_polyhole.c =================================================================== --- trunk/src/tool_polyhole.c (revision 12227) +++ trunk/src/tool_polyhole.c (revision 12228) @@ -51,7 +51,7 @@ break; /* don't start doing anything if clicket out of polys */ } - if (PCB_FLAG_TEST(PCB_FLAG_LOCK, (pcb_polygon_t *) + if (PCB_FLAG_TEST(PCB_FLAG_LOCK, (pcb_poly_t *) pcb_crosshair.AttachedObject.Ptr2)) { pcb_message(PCB_MSG_WARNING, _("Sorry, the object is locked\n")); pcb_crosshair.AttachedObject.Type = PCB_TYPE_NONE; Index: trunk/src/tool_rectangle.c =================================================================== --- trunk/src/tool_rectangle.c (revision 12227) +++ trunk/src/tool_rectangle.c (revision 12228) @@ -51,7 +51,7 @@ if (pcb_crosshair.AttachedBox.State == PCB_CH_STATE_THIRD && pcb_crosshair.AttachedBox.Point1.X != pcb_crosshair.AttachedBox.Point2.X && pcb_crosshair.AttachedBox.Point1.Y != pcb_crosshair.AttachedBox.Point2.Y) { - pcb_polygon_t *polygon; + pcb_poly_t *polygon; int flags = PCB_FLAG_CLEARPOLY; if (conf_core.editor.full_poly) Index: trunk/src/undo_old.c =================================================================== --- trunk/src/undo_old.c (revision 12227) +++ trunk/src/undo_old.c (revision 12228) @@ -576,7 +576,7 @@ static pcb_bool UndoRemovePoint(UndoListTypePtr Entry) { pcb_layer_t *layer; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; void *ptr3; int type; @@ -615,7 +615,7 @@ static pcb_bool UndoInsertPoint(UndoListTypePtr Entry) { pcb_layer_t *layer; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_point_t *pnt; int type; pcb_cardinal_t point_idx; @@ -692,7 +692,7 @@ obj = (pcb_any_obj_t *) pcb_move_obj_to_buffer(PCB, PCB->Data, RemoveList, type, ptr1, ptr2, ptr3); if (Entry->Kind == PCB_TYPE_POLYGON) - pcb_poly_init_clip(PCB->Data, (pcb_layer_t *) ptr1b, (pcb_polygon_t *) obj); + pcb_poly_init_clip(PCB->Data, (pcb_layer_t *) ptr1b, (pcb_poly_t *) obj); return (pcb_true); } @@ -972,7 +972,7 @@ void pcb_undo_add_obj_to_remove_point(int Type, void *Ptr1, void *Ptr2, pcb_cardinal_t index) { UndoListTypePtr undo; - pcb_polygon_t *polygon = (pcb_polygon_t *) Ptr2; + pcb_poly_t *polygon = (pcb_poly_t *) Ptr2; pcb_cardinal_t hole; pcb_bool last_in_contour = pcb_false; @@ -1034,7 +1034,7 @@ * adds an object to the list of removed contours * (Actually just takes a copy of the whole polygon to restore) */ -void pcb_undo_add_obj_to_remove_contour(int Type, pcb_layer_t * Layer, pcb_polygon_t * Polygon) +void pcb_undo_add_obj_to_remove_contour(int Type, pcb_layer_t * Layer, pcb_poly_t * Polygon) { CopyObjectToUndoList(PCB_UNDO_REMOVE_CONTOUR, Type, Layer, Polygon, NULL); } @@ -1043,7 +1043,7 @@ * adds an object to the list of insert contours * (Actually just takes a copy of the whole polygon to restore) */ -void pcb_undo_add_obj_to_insert_contour(int Type, pcb_layer_t * Layer, pcb_polygon_t * Polygon) +void pcb_undo_add_obj_to_insert_contour(int Type, pcb_layer_t * Layer, pcb_poly_t * Polygon) { CopyObjectToUndoList(PCB_UNDO_INSERT_CONTOUR, Type, Layer, Polygon, NULL); } Index: trunk/src/undo_old.h =================================================================== --- trunk/src/undo_old.h (revision 12227) +++ trunk/src/undo_old.h (revision 12228) @@ -39,8 +39,8 @@ void pcb_undo_move_obj_to_remove(int, void *, void *, void *); void pcb_undo_add_obj_to_remove_point(int, void *, void *, pcb_cardinal_t); void pcb_undo_add_obj_to_insert_point(int, void *, void *, void *); -void pcb_undo_add_obj_to_remove_contour(int, pcb_layer_t *, pcb_polygon_t *); -void pcb_undo_add_obj_to_insert_contour(int, pcb_layer_t *, pcb_polygon_t *); +void pcb_undo_add_obj_to_remove_contour(int, pcb_layer_t *, pcb_poly_t *); +void pcb_undo_add_obj_to_insert_contour(int, pcb_layer_t *, pcb_poly_t *); void pcb_undo_add_obj_to_move(int, void *, void *, void *, pcb_coord_t, pcb_coord_t); void pcb_undo_add_obj_to_change_name(int, void *, void *, void *, char *); void pcb_undo_add_obj_to_change_pinnum(int, void *, void *, void *, char *); Index: trunk/src_plugins/autocrop/autocrop.c =================================================================== --- trunk/src_plugins/autocrop/autocrop.c (revision 12227) +++ trunk/src_plugins/autocrop/autocrop.c (revision 12228) @@ -108,7 +108,7 @@ return Arc; } -static void *Mypcb_poly_move(pcb_data_t * Data, pcb_layer_t * Layer, pcb_polygon_t * Polygon, pcb_coord_t dx, pcb_coord_t dy) +static void *Mypcb_poly_move(pcb_data_t * Data, pcb_layer_t * Layer, pcb_poly_t * Polygon, pcb_coord_t dx, pcb_coord_t dy) { if (Data) { pcb_r_delete_entry(Layer->polygon_tree, (pcb_box_t *) Polygon); Index: trunk/src_plugins/autoroute/autoroute.c =================================================================== --- trunk/src_plugins/autoroute/autoroute.c (revision 12227) +++ trunk/src_plugins/autoroute/autoroute.c (revision 12228) @@ -726,7 +726,7 @@ return *rbpp; } -static routebox_t *AddPolygon(vtp0_t layergroupboxes[], pcb_cardinal_t layer, pcb_polygon_t *polygon, pcb_route_style_t * style) +static routebox_t *AddPolygon(vtp0_t layergroupboxes[], pcb_cardinal_t layer, pcb_poly_t *polygon, pcb_route_style_t * style) { int is_not_rectangle = 1; pcb_layergrp_id_t layergroup = pcb_layer_get_group(PCB, layer); Index: trunk/src_plugins/diag/integrity.c =================================================================== --- trunk/src_plugins/diag/integrity.c (revision 12227) +++ trunk/src_plugins/diag/integrity.c (revision 12228) @@ -158,7 +158,7 @@ pcb_line_t *lin; pcb_arc_t *arc; pcb_text_t *txt; - pcb_polygon_t *pol; + pcb_poly_t *pol; if (!ly->is_bound) pcb_message(PCB_MSG_ERROR, CHK "%ld subc layer %ld is not a bound layer\n", subc->ID, n); @@ -193,7 +193,7 @@ pcb_line_t *lin; pcb_text_t *txt; pcb_arc_t *arc; - pcb_polygon_t *poly; + pcb_poly_t *poly; /* check layers */ if (data->Layer[n].parent != data) Index: trunk/src_plugins/export_openscad/scad_draw.c =================================================================== --- trunk/src_plugins/export_openscad/scad_draw.c (revision 12227) +++ trunk/src_plugins/export_openscad/scad_draw.c (revision 12228) @@ -76,7 +76,7 @@ static int scad_draw_outline(void) { pcb_any_obj_t *start = pcb_topoly_find_1st_outline(PCB); - pcb_polygon_t *poly; + pcb_poly_t *poly; int n; if (start == NULL) { Index: trunk/src_plugins/export_ps/ps.c =================================================================== --- trunk/src_plugins/export_ps/ps.c (revision 12227) +++ trunk/src_plugins/export_ps/ps.c (revision 12228) @@ -1240,7 +1240,7 @@ return *c1 < *c2; } -static void ps_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +static void ps_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { /* Ignore clip_box, just draw everything */ Index: trunk/src_plugins/fontmode/fontmode.c =================================================================== --- trunk/src_plugins/fontmode/fontmode.c (revision 12227) +++ trunk/src_plugins/fontmode/fontmode.c (revision 12228) @@ -79,9 +79,9 @@ return &PCB->Data->Layer[lid]; } -static void add_poly(pcb_layer_t *layer, pcb_polygon_t *poly, pcb_coord_t ox, pcb_coord_t oy) +static void add_poly(pcb_layer_t *layer, pcb_poly_t *poly, pcb_coord_t ox, pcb_coord_t oy) { - pcb_polygon_t *np; + pcb_poly_t *np; /* alloc */ np = pcb_poly_new(layer, 0, pcb_no_flags()); @@ -99,7 +99,7 @@ pcb_symbol_t *symbol; pcb_layer_t *lfont, *lorig, *lwidth, *lgrid, *lsilk; pcb_layergrp_id_t grp[4]; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc, *newarc; int s, l; @@ -239,7 +239,7 @@ int i; pcb_line_t *l; pcb_arc_t *a; - pcb_polygon_t *p, *np; + pcb_poly_t *p, *np; gdl_iterator_t it; pcb_layer_t *lfont, *lwidth; Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid.h =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid.h (revision 12227) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid.h (revision 12228) @@ -35,7 +35,7 @@ Beveled_Cap /* octagon pins or bevel-cornered pads */ } pcb_cap_style_t; -typedef void *pcb_polygon_t; +typedef void *pcb_poly_t; typedef void *pcb_box_t; #endif Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.c =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.c (revision 12227) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.c (revision 12228) @@ -147,7 +147,7 @@ gpmi_event(h->module, HIDE_fill_polygon, h, gc, x, y); } -void gpmi_hid_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t *poly, const pcb_box_t *clip_box) +void gpmi_hid_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t *poly, const pcb_box_t *clip_box) { /* TODO */ } Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.h =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.h (revision 12227) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/hid/hid_callbacks.h (revision 12228) @@ -15,7 +15,7 @@ void gpmi_hid_draw_rect(pcb_hid_gc_t gc, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2); void gpmi_hid_fill_circle(pcb_hid_gc_t gc, pcb_coord_t cx, pcb_coord_t cy, pcb_coord_t radius); void gpmi_hid_fill_polygon(pcb_hid_gc_t gc, int n_coords, pcb_coord_t *x, pcb_coord_t *y); -void gpmi_hid_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t *poly, const pcb_box_t *clip_box); +void gpmi_hid_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t *poly, const pcb_box_t *clip_box); void gpmi_hid_fill_rect(pcb_hid_gc_t gc, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2); void gpmi_hid_fill_pcb_pv(pcb_hid_gc_t fg_gc, pcb_hid_gc_t bg_gc, pcb_pin_t *pad, pcb_bool drawHole, pcb_bool mask); void gpmi_hid_fill_pcb_pad(pcb_hid_gc_t gc, pcb_pad_t * pad, pcb_bool clear, pcb_bool mask); Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/layout.h =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/layout.h (revision 12227) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/layout.h (revision 12228) @@ -110,7 +110,7 @@ union { pcb_line_t *l; pcb_text_t *t; - pcb_polygon_t *p; + pcb_poly_t *p; pcb_arc_t *a; pcb_pin_t *v; pcb_pin_t *pin; @@ -293,8 +293,8 @@ void draw_rect(dctx_t *ctx, int x1_, int y1_, int x2_, int y2_); void fill_circle(dctx_t *ctx, int cx_, int cy_, int radius_); void fill_polygon(dctx_t *ctx, int n_ints_, int *x_, int *y_); -void fill_pcb_polygon(dctx_t *ctx, pcb_polygon_t *poly, const pcb_box_t *clip_box); -void thindraw_pcb_polygon(dctx_t *ctx, pcb_polygon_t *poly, const pcb_box_t *clip_box); +void fill_pcb_polygon(dctx_t *ctx, pcb_poly_t *poly, const pcb_box_t *clip_box); +void thindraw_pcb_polygon(dctx_t *ctx, pcb_poly_t *poly, const pcb_box_t *clip_box); void fill_pcb_pad(dctx_t *ctx, pcb_pad_t *pad, pcb_bool clip, pcb_bool mask); void thindraw_pcb_pad(dctx_t *ctx, pcb_pad_t *pad, pcb_bool clip, pcb_bool mask); void fill_pcb_pv(pcb_hid_gc_t fg_gc, pcb_hid_gc_t bg_gc, pcb_pin_t *pv, pcb_bool drawHole, pcb_bool mask); Index: trunk/src_plugins/hid_gtk2_gl/gtkhid-gl.c =================================================================== --- trunk/src_plugins/hid_gtk2_gl/gtkhid-gl.c (revision 12227) +++ trunk/src_plugins/hid_gtk2_gl/gtkhid-gl.c (revision 12228) @@ -556,7 +556,7 @@ hidgl_fill_polygon(n_coords, x, y); } -void ghid_gl_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +void ghid_gl_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { USE_GC(gc); @@ -563,7 +563,7 @@ hidgl_fill_pcb_polygon(poly, clip_box, gport->view.coord_per_px); } -void ghid_gl_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t * poly, const pcb_box_t * clip_box) +void ghid_gl_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t * poly, const pcb_box_t * clip_box) { pcb_dhlp_thindraw_pcb_polygon(gc, poly, clip_box); /* Disable thindraw poly filling until it is fixed. The poly fill overwrites lines and Index: trunk/src_plugins/hid_gtk2_gl/hidgl.c =================================================================== --- trunk/src_plugins/hid_gtk2_gl/hidgl.c (revision 12227) +++ trunk/src_plugins/hid_gtk2_gl/hidgl.c (revision 12228) @@ -625,7 +625,7 @@ } -void hidgl_fill_pcb_polygon(pcb_polygon_t * poly, const pcb_box_t * clip_box, double scale) +void hidgl_fill_pcb_polygon(pcb_poly_t * poly, const pcb_box_t * clip_box, double scale) { int vertex_count = 0; pcb_pline_t *contour; Index: trunk/src_plugins/hid_gtk2_gl/hidgl.h =================================================================== --- trunk/src_plugins/hid_gtk2_gl/hidgl.h (revision 12227) +++ trunk/src_plugins/hid_gtk2_gl/hidgl.h (revision 12228) @@ -34,7 +34,7 @@ void hidgl_draw_rect(pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2); void hidgl_fill_circle(pcb_coord_t vx, pcb_coord_t vy, pcb_coord_t vr, double scale); void hidgl_fill_polygon(int n_coords, pcb_coord_t * x, pcb_coord_t * y); -void hidgl_fill_pcb_polygon(pcb_polygon_t * poly, const pcb_box_t * clip_box, double scale); +void hidgl_fill_pcb_polygon(pcb_poly_t * poly, const pcb_box_t * clip_box, double scale); void hidgl_fill_rect(pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2); void hidgl_init(void); void hidgl_set_drawing_mode(pcb_composite_op_t op, pcb_bool direct, const pcb_box_t * screen); Index: trunk/src_plugins/io_autotrax/read.c =================================================================== --- trunk/src_plugins/io_autotrax/read.c (revision 12227) +++ trunk/src_plugins/io_autotrax/read.c (revision 12228) @@ -644,7 +644,7 @@ int valid = 1; int autotrax_layer = 0; char line[MAXREAD]; - pcb_polygon_t *polygon = NULL; + pcb_poly_t *polygon = NULL; pcb_flag_t flags = pcb_flag_make(PCB_FLAG_CLEARPOLY); pcb_coord_t X1, Y1, X2, Y2, Clearance; pcb_layer_id_t PCB_layer; Index: trunk/src_plugins/io_autotrax/write.c =================================================================== --- trunk/src_plugins/io_autotrax/write.c (revision 12227) +++ trunk/src_plugins/io_autotrax/write.c (revision 12228) @@ -97,7 +97,7 @@ /* --------------------------------------------------------------------------- * generates autotrax tracks to cross hatch a complex polygon being exported */ -void autotrax_cpoly_hatch_lines(FILE * FP, const pcb_polygon_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_cardinal_t layer) +void autotrax_cpoly_hatch_lines(FILE * FP, const pcb_poly_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_cardinal_t layer) { autotrax_hatch_ctx_t ctx; @@ -680,7 +680,7 @@ { int i; gdl_iterator_t it; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_cardinal_t current_layer = number; pcb_poly_it_t poly_it; Index: trunk/src_plugins/io_eagle/read.c =================================================================== --- trunk/src_plugins/io_eagle/read.c (revision 12227) +++ trunk/src_plugins/io_eagle/read.c (revision 12228) @@ -1053,7 +1053,7 @@ eagle_loc_t loc = type; eagle_layer_t *ly; long ln = eagle_get_attrl(st, subtree, "layer", -1); - pcb_polygon_t *poly; + pcb_poly_t *poly; trnode_t *n; ly = eagle_layer_get(st, ln); Index: trunk/src_plugins/io_hyp/write.c =================================================================== --- trunk/src_plugins/io_hyp/write.c (revision 12227) +++ trunk/src_plugins/io_hyp/write.c (revision 12228) @@ -136,7 +136,7 @@ safe_element_name(wr, (pcb_element_t *) pad->Element), pad->Number, pcb_pshash_pad(&wr->psh, pad, NULL)); } -static void write_poly(hyp_wr_t * wr, pcb_polygon_t * poly) +static void write_poly(hyp_wr_t * wr, pcb_poly_t * poly) { pcb_pline_t *pl; pcb_vnode_t *v; @@ -402,7 +402,7 @@ write_pad(wr, (pcb_pad_t *) o->obj); break; case PCB_OBJ_POLYGON: - write_poly(wr, (pcb_polygon_t *) o->obj); + write_poly(wr, (pcb_poly_t *) o->obj); break; case PCB_OBJ_RAT: Index: trunk/src_plugins/io_kicad/read.c =================================================================== --- trunk/src_plugins/io_kicad/read.c (revision 12227) +++ trunk/src_plugins/io_kicad/read.c (revision 12228) @@ -2072,7 +2072,7 @@ unsigned long tally = 0; unsigned long required; - pcb_polygon_t *polygon = NULL; + pcb_poly_t *polygon = NULL; pcb_flag_t flags = pcb_flag_make(PCB_FLAG_CLEARPOLY); char *end; double val; Index: trunk/src_plugins/io_kicad/write.c =================================================================== --- trunk/src_plugins/io_kicad/write.c (revision 12227) +++ trunk/src_plugins/io_kicad/write.c (revision 12228) @@ -1060,7 +1060,7 @@ { int i, j; gdl_iterator_t it; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_cardinal_t currentLayer = number; /* write information about non empty layers */ Index: trunk/src_plugins/io_kicad_legacy/write.c =================================================================== --- trunk/src_plugins/io_kicad_legacy/write.c (revision 12227) +++ trunk/src_plugins/io_kicad_legacy/write.c (revision 12228) @@ -1214,7 +1214,7 @@ { int i, j; gdl_iterator_t it; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_cardinal_t currentLayer = number; /* write information about non empty layers */ Index: trunk/src_plugins/io_lihata/read.c =================================================================== --- trunk/src_plugins/io_lihata/read.c (revision 12227) +++ trunk/src_plugins/io_lihata/read.c (revision 12228) @@ -507,7 +507,7 @@ static int parse_polygon(pcb_layer_t *ly, pcb_element_t *el, lht_node_t *obj) { - pcb_polygon_t *poly = pcb_poly_alloc(ly); + pcb_poly_t *poly = pcb_poly_alloc(ly); lht_node_t *geo; pcb_cardinal_t n = 0, c; unsigned char intconn = 0; @@ -1238,7 +1238,7 @@ } else if (strncmp(obj->name, "simplepoly.", 11) == 0) { int len; - pcb_polygon_t *sp; + pcb_poly_t *sp; if (obj->type != LHT_LIST) { pcb_message(PCB_MSG_ERROR, "Symbol error: simplepoly is not a list!\n"); continue; @@ -1540,7 +1540,7 @@ for(l = 0; l < pcb->Data->LayerN; l++) { pcb_layer_t *layer = pcb->Data->Layer + l; for(b = pcb_r_first(layer->polygon_tree, &it); b != NULL; b = pcb_r_next(&it)) { - pcb_polygon_t *p = (pcb_polygon_t *)b; + pcb_poly_t *p = (pcb_poly_t *)b; pcb_poly_init_clip(pcb->Data, layer, p); } pcb_r_end(&it); Index: trunk/src_plugins/io_lihata/write.c =================================================================== --- trunk/src_plugins/io_lihata/write.c (revision 12227) +++ trunk/src_plugins/io_lihata/write.c (revision 12228) @@ -275,7 +275,7 @@ } -static lht_node_t *build_simplepoly(pcb_polygon_t *poly, int local_id) +static lht_node_t *build_simplepoly(pcb_poly_t *poly, int local_id) { char buff[128]; lht_node_t *obj; @@ -377,7 +377,7 @@ return obj; } -static lht_node_t *build_polygon(pcb_polygon_t *poly) +static lht_node_t *build_polygon(pcb_poly_t *poly) { char buff[128]; lht_node_t *obj, *tbl, *geo; @@ -647,7 +647,7 @@ lht_node_t *obj, *grp, *comb; pcb_line_t *li; pcb_arc_t *ar; - pcb_polygon_t *po; + pcb_poly_t *po; pcb_text_t *tx; int added = 0; @@ -826,7 +826,7 @@ { lht_node_t *lst, *ndt; pcb_line_t *li; - pcb_polygon_t *poly; + pcb_poly_t *poly; pcb_arc_t *arc; int n; Index: trunk/src_plugins/io_pcb/file.c =================================================================== --- trunk/src_plugins/io_pcb/file.c (revision 12227) +++ trunk/src_plugins/io_pcb/file.c (revision 12228) @@ -505,7 +505,7 @@ pcb_line_t *line; pcb_arc_t *arc; pcb_text_t *text; - pcb_polygon_t *polygon; + pcb_poly_t *polygon; /* write information about non empty layers */ if (!pcb_layer_is_empty_(PCB, layer) || (layer->name && *layer->name)) { Index: trunk/src_plugins/io_pcb/parse_y.c =================================================================== --- trunk/src_plugins/io_pcb/parse_y.c (revision 12227) +++ trunk/src_plugins/io_pcb/parse_y.c (revision 12228) @@ -121,7 +121,7 @@ #include "obj_all.h" static pcb_layer_t *Layer; -static pcb_polygon_t *Polygon; +static pcb_poly_t *Polygon; static pcb_symbol_t *Symbol; static int pin_num; static pcb_lib_menu_t *Menu; Index: trunk/src_plugins/io_pcb/parse_y.y =================================================================== --- trunk/src_plugins/io_pcb/parse_y.y (revision 12227) +++ trunk/src_plugins/io_pcb/parse_y.y (revision 12228) @@ -58,7 +58,7 @@ #include "obj_all.h" static pcb_layer_t *Layer; -static pcb_polygon_t *Polygon; +static pcb_poly_t *Polygon; static pcb_symbol_t *Symbol; static int pin_num; static pcb_lib_menu_t *Menu; Index: trunk/src_plugins/lib_gtk_common/dlg_propedit.c =================================================================== --- trunk/src_plugins/lib_gtk_common/dlg_propedit.c (revision 12227) +++ trunk/src_plugins/lib_gtk_common/dlg_propedit.c (revision 12228) @@ -295,7 +295,7 @@ static void prop_preview_init(void) { - pcb_polygon_t *v; + pcb_poly_t *v; pcb_layer_id_t n; pcb_board_t *old_pcb; old_pcb = PCB; Index: trunk/src_plugins/lib_netmap/netmap.c =================================================================== --- trunk/src_plugins/lib_netmap/netmap.c (revision 12227) +++ trunk/src_plugins/lib_netmap/netmap.c (revision 12228) @@ -84,7 +84,7 @@ list_obj(ctx, pcb, layer, (pcb_any_obj_t *)arc); } -static void list_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly) +static void list_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly) { list_obj(ctx, pcb, layer, (pcb_any_obj_t *)poly); } Index: trunk/src_plugins/lib_polyhelp/polyhelp.c =================================================================== --- trunk/src_plugins/lib_polyhelp/polyhelp.c (revision 12227) +++ trunk/src_plugins/lib_polyhelp/polyhelp.c (revision 12228) @@ -97,7 +97,7 @@ } -pcb_bool pcb_cpoly_is_simple_rect(const pcb_polygon_t *p) +pcb_bool pcb_cpoly_is_simple_rect(const pcb_poly_t *p) { if (p->Clipped->f != p->Clipped) return pcb_false; /* more than one islands */ @@ -106,7 +106,7 @@ return pcb_pline_is_rectangle(p->Clipped->contours); } -pcb_cardinal_t pcb_cpoly_num_corners(const pcb_polygon_t *src) +pcb_cardinal_t pcb_cpoly_num_corners(const pcb_poly_t *src) { pcb_cardinal_t res = 0; pcb_poly_it_t it; @@ -179,7 +179,7 @@ /* collect all edge lines (contour and holes) in an rtree, calculate the bbox */ -pcb_cpoly_edgetree_t *pcb_cpoly_edgetree_create(const pcb_polygon_t *src, pcb_coord_t offs) +pcb_cpoly_edgetree_t *pcb_cpoly_edgetree_create(const pcb_poly_t *src, pcb_coord_t offs) { pcb_poly_it_t it; pcb_polyarea_t *pa; @@ -273,7 +273,7 @@ } -void pcb_cpoly_hatch(const pcb_polygon_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t offs, pcb_coord_t period, void *ctx, void (*cb)(void *ctx, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2)) +void pcb_cpoly_hatch(const pcb_poly_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t offs, pcb_coord_t period, void *ctx, void (*cb)(void *ctx, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2)) { pcb_cpoly_edgetree_t *etr; pcb_box_t scan; @@ -340,7 +340,7 @@ pcb_line_new(ctx->dst, x1, y1, x2, y2, ctx->thickness, ctx->clearance, ctx->flags); } -void pcb_cpoly_hatch_lines(pcb_layer_t *dst, const pcb_polygon_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_coord_t clearance, pcb_flag_t flags) +void pcb_cpoly_hatch_lines(pcb_layer_t *dst, const pcb_poly_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_coord_t clearance, pcb_flag_t flags) { hatch_ctx_t ctx; @@ -451,7 +451,7 @@ } } if (want_poly) { - pcb_polygon_t *p = pcb_poly_new_from_poly(CURRENT, polygon, period, polygon->Clearance, polygon->Flags); + pcb_poly_t *p = pcb_poly_new_from_poly(CURRENT, polygon, period, polygon->Clearance, polygon->Flags); PCB_FLAG_CLEAR(PCB_FLAG_SELECTED, p); } pcb_cpoly_hatch_lines(CURRENT, polygon, dir, period, conf_core.design.line_thickness, conf_core.design.line_thickness * 2, flg); @@ -478,7 +478,7 @@ } PCB_POLY_ALL_LOOP(PCB->Data); { - pcb_polygon_t *p; + pcb_poly_t *p; if (!PCB_FLAG_TEST(PCB_FLAG_SELECTED, polygon)) continue; Index: trunk/src_plugins/lib_polyhelp/polyhelp.h =================================================================== --- trunk/src_plugins/lib_polyhelp/polyhelp.h (revision 12227) +++ trunk/src_plugins/lib_polyhelp/polyhelp.h (revision 12228) @@ -32,7 +32,7 @@ /* Returns whether the clipped polygon is a simple rectangle (single island, no-hole rectangle). */ -pcb_bool pcb_cpoly_is_simple_rect(const pcb_polygon_t *p); +pcb_bool pcb_cpoly_is_simple_rect(const pcb_poly_t *p); /* Returns whether all edges of a pline are axis aligned */ pcb_bool pcb_pline_is_aligned(const pcb_pline_t *src); @@ -51,7 +51,7 @@ pcb_cpoly_edge_t edges[1]; } pcb_cpoly_edgetree_t; -pcb_cpoly_edgetree_t *pcb_cpoly_edgetree_create(const pcb_polygon_t *src, pcb_coord_t offs); +pcb_cpoly_edgetree_t *pcb_cpoly_edgetree_create(const pcb_poly_t *src, pcb_coord_t offs); void pcb_cpoly_edgetree_destroy(pcb_cpoly_edgetree_t *etr); @@ -65,8 +65,8 @@ /* hatch a polygon with horizontal and/or vertical lines drawn on dst, one line per period */ -void pcb_cpoly_hatch_lines(pcb_layer_t *dst, const pcb_polygon_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_coord_t clearance, pcb_flag_t flags); +void pcb_cpoly_hatch_lines(pcb_layer_t *dst, const pcb_poly_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t period, pcb_coord_t thickness, pcb_coord_t clearance, pcb_flag_t flags); /* Generic hor-ver hatch with a callback */ -void pcb_cpoly_hatch(const pcb_polygon_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t offs, pcb_coord_t period, void *ctx, void (*cb)(void *ctx, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2)); +void pcb_cpoly_hatch(const pcb_poly_t *src, pcb_cpoly_hatchdir_t dir, pcb_coord_t offs, pcb_coord_t period, void *ctx, void (*cb)(void *ctx, pcb_coord_t x1, pcb_coord_t y1, pcb_coord_t x2, pcb_coord_t y2)); Index: trunk/src_plugins/lib_polyhelp/topoly.c =================================================================== --- trunk/src_plugins/lib_polyhelp/topoly.c (revision 12227) +++ trunk/src_plugins/lib_polyhelp/topoly.c (revision 12228) @@ -190,13 +190,13 @@ return 0; } -pcb_polygon_t *contour2poly(pcb_board_t *pcb, vtp0_t *objs, vti0_t *ends, pcb_topoly_t how) +pcb_poly_t *contour2poly(pcb_board_t *pcb, vtp0_t *objs, vti0_t *ends, pcb_topoly_t how) { int n; pcb_any_obj_t **obj = (pcb_any_obj_t **)(&objs->array[0]); int *end = (int *)(&ends->array[0]); pcb_layer_t *layer = (*obj)->parent.layer; - pcb_polygon_t *poly = pcb_poly_alloc(layer); + pcb_poly_t *poly = pcb_poly_alloc(layer); pcb_coord_t x, y; obj++; @@ -238,12 +238,12 @@ return poly; } -pcb_polygon_t *pcb_topoly_conn(pcb_board_t *pcb, pcb_any_obj_t *start, pcb_topoly_t how) +pcb_poly_t *pcb_topoly_conn(pcb_board_t *pcb, pcb_any_obj_t *start, pcb_topoly_t how) { vtp0_t objs; vti0_t ends; int res; - pcb_polygon_t *poly; + pcb_poly_t *poly; if (!VALID_TYPE(start)) { pcb_message(PCB_MSG_ERROR, "pcb_topoly_conn(): starting object is not a line or arc\n"); Index: trunk/src_plugins/lib_polyhelp/topoly.h =================================================================== --- trunk/src_plugins/lib_polyhelp/topoly.h (revision 12227) +++ trunk/src_plugins/lib_polyhelp/topoly.h (revision 12228) @@ -33,7 +33,7 @@ /* Convert a loop of connected objects into a polygon (with no holes); the first object is named in start. */ -pcb_polygon_t *pcb_topoly_conn(pcb_board_t *pcb, pcb_any_obj_t *start, pcb_topoly_t how); +pcb_poly_t *pcb_topoly_conn(pcb_board_t *pcb, pcb_any_obj_t *start, pcb_topoly_t how); /* Find the first line/arc on the outline layer from top-left */ pcb_any_obj_t *pcb_topoly_find_1st_outline(pcb_board_t *pcb); Index: trunk/src_plugins/loghid/hid-logger.c =================================================================== --- trunk/src_plugins/loghid/hid-logger.c (revision 12227) +++ trunk/src_plugins/loghid/hid-logger.c (revision 12228) @@ -170,13 +170,13 @@ delegatee_->fill_polygon(gc, n_coords, x, y); } -static void log_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t *poly, const pcb_box_t *clip_box) +static void log_fill_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t *poly, const pcb_box_t *clip_box) { pcb_fprintf(out_, "fill_pcb_polygon(gc, poly->PointN=%d, ...)\n", poly->PointN); delegatee_->fill_pcb_polygon(gc, poly, clip_box); } -static void log_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_polygon_t *poly, const pcb_box_t *clip_box) +static void log_thindraw_pcb_polygon(pcb_hid_gc_t gc, pcb_poly_t *poly, const pcb_box_t *clip_box) { pcb_fprintf(out_, "thindraw_pcb_polygon(gc, poly->PointN=%d, ...)\n", poly->PointN); delegatee_->thindraw_pcb_polygon(gc, poly, clip_box); Index: trunk/src_plugins/millpath/toolpath.h =================================================================== --- trunk/src_plugins/millpath/toolpath.h (revision 12227) +++ trunk/src_plugins/millpath/toolpath.h (revision 12228) @@ -58,7 +58,7 @@ /* temp data */ pcb_layer_t *res_ply; /* resulting "remove" polygon */ pcb_layer_t *res_path; /* resulting toolpath */ - pcb_polygon_t *fill; /* base fill */ + pcb_poly_t *fill; /* base fill */ pcb_layergrp_t *grp; Index: trunk/src_plugins/polycombine/polycombine.c =================================================================== --- trunk/src_plugins/polycombine/polycombine.c (revision 12227) +++ trunk/src_plugins/polycombine/polycombine.c (revision 12228) @@ -38,7 +38,7 @@ #include "hid_actions.h" #include "obj_poly.h" -static pcb_polyarea_t *original_poly(pcb_polygon_t *p, pcb_bool *forward) +static pcb_polyarea_t *original_poly(pcb_poly_t *p, pcb_bool *forward) { pcb_pline_t *contour = NULL; pcb_polyarea_t *np = NULL; @@ -92,7 +92,7 @@ typedef struct poly_tree poly_tree; struct poly_tree { - pcb_polygon_t *polygon; + pcb_poly_t *polygon; pcb_bool forward; pcb_polyarea_t *polyarea; poly_tree *parent; @@ -277,7 +277,7 @@ pcb_polyarea_t *pa; pcb_pline_t *pline; pcb_vnode_t *node; - pcb_polygon_t *Polygon;*/ + pcb_poly_t *Polygon;*/ pcb_layer_t *Layer = NULL; poly_tree *root = NULL; poly_tree *this_node; Index: trunk/src_plugins/polystitch/polystitch.c =================================================================== --- trunk/src_plugins/polystitch/polystitch.c (revision 12227) +++ trunk/src_plugins/polystitch/polystitch.c (revision 12228) @@ -38,7 +38,7 @@ #include "obj_poly.h" #include "obj_poly_draw.h" -static pcb_polygon_t *inner_poly, *outer_poly; +static pcb_poly_t *inner_poly, *outer_poly; static pcb_layer_t *poly_layer; static double ATAN2(pcb_point_t a, pcb_point_t b) @@ -48,7 +48,7 @@ return atan2((double) b.Y - a.Y, (double) b.X - a.X); } -static double poly_winding(pcb_polygon_t * poly) +static double poly_winding(pcb_poly_t * poly) { double winding, turn; double prev_angle, this_angle; @@ -150,7 +150,7 @@ * \brief Rotate the polygon point list around so that point N is the * first one in the list. */ -static void rotate_points(pcb_polygon_t * poly, int n) +static void rotate_points(pcb_poly_t * poly, int n) { pcb_point_t *np; int n2 = poly->PointN - n; @@ -166,7 +166,7 @@ * \brief Make sure the first and last point of the polygon are the same * point, so we can stitch them properly. */ -static void dup_endpoints(pcb_polygon_t * poly) +static void dup_endpoints(pcb_poly_t * poly) { int n = poly->PointN; if (poly->Points[0].X == poly->Points[n - 1].X && poly->Points[0].Y == poly->Points[n - 1].Y) Index: trunk/src_plugins/propedit/propsel.c =================================================================== --- trunk/src_plugins/propedit/propsel.c (revision 12227) +++ trunk/src_plugins/propedit/propsel.c (revision 12228) @@ -118,7 +118,7 @@ map_attr(ctx, &text->Attributes); } -static void map_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly) +static void map_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly) { map_chk_skip(ctx, poly); map_attr(ctx, &poly->Attributes); @@ -311,7 +311,7 @@ } -static void set_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly) +static void set_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly) { set_ctx_t *st = (set_ctx_t *)ctx; @@ -509,7 +509,7 @@ del_attr(ctx, &text->Attributes); } -static void del_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly) +static void del_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly) { map_chk_skip(ctx, poly); del_attr(ctx, &poly->Attributes); Index: trunk/src_plugins/puller/puller.c =================================================================== --- trunk/src_plugins/puller/puller.c (revision 12227) +++ trunk/src_plugins/puller/puller.c (revision 12228) @@ -1546,7 +1546,7 @@ static pcb_r_dir_t gp_poly_cb(const pcb_box_t * b, void *cb) { int i; - const pcb_polygon_t *p = (pcb_polygon_t *) b; + const pcb_poly_t *p = (pcb_poly_t *) b; for (i = 0; i < p->PointN; i++) gp_point(p->Points[i].X, p->Points[i].Y, 0, 0); return PCB_R_DIR_NOT_FOUND; Index: trunk/src_plugins/query/query_access.c =================================================================== --- trunk/src_plugins/query/query_access.c (revision 12227) +++ trunk/src_plugins/query/query_access.c (revision 12228) @@ -64,7 +64,7 @@ APPEND(ctx, PCB_OBJ_TEXT, text, PCB_PARENT_LAYER, layer); } -static void list_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_polygon_t *poly) +static void list_poly_cb(void *ctx, pcb_board_t *pcb, pcb_layer_t *layer, pcb_poly_t *poly) { APPEND(ctx, PCB_OBJ_POLYGON, poly, PCB_PARENT_LAYER, layer); } @@ -416,7 +416,7 @@ static int field_polygon(pcb_obj_t *obj, pcb_qry_node_t *fld, pcb_qry_val_t *res) { - pcb_polygon_t *p = obj->data.polygon; + pcb_poly_t *p = obj->data.polygon; query_fields_keys_t fh1; fld2hash_req(fh1, fld, 0); Index: trunk/src_plugins/report/report.c =================================================================== --- trunk/src_plugins/report/report.c (revision 12227) +++ trunk/src_plugins/report/report.c (revision 12228) @@ -311,7 +311,7 @@ } case PCB_TYPE_POLYGON: { - pcb_polygon_t *Polygon; + pcb_poly_t *Polygon; #ifndef NDEBUG if (pcb_gui->shift_is_pressed()) { pcb_layer_t *layer = (pcb_layer_t *) ptr1; @@ -319,7 +319,7 @@ return 0; } #endif - Polygon = (pcb_polygon_t *) ptr2; + Polygon = (pcb_poly_t *) ptr2; report = pcb_strdup_printf("%m+POLYGON ID# %ld; Flags:%s\n" "Its bounding box is %$mD %$mD.\n" Index: trunk/src_plugins/rubberband_orig/rubberband.c =================================================================== --- trunk/src_plugins/rubberband_orig/rubberband.c (revision 12227) +++ trunk/src_plugins/rubberband_orig/rubberband.c (revision 12228) @@ -110,7 +110,7 @@ static void CheckLinePointForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_line_t *, pcb_point_t *,int delta_index); static void CheckArcPointForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_arc_t *, int *, pcb_bool); static void CheckArcForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_arc_t *, pcb_bool); -static void CheckPolygonForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_polygon_t *); +static void CheckPolygonForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_poly_t *); static void CheckLinePointForRat(rubber_ctx_t *rbnd, pcb_layer_t *, pcb_point_t *); static void calculate_route_rubber_arc_point_move(pcb_rubberband_arc_t * arcptr,pcb_coord_t group_dx,pcb_coord_t group_dy,pcb_route_t * route); @@ -659,7 +659,7 @@ * If one of the endpoints of the line lays inside the passed polygon, * the scanned line is added to the 'rubberband' list */ -static void CheckPolygonForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *Layer, pcb_polygon_t *Polygon) +static void CheckPolygonForRubberbandConnection(rubber_ctx_t *rbnd, pcb_layer_t *Layer, pcb_poly_t *Polygon) { pcb_layergrp_id_t group; @@ -762,7 +762,7 @@ case PCB_TYPE_POLYGON: if (pcb_layer_flags_((pcb_layer_t *)Ptr1) & PCB_LYT_COPPER) - CheckPolygonForRubberbandConnection(rbnd, (pcb_layer_t *) Ptr1, (pcb_polygon_t *) Ptr2); + CheckPolygonForRubberbandConnection(rbnd, (pcb_layer_t *) Ptr1, (pcb_poly_t *) Ptr2); break; } }