Index: trunk/src/crosshair.c
===================================================================
--- trunk/src/crosshair.c	(revision 27092)
+++ trunk/src/crosshair.c	(revision 27093)
@@ -99,7 +99,7 @@
 		}
 
 		/* normal contour line */
-		pcb_gui->draw_line(pcb_crosshair.GC,
+		pcb_render->draw_line(pcb_crosshair.GC,
 								 polygon->Points[i].X + dx,
 								 polygon->Points[i].Y + dy, polygon->Points[next].X + dx, polygon->Points[next].Y + dy);
 	}
@@ -121,7 +121,7 @@
 		}
 
 		/* normal contour line */
-		pcb_gui->draw_line(pcb_crosshair.GC,
+		pcb_render->draw_line(pcb_crosshair.GC,
 			PCB_CSWAP_X(polygon->Points[i].X, w, mirr) + dx,
 			PCB_CSWAP_Y(polygon->Points[i].Y, h, mirr) + dy,
 			PCB_CSWAP_X(polygon->Points[next].X, w, mirr) + dx,
@@ -234,8 +234,8 @@
 	pcb_point_t *point = (pcb_point_t *) pcb_crosshair.AttachedObject.Ptr3;
 
 	if (pcb_crosshair.AttachedObject.Type != PCB_OBJ_VOID) {
-		pcb_gui->draw_line(pcb_crosshair.GC, point->X, point->Y, line->Point1.X, line->Point1.Y);
-		pcb_gui->draw_line(pcb_crosshair.GC, point->X, point->Y, line->Point2.X, line->Point2.Y);
+		pcb_render->draw_line(pcb_crosshair.GC, point->X, point->Y, line->Point1.X, line->Point1.Y);
+		pcb_render->draw_line(pcb_crosshair.GC, point->X, point->Y, line->Point2.X, line->Point2.Y);
 	}
 }
 
@@ -440,8 +440,8 @@
 			next = pcb_poly_contour_next_point(polygon, point_idx);
 
 			/* draw the two segments */
-			pcb_gui->draw_line(pcb_crosshair.GC, polygon->Points[prev].X, polygon->Points[prev].Y, point->X + dx, point->Y + dy);
-			pcb_gui->draw_line(pcb_crosshair.GC, point->X + dx, point->Y + dy, polygon->Points[next].X, polygon->Points[next].Y);
+			pcb_render->draw_line(pcb_crosshair.GC, polygon->Points[prev].X, polygon->Points[prev].Y, point->X + dx, point->Y + dy);
+			pcb_render->draw_line(pcb_crosshair.GC, point->X + dx, point->Y + dy, polygon->Points[next].X, polygon->Points[next].Y);
 			break;
 		}
 
@@ -460,7 +460,7 @@
 				pcb_subc_t *sc = data->parent.subc;
 				pcb_coord_t ox, oy;
 				if (pcb_subc_get_origin(sc, &ox, &oy) == 0)
-					pcb_gui->draw_line(pcb_crosshair.GC, ox, oy, pcb_crosshair.X, pcb_crosshair.Y);
+					pcb_render->draw_line(pcb_crosshair.GC, ox, oy, pcb_crosshair.X, pcb_crosshair.Y);
 			}
 		}
 	}
@@ -486,7 +486,7 @@
 		y1 = pcb_crosshair.AttachedBox.Point1.Y;
 		x2 = pcb_crosshair.AttachedBox.Point2.X;
 		y2 = pcb_crosshair.AttachedBox.Point2.Y;
-		pcb_gui->draw_rect(pcb_crosshair.GC, x1, y1, x2, y2);
+		pcb_render->draw_rect(pcb_crosshair.GC, x1, y1, x2, y2);
 	}
 
 	if (!inhibit_drawing_mode)
@@ -507,8 +507,8 @@
 		pcb_render->set_drawing_mode(pcb_gui, PCB_HID_COMP_POSITIVE, 1, NULL);
 	}
 
-	pcb_gui->draw_line(pcb_crosshair.GC, pcb_marked.X - ms, pcb_marked.Y - ms, pcb_marked.X + ms, pcb_marked.Y + ms);
-	pcb_gui->draw_line(pcb_crosshair.GC, pcb_marked.X + ms, pcb_marked.Y - ms, pcb_marked.X - ms, pcb_marked.Y + ms);
+	pcb_render->draw_line(pcb_crosshair.GC, pcb_marked.X - ms, pcb_marked.Y - ms, pcb_marked.X + ms, pcb_marked.Y + ms);
+	pcb_render->draw_line(pcb_crosshair.GC, pcb_marked.X + ms, pcb_marked.Y - ms, pcb_marked.X - ms, pcb_marked.Y + ms);
 
 	if (!inhibit_drawing_mode)
 		pcb_render->set_drawing_mode(pcb_gui, PCB_HID_COMP_FLUSH, 1, NULL);
Index: trunk/src/draw.c
===================================================================
--- trunk/src/draw.c	(revision 27092)
+++ trunk/src/draw.c	(revision 27093)
@@ -123,7 +123,7 @@
 
 	if (len_mnt < minlen*2) {
 		/* line too short, just draw it */
-		pcb_gui->draw_line(GC, x1, y1, x2, y2);
+		pcb_render->draw_line(GC, x1, y1, x2, y2);
 		return;
 	}
 
@@ -138,7 +138,7 @@
 
 	/* first seg is drawn from x1, y1 with no rounding error due to n-1 == 0 */
 	for(n = 1; n < segs; n+=2)
-		pcb_gui->draw_line(GC,
+		pcb_render->draw_line(GC,
 			x1 + (dx * (double)(n-1) / (double)segs), y1 + (dy * (double)(n-1) / (double)segs),
 			x1 + (dx * (double)n / (double)segs), y1 + (dy * (double)n / (double)segs));
 
@@ -145,7 +145,7 @@
 
 	/* make sure the last segment is drawn properly to x2 and y2, don't leave
 	   room for rounding errors */
-	pcb_gui->draw_line(GC,
+	pcb_render->draw_line(GC,
 		x2 - (dx / (double)segs), y2 - (dy / (double)segs),
 		x2, y2);
 }
Index: trunk/src/draw.h
===================================================================
--- trunk/src/draw.h	(revision 27092)
+++ trunk/src/draw.h	(revision 27093)
@@ -147,7 +147,7 @@
 #define PCB_DRAW_BBOX(obj) \
 	do { \
 		pcb_hid_set_line_width(pcb_draw_out.fgGC, 0); \
-		pcb_gui->draw_rect(pcb_draw_out.fgGC, obj->BoundingBox.X1, obj->BoundingBox.Y1, obj->BoundingBox.X2, obj->BoundingBox.Y2); \
+		pcb_render->draw_rect(pcb_draw_out.fgGC, obj->BoundingBox.X1, obj->BoundingBox.Y1, obj->BoundingBox.X2, obj->BoundingBox.Y2); \
 	} while(0)
 #else
 #define PCB_DRAW_BBOX(obj)
Index: trunk/src/draw_composite.c
===================================================================
--- trunk/src/draw_composite.c	(revision 27092)
+++ trunk/src/draw_composite.c	(revision 27093)
@@ -43,9 +43,9 @@
 {
 	pcb_render->set_color(pcb_draw_out.fgGC, ctx->color);
 	if (ctx->info->drawn_area == NULL)
-		pcb_gui->fill_rect(pcb_draw_out.fgGC, 0, 0, ctx->info->pcb->hidlib.size_x, ctx->info->pcb->hidlib.size_y);
+		pcb_render->fill_rect(pcb_draw_out.fgGC, 0, 0, ctx->info->pcb->hidlib.size_x, ctx->info->pcb->hidlib.size_y);
 	else
-		pcb_gui->fill_rect(pcb_draw_out.fgGC, ctx->info->drawn_area->X1, ctx->info->drawn_area->Y1, ctx->info->drawn_area->X2, ctx->info->drawn_area->Y2);
+		pcb_render->fill_rect(pcb_draw_out.fgGC, ctx->info->drawn_area->X1, ctx->info->drawn_area->Y1, ctx->info->drawn_area->X2, ctx->info->drawn_area->Y2);
 }
 
 static void comp_start_sub_(comp_ctx_t *ctx)
Index: trunk/src/draw_ly_spec.c
===================================================================
--- trunk/src/draw_ly_spec.c	(revision 27092)
+++ trunk/src/draw_ly_spec.c	(revision 27093)
@@ -270,7 +270,7 @@
 		pcb_render->set_color(pcb_draw_out.fgGC, &PCB->Data->Layer[goutl->lid[0]].meta.real.color);
 		pcb_hid_set_line_cap(pcb_draw_out.fgGC, pcb_cap_round);
 		pcb_hid_set_line_width(pcb_draw_out.fgGC, conf_core.design.min_wid);
-		pcb_gui->draw_rect(pcb_draw_out.fgGC, 0, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
+		pcb_render->draw_rect(pcb_draw_out.fgGC, 0, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
 
 		pcb_render->set_drawing_mode(pcb_gui, PCB_HID_COMP_FLUSH, pcb_draw_out.direct, info->drawn_area);
 		pcb_render->end_layer(pcb_gui);
Index: trunk/src/draw_wireframe.h
===================================================================
--- trunk/src/draw_wireframe.h	(revision 27092)
+++ trunk/src/draw_wireframe.h	(revision 27093)
@@ -42,11 +42,11 @@
 	pcb_arc_get_end(arc, 0, &x1, &y1);
 	pcb_arc_get_end(arc, 1, &x2, &y2);
 
-	pcb_gui->draw_arc(gc, arc->X, arc->Y, arc->Width + wid, arc->Height + wid, arc->StartAngle, arc->Delta);
+	pcb_render->draw_arc(gc, arc->X, arc->Y, arc->Width + wid, arc->Height + wid, arc->StartAngle, arc->Delta);
 	if (wid > pcb_pixel_slop) {
-		pcb_gui->draw_arc(gc, arc->X, arc->Y, arc->Width - wid, arc->Height - wid, arc->StartAngle, arc->Delta);
-		pcb_gui->draw_arc(gc, x1, y1, wid, wid, arc->StartAngle, -180 * SGN(arc->Delta));
-		pcb_gui->draw_arc(gc, x2, y2, wid, wid, arc->StartAngle + arc->Delta, 180 * SGN(arc->Delta));
+		pcb_render->draw_arc(gc, arc->X, arc->Y, arc->Width - wid, arc->Height - wid, arc->StartAngle, arc->Delta);
+		pcb_render->draw_arc(gc, x1, y1, wid, wid, arc->StartAngle, -180 * SGN(arc->Delta));
+		pcb_render->draw_arc(gc, x2, y2, wid, wid, arc->StartAngle + arc->Delta, 180 * SGN(arc->Delta));
 	}
 }
 
@@ -69,34 +69,34 @@
 			y2 += dy * h;
 		}
 		if ((coord_abs(ox) >= pcb_pixel_slop) || (coord_abs(oy) >= pcb_pixel_slop)) {
-			pcb_gui->draw_line(gc, x1 + ox, y1 + oy, x2 + ox, y2 + oy);
-			pcb_gui->draw_line(gc, x1 - ox, y1 - oy, x2 - ox, y2 - oy);
+			pcb_render->draw_line(gc, x1 + ox, y1 + oy, x2 + ox, y2 + oy);
+			pcb_render->draw_line(gc, x1 - ox, y1 - oy, x2 - ox, y2 - oy);
 
 			/* draw caps */
 			if (!square) {
 				pcb_angle_t angle = atan2(dx, dy) * 57.295779;
-				pcb_gui->draw_arc(gc, x1, y1, thick / 2, thick / 2, angle - 180, 180);
-				pcb_gui->draw_arc(gc, x2, y2, thick / 2, thick / 2, angle, 180);
+				pcb_render->draw_arc(gc, x1, y1, thick / 2, thick / 2, angle - 180, 180);
+				pcb_render->draw_arc(gc, x2, y2, thick / 2, thick / 2, angle, 180);
 			}
 			else {
-				pcb_gui->draw_line(gc, x1 + ox, y1 + oy, x1 - ox, y1 - oy);
-				pcb_gui->draw_line(gc, x2 + ox, y2 + oy, x2 - ox, y2 - oy);
+				pcb_render->draw_line(gc, x1 + ox, y1 + oy, x1 - ox, y1 - oy);
+				pcb_render->draw_line(gc, x2 + ox, y2 + oy, x2 - ox, y2 - oy);
 			}
 		}
 		else
-			pcb_gui->draw_line(gc, x1, y1, x2, y2);
+			pcb_render->draw_line(gc, x1, y1, x2, y2);
 	}
 	else {
 		if (square) {
 			/* square cap 0 long line does not have an angle -> always draw it axis aligned */
 			pcb_coord_t cx1 = x1 - thick/2, cx2 = x1 + thick/2, cy1 = y1 - thick/2, cy2 = y1 + thick/2;
-			pcb_gui->draw_line(gc, cx1, cy1, cx2, cy1);
-			pcb_gui->draw_line(gc, cx2, cy1, cx2, cy2);
-			pcb_gui->draw_line(gc, cx2, cy2, cx1, cy2);
-			pcb_gui->draw_line(gc, cx1, cy2, cx1, cy1);
+			pcb_render->draw_line(gc, cx1, cy1, cx2, cy1);
+			pcb_render->draw_line(gc, cx2, cy1, cx2, cy2);
+			pcb_render->draw_line(gc, cx2, cy2, cx1, cy2);
+			pcb_render->draw_line(gc, cx1, cy2, cx1, cy1);
 		}
 		else
-			pcb_gui->draw_arc(gc, x1, y1, thick/2, thick/2, 0, 360); 
+			pcb_render->draw_arc(gc, x1, y1, thick/2, thick/2, 0, 360); 
 	}
 }
 
Index: trunk/src/obj_arc.c
===================================================================
--- trunk/src/obj_arc.c	(revision 27092)
+++ trunk/src/obj_arc.c	(revision 27093)
@@ -937,13 +937,13 @@
 		if ((allow_term_gfx) && pcb_draw_term_need_gfx(arc) && pcb_draw_term_hid_permission()) {
 			pcb_hid_set_line_cap(pcb_draw_out.active_padGC, pcb_cap_round);
 			pcb_hid_set_line_width(pcb_draw_out.active_padGC, thickness);
-			pcb_gui->draw_arc(pcb_draw_out.active_padGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
+			pcb_render->draw_arc(pcb_draw_out.active_padGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, PCB_DRAW_TERM_GFX_WIDTH);
 		}
 		else
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, thickness);
 		pcb_hid_set_line_cap(pcb_draw_out.fgGC, pcb_cap_round);
-		pcb_gui->draw_arc(pcb_draw_out.fgGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
+		pcb_render->draw_arc(pcb_draw_out.fgGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
 	}
 	else
 	{
@@ -951,7 +951,7 @@
 		pcb_hid_set_line_cap(pcb_draw_out.fgGC, pcb_cap_round);
 
 		if(conf_core.editor.thin_draw)
-			pcb_gui->draw_arc(pcb_draw_out.fgGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
+			pcb_render->draw_arc(pcb_draw_out.fgGC, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
 
 		if(conf_core.editor.wireframe_draw)
 			pcb_draw_wireframe_arc(pcb_draw_out.fgGC, arc, thickness);
Index: trunk/src/obj_arc_ui.c
===================================================================
--- trunk/src/obj_arc_ui.c	(revision 27092)
+++ trunk/src/obj_arc_ui.c	(revision 27093)
@@ -38,8 +38,8 @@
 static void draw_mark(pcb_hid_gc_t gc, const pcb_arc_t *arc)
 {
 	const pcb_coord_t mark = PCB_MM_TO_COORD(0.2);
-	pcb_gui->draw_line(gc, arc->X-mark, arc->Y, arc->X+mark, arc->Y);
-	pcb_gui->draw_line(gc, arc->X, arc->Y-mark, arc->X, arc->Y+mark);
+	pcb_render->draw_line(gc, arc->X-mark, arc->Y, arc->X+mark, arc->Y);
+	pcb_render->draw_line(gc, arc->X, arc->Y-mark, arc->X, arc->Y+mark);
 }
 
 static void pcb_arc_ui_move_or_copy_angle(pcb_crosshair_t *ch)
@@ -94,7 +94,7 @@
 	ch->AttachedObject.delta_angle = delta;
 	ch->AttachedObject.radius = 0;
 
-	pcb_gui->draw_arc(ch->GC, arc->X, arc->Y, arc->Width, arc->Height, start, delta);
+	pcb_render->draw_arc(ch->GC, arc->X, arc->Y, arc->Width, arc->Height, start, delta);
 	draw_mark(ch->GC, arc);
 }
 
@@ -113,7 +113,7 @@
 
 	ch->AttachedObject.radius = d;
 
-	pcb_gui->draw_arc(ch->GC, arc->X, arc->Y, ch->AttachedObject.radius, ch->AttachedObject.radius, arc->StartAngle, arc->Delta);
+	pcb_render->draw_arc(ch->GC, arc->X, arc->Y, ch->AttachedObject.radius, ch->AttachedObject.radius, arc->StartAngle, arc->Delta);
 
 	draw_mark(ch->GC, &arc2);
 }
Index: trunk/src/obj_line.c
===================================================================
--- trunk/src/obj_line.c	(revision 27092)
+++ trunk/src/obj_line.c	(revision 27093)
@@ -1089,17 +1089,17 @@
 		if ((allow_term_gfx) && pcb_draw_term_need_gfx(line) && pcb_draw_term_hid_permission()) {
 			pcb_hid_set_line_cap(pcb_draw_out.active_padGC, pcb_cap_round);
 			pcb_hid_set_line_width(pcb_draw_out.active_padGC, thickness);
-			pcb_gui->draw_line(pcb_draw_out.active_padGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
+			pcb_render->draw_line(pcb_draw_out.active_padGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, PCB_DRAW_TERM_GFX_WIDTH);
 		}
 		else
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, thickness);
-		pcb_gui->draw_line(pcb_draw_out.fgGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
+		pcb_render->draw_line(pcb_draw_out.fgGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
 	}
 	else {
 		if(conf_core.editor.thin_draw) {
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, 0);
-			pcb_gui->draw_line(pcb_draw_out.fgGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
+			pcb_render->draw_line(pcb_draw_out.fgGC, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
 		}
 
 		if(conf_core.editor.wireframe_draw) { 
Index: trunk/src/obj_poly.c
===================================================================
--- trunk/src/obj_poly.c	(revision 27092)
+++ trunk/src/obj_poly.c	(revision 27093)
@@ -1116,8 +1116,8 @@
 		np = poly->PointN;
 
 	for(n = 1; n < np; n++)
-		pcb_gui->draw_line(pcb_draw_out.fgGC, poly->Points[n-1].X, poly->Points[n-1].Y, poly->Points[n].X, poly->Points[n].Y);
-	pcb_gui->draw_line(pcb_draw_out.fgGC, poly->Points[n-1].X, poly->Points[n-1].Y, poly->Points[0].X, poly->Points[0].Y);
+		pcb_render->draw_line(pcb_draw_out.fgGC, poly->Points[n-1].X, poly->Points[n-1].Y, poly->Points[n].X, poly->Points[n].Y);
+	pcb_render->draw_line(pcb_draw_out.fgGC, poly->Points[n-1].X, poly->Points[n-1].Y, poly->Points[0].X, poly->Points[0].Y);
 }
 
 static void pcb_poly_draw_tr_offs(pcb_poly_it_t *it, pcb_coord_t offs)
@@ -1222,7 +1222,7 @@
 				r = PCB_DRAW_TERM_GFX_WIDTH;
 				pcb_hid_set_line_width(pcb_draw_out.fgGC, r);
 				pcb_hid_set_line_cap(pcb_draw_out.fgGC, pcb_cap_square);
-				pcb_gui->draw_line(pcb_draw_out.fgGC, x, y, x, y);
+				pcb_render->draw_line(pcb_draw_out.fgGC, x, y, x, y);
 			}
 		}
 		else
Index: trunk/src/obj_poly_draw_helper.c
===================================================================
--- trunk/src/obj_poly_draw_helper.c	(revision 27092)
+++ trunk/src/obj_poly_draw_helper.c	(revision 27093)
@@ -97,9 +97,9 @@
 	while ((v = v->next) != pl->head.next);
 
 	if (i < 3)
-		pcb_gui->draw_line(gc, last_x, last_y, this_x, this_y);
+		pcb_render->draw_line(gc, last_x, last_y, this_x, this_y);
 	else
-		pcb_gui->fill_polygon(gc, i, fc_x, fc_y);
+		pcb_render->fill_polygon(gc, i, fc_x, fc_y);
 
 	vert_opt_end();
 }
@@ -115,7 +115,7 @@
 
 	/* If the contour is round, use an arc drawing routine. */
 	if (pl->is_round) {
-		pcb_gui->draw_arc(gc, pl->cx, pl->cy, pl->radius, pl->radius, 0, 360);
+		pcb_render->draw_arc(gc, pl->cx, pl->cy, pl->radius, pl->radius, 0, 360);
 		return;
 	}
 
@@ -126,7 +126,7 @@
 	vert_opt_begin();
 	do {
 		vert_opt_loop1(v, 0, continue);
-		pcb_gui->draw_line(gc, last_x, last_y, this_x, this_y);
+		pcb_render->draw_line(gc, last_x, last_y, this_x, this_y);
 		vert_opt_loop2();
 	}
 	while ((v = v->next) != pl->head.next);
Index: trunk/src/obj_pstk.c
===================================================================
--- trunk/src/obj_pstk.c	(revision 27092)
+++ trunk/src/obj_pstk.c	(revision 27093)
@@ -455,11 +455,11 @@
 
 		if (!fill) {
 			for(n = 1; n < shape->data.poly.len; n++)
-				pcb_gui->draw_line(gc, ps->x + x[n-1], ps->y + y[n-1], ps->x + x[n], ps->y + y[n]);
-			pcb_gui->draw_line(gc, ps->x + x[n-1], ps->y + y[n-1], ps->x + x[0], ps->y + y[0]);
+				pcb_render->draw_line(gc, ps->x + x[n-1], ps->y + y[n-1], ps->x + x[n], ps->y + y[n]);
+			pcb_render->draw_line(gc, ps->x + x[n-1], ps->y + y[n-1], ps->x + x[0], ps->y + y[0]);
 		}
 		else
-			pcb_gui->fill_polygon_offs(gc, shape->data.poly.len, x, y, ps->x, ps->y);
+			pcb_render->fill_polygon_offs(gc, shape->data.poly.len, x, y, ps->x, ps->y);
 		if (p != p_st) {
 			free(p);
 			free(x);
@@ -468,11 +468,11 @@
 	else {
 		if (!fill) {
 			for(n = 1; n < shape->data.poly.len; n++)
-				pcb_gui->draw_line(gc, ps->x + shape->data.poly.x[n-1], ps->y + shape->data.poly.y[n-1], ps->x + shape->data.poly.x[n], ps->y + shape->data.poly.y[n]);
-			pcb_gui->draw_line(gc, ps->x + shape->data.poly.x[n-1], ps->y + shape->data.poly.y[n-1], ps->x + shape->data.poly.x[0], ps->y + shape->data.poly.y[0]);
+				pcb_render->draw_line(gc, ps->x + shape->data.poly.x[n-1], ps->y + shape->data.poly.y[n-1], ps->x + shape->data.poly.x[n], ps->y + shape->data.poly.y[n]);
+			pcb_render->draw_line(gc, ps->x + shape->data.poly.x[n-1], ps->y + shape->data.poly.y[n-1], ps->x + shape->data.poly.x[0], ps->y + shape->data.poly.y[0]);
 		}
 		else
-			pcb_gui->fill_polygon_offs(gc, shape->data.poly.len, shape->data.poly.x, shape->data.poly.y, ps->x, ps->y);
+			pcb_render->fill_polygon_offs(gc, shape->data.poly.len, shape->data.poly.x, shape->data.poly.y, ps->x, ps->y);
 	}
 }
 
@@ -489,12 +489,12 @@
 		case PCB_PSSH_LINE:
 			pcb_hid_set_line_cap(gc, shape->data.line.square ? pcb_cap_square : pcb_cap_round);
 			pcb_hid_set_line_width(gc, MAX(shape->data.line.thickness + dthick, 1));
-			pcb_gui->draw_line(gc, ps->x + shape->data.line.x1, ps->y + shape->data.line.y1, ps->x + shape->data.line.x2, ps->y + shape->data.line.y2);
+			pcb_render->draw_line(gc, ps->x + shape->data.line.x1, ps->y + shape->data.line.y1, ps->x + shape->data.line.x2, ps->y + shape->data.line.y2);
 			break;
 		case PCB_PSSH_CIRC:
 			r = MAX(shape->data.circ.dia/2 + dthick/2, 1);
 			pcb_hid_set_line_cap(gc, pcb_cap_round);
-			pcb_gui->fill_circle(gc, ps->x + shape->data.circ.x, ps->y + shape->data.circ.y, r);
+			pcb_render->fill_circle(gc, ps->x + shape->data.circ.x, ps->y + shape->data.circ.y, r);
 			break;
 		case PCB_PSSH_HSHADOW:
 			break;
@@ -518,7 +518,7 @@
 			break;
 		case PCB_PSSH_CIRC:
 			r = MAX(shape->data.circ.dia/2 + dthick/2, 1);
-			pcb_gui->draw_arc(gc, ps->x + shape->data.circ.x, ps->y + shape->data.circ.y, r, r, 0, 360);
+			pcb_render->draw_arc(gc, ps->x + shape->data.circ.x, ps->y + shape->data.circ.y, r, r, 0, 360);
 			break;
 		case PCB_PSSH_HSHADOW:
 			break;
@@ -594,11 +594,11 @@
 	set_ps_annot_color(pcb_draw_out.fgGC, ps);
 	pcb_hid_set_line_width(pcb_draw_out.fgGC, 0);
 	if (mark2 > pcb_gui->coord_per_pix*3) {
-		pcb_gui->draw_line(pcb_draw_out.fgGC, ps->x-mark, ps->y, ps->x+mark, ps->y);
-		pcb_gui->draw_line(pcb_draw_out.fgGC, ps->x, ps->y-mark, ps->x, ps->y+mark);
+		pcb_render->draw_line(pcb_draw_out.fgGC, ps->x-mark, ps->y, ps->x+mark, ps->y);
+		pcb_render->draw_line(pcb_draw_out.fgGC, ps->x, ps->y-mark, ps->x, ps->y+mark);
 	}
 	else
-		pcb_gui->draw_line(pcb_draw_out.fgGC, ps->x-pcb_gui->coord_per_pix, ps->y, ps->x+pcb_gui->coord_per_pix, ps->y);
+		pcb_render->draw_line(pcb_draw_out.fgGC, ps->x-pcb_gui->coord_per_pix, ps->y, ps->x+pcb_gui->coord_per_pix, ps->y);
 
 	return PCB_R_DIR_FOUND_CONTINUE;
 }
@@ -653,7 +653,7 @@
 	/* actual hole */
 	pcb_hid_set_line_width(pcb_draw_out.drillGC, 0);
 	pcb_hid_set_line_cap(pcb_draw_out.drillGC, pcb_cap_round);
-	pcb_gui->fill_circle(pcb_draw_out.drillGC, ps->x, ps->y, proto->hdia / 2);
+	pcb_render->fill_circle(pcb_draw_out.drillGC, ps->x, ps->y, proto->hdia / 2);
 
 	/* indicate unplated holes with an arc; unplated holes are more rare
 	   than plated holes, thus unplated holes are indicated */
@@ -662,7 +662,7 @@
 		r -= r/8; /* +12.5% */
 		pcb_render->set_color(pcb_draw_out.fgGC, PCB_FLAG_TEST(PCB_FLAG_SELECTED, ps) ? &conf_core.appearance.color.selected : &conf_core.appearance.color.subc);
 		pcb_hid_set_line_width(pcb_draw_out.fgGC, 0);
-		pcb_gui->draw_arc(pcb_draw_out.fgGC, ps->x, ps->y, r, r, 20, 290);
+		pcb_render->draw_arc(pcb_draw_out.fgGC, ps->x, ps->y, r, r, 20, 290);
 	}
 
 	return PCB_R_DIR_FOUND_CONTINUE;
Index: trunk/src/obj_rat.c
===================================================================
--- trunk/src/obj_rat.c	(revision 27092)
+++ trunk/src/obj_rat.c	(revision 27093)
@@ -463,7 +463,7 @@
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, 0);
 		else
 			pcb_hid_set_line_width(pcb_draw_out.fgGC, w);
-		pcb_gui->draw_arc(pcb_draw_out.fgGC, rat->Point1.X, rat->Point1.Y, w * 2, w * 2, 0, 360);
+		pcb_render->draw_arc(pcb_draw_out.fgGC, rat->Point1.X, rat->Point1.Y, w * 2, w * 2, 0, 360);
 	}
 	else
 		pcb_line_draw_(NULL, (pcb_line_t *) rat, 0);
Index: trunk/src/obj_subc.c
===================================================================
--- trunk/src/obj_subc.c	(revision 27092)
+++ trunk/src/obj_subc.c	(revision 27093)
@@ -629,10 +629,10 @@
 	DX += (origin->Point1.X + origin->Point2.X) / 2;
 	DY += (origin->Point1.Y + origin->Point2.Y) / 2;
 
-	pcb_gui->draw_line(GC, DX - PCB_EMARK_SIZE, DY, DX, DY - PCB_EMARK_SIZE);
-	pcb_gui->draw_line(GC, DX + PCB_EMARK_SIZE, DY, DX, DY - PCB_EMARK_SIZE);
-	pcb_gui->draw_line(GC, DX - PCB_EMARK_SIZE, DY, DX, DY + PCB_EMARK_SIZE);
-	pcb_gui->draw_line(GC, DX + PCB_EMARK_SIZE, DY, DX, DY + PCB_EMARK_SIZE);
+	pcb_render->draw_line(GC, DX - PCB_EMARK_SIZE, DY, DX, DY - PCB_EMARK_SIZE);
+	pcb_render->draw_line(GC, DX + PCB_EMARK_SIZE, DY, DX, DY - PCB_EMARK_SIZE);
+	pcb_render->draw_line(GC, DX - PCB_EMARK_SIZE, DY, DX, DY + PCB_EMARK_SIZE);
+	pcb_render->draw_line(GC, DX + PCB_EMARK_SIZE, DY, DX, DY + PCB_EMARK_SIZE);
 }
 
 void pcb_xordraw_subc(pcb_subc_t *sc, pcb_coord_t DX, pcb_coord_t DY, int use_curr_side)
@@ -672,7 +672,7 @@
 TODO(": The wireframe arc drawing code cannot draw ellipses yet so draw the elliptical arc with a thin line ")
 				double sa = mirr ? PCB_SWAP_ANGLE(arc->StartAngle) : arc->StartAngle;
 				double da = mirr ? PCB_SWAP_DELTA(arc->Delta) : arc->Delta;
-				pcb_gui->draw_arc(pcb_crosshair.GC, DX + PCB_CSWAP_X(arc->X, w, mirr), DY + PCB_CSWAP_Y(arc->Y, h, mirr), arc->Width, arc->Height, sa, da);
+				pcb_render->draw_arc(pcb_crosshair.GC, DX + PCB_CSWAP_X(arc->X, w, mirr), DY + PCB_CSWAP_Y(arc->Y, h, mirr), arc->Width, arc->Height, sa, da);
 			}
 			else {
 				pcb_arc_t temp_arc;
Index: trunk/src/obj_text.c
===================================================================
--- trunk/src/obj_text.c	(revision 27092)
+++ trunk/src/obj_text.c	(revision 27093)
@@ -981,11 +981,11 @@
 	if (xordraw || thindraw) {
 		pcb_hid_gc_t gc = xordraw ? pcb_crosshair.GC : pcb_draw_out.fgGC;
 		for(n = 1, p = poly->Points+1; n < max; n++,p++)
-			pcb_gui->draw_line(gc, xordx + x[n-1], xordy + y[n-1], xordx + x[n], xordy + y[n]);
-		pcb_gui->draw_line(gc, xordx + x[0], xordy + y[0], xordx + x[max-1], xordy + y[max-1]);
+			pcb_render->draw_line(gc, xordx + x[n-1], xordy + y[n-1], xordx + x[n], xordy + y[n]);
+		pcb_render->draw_line(gc, xordx + x[0], xordy + y[0], xordx + x[max-1], xordy + y[max-1]);
 	}
 	else
-		pcb_gui->fill_polygon(pcb_draw_out.fgGC, poly->PointN, x, y);
+		pcb_render->fill_polygon(pcb_draw_out.fgGC, poly->PointN, x, y);
 }
 
 /* Very rough estimation on the full width of the text */
@@ -1036,7 +1036,7 @@
 	tx2 += xordx;
 	ty2 += xordy;
 
-	pcb_gui->draw_line(gc, tx1, ty1, tx2, ty2);
+	pcb_render->draw_line(gc, tx1, ty1, tx2, ty2);
 }
 
 
@@ -1126,7 +1126,7 @@
 				if (thickness > 0)
 					newline.Thickness = thickness;
 				if (xordraw)
-					pcb_gui->draw_line(pcb_crosshair.GC, xordx + newline.Point1.X, xordy + newline.Point1.Y, xordx + newline.Point2.X, xordy + newline.Point2.Y);
+					pcb_render->draw_line(pcb_crosshair.GC, xordx + newline.Point1.X, xordy + newline.Point1.Y, xordx + newline.Point2.X, xordy + newline.Point2.Y);
 				else
 					pcb_line_draw_(info, &newline, 0);
 			}
@@ -1149,7 +1149,7 @@
 				if (thickness > 0)
 					newarc.Thickness = thickness;
 				if (xordraw)
-					pcb_gui->draw_arc(pcb_crosshair.GC, xordx + newarc.X, xordy + newarc.Y, newarc.Width, newarc.Height, newarc.StartAngle, newarc.Delta);
+					pcb_render->draw_arc(pcb_crosshair.GC, xordx + newarc.X, xordy + newarc.Y, newarc.Width, newarc.Height, newarc.StartAngle, newarc.Delta);
 				else
 					pcb_arc_draw_(info, &newarc, 0);
 			}
@@ -1179,20 +1179,20 @@
 			/* draw move on to next cursor position */
 			if (xordraw || (conf_core.editor.thin_draw || conf_core.editor.wireframe_draw)) {
 				if (xordraw) {
-					pcb_gui->draw_line(pcb_crosshair.GC, px[0] + xordx, py[0] + xordy, px[1] + xordx, py[1] + xordy);
-					pcb_gui->draw_line(pcb_crosshair.GC, px[1] + xordx, py[1] + xordy, px[2] + xordx, py[2] + xordy);
-					pcb_gui->draw_line(pcb_crosshair.GC, px[2] + xordx, py[2] + xordy, px[3] + xordx, py[3] + xordy);
-					pcb_gui->draw_line(pcb_crosshair.GC, px[3] + xordx, py[3] + xordy, px[0] + xordx, py[0] + xordy);
+					pcb_render->draw_line(pcb_crosshair.GC, px[0] + xordx, py[0] + xordy, px[1] + xordx, py[1] + xordy);
+					pcb_render->draw_line(pcb_crosshair.GC, px[1] + xordx, py[1] + xordy, px[2] + xordx, py[2] + xordy);
+					pcb_render->draw_line(pcb_crosshair.GC, px[2] + xordx, py[2] + xordy, px[3] + xordx, py[3] + xordy);
+					pcb_render->draw_line(pcb_crosshair.GC, px[3] + xordx, py[3] + xordy, px[0] + xordx, py[0] + xordy);
 				}
 				else {
-					pcb_gui->draw_line(pcb_draw_out.fgGC, px[0], py[0], px[1], py[1]);
-					pcb_gui->draw_line(pcb_draw_out.fgGC, px[1], py[1], px[2], py[2]);
-					pcb_gui->draw_line(pcb_draw_out.fgGC, px[2], py[2], px[3], py[3]);
-					pcb_gui->draw_line(pcb_draw_out.fgGC, px[3], py[3], px[0], py[0]);
+					pcb_render->draw_line(pcb_draw_out.fgGC, px[0], py[0], px[1], py[1]);
+					pcb_render->draw_line(pcb_draw_out.fgGC, px[1], py[1], px[2], py[2]);
+					pcb_render->draw_line(pcb_draw_out.fgGC, px[2], py[2], px[3], py[3]);
+					pcb_render->draw_line(pcb_draw_out.fgGC, px[3], py[3], px[0], py[0]);
 				}
 			}
 			else {
-				pcb_gui->fill_polygon(pcb_draw_out.fgGC, 4, px, py);
+				pcb_render->fill_polygon(pcb_draw_out.fgGC, 4, px, py);
 			}
 			x += size;
 		}
@@ -1353,10 +1353,10 @@
 {
 	DrawTextLowLevel_(NULL, text, 0, 1, x, y, PCB_TXT_TINY_CHEAP);
 	if ((conf_core.appearance.text_host_bbox) && (text->BoundingBox.X1 != text->BoundingBox.X2)) {
-		pcb_gui->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X1, y + text->BoundingBox.Y1, x + text->BoundingBox.X1, y + text->BoundingBox.Y2);
-		pcb_gui->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X1, y + text->BoundingBox.Y1, x + text->BoundingBox.X2, y + text->BoundingBox.Y1);
-		pcb_gui->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X2, y + text->BoundingBox.Y2, x + text->BoundingBox.X1, y + text->BoundingBox.Y2);
-		pcb_gui->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X2, y + text->BoundingBox.Y2, x + text->BoundingBox.X2, y + text->BoundingBox.Y1);
+		pcb_render->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X1, y + text->BoundingBox.Y1, x + text->BoundingBox.X1, y + text->BoundingBox.Y2);
+		pcb_render->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X1, y + text->BoundingBox.Y1, x + text->BoundingBox.X2, y + text->BoundingBox.Y1);
+		pcb_render->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X2, y + text->BoundingBox.Y2, x + text->BoundingBox.X1, y + text->BoundingBox.Y2);
+		pcb_render->draw_line(pcb_crosshair.GC, x + text->BoundingBox.X2, y + text->BoundingBox.Y2, x + text->BoundingBox.X2, y + text->BoundingBox.Y1);
 	}
 }
 
Index: trunk/src/route.c
===================================================================
--- trunk/src/route.c	(revision 27092)
+++ trunk/src/route.c	(revision 27093)
@@ -664,11 +664,11 @@
 	x2 = x - (cos(PCB_M180 * (start_angle + delta)) * radius);
 	y2 = y + (sin(PCB_M180 * (start_angle + delta)) * radius);
 
-	pcb_gui->draw_arc(GC, x, y, radius + wid, radius + wid, start_angle, delta);
+	pcb_render->draw_arc(GC, x, y, radius + wid, radius + wid, start_angle, delta);
 	if (wid > pcb_pixel_slop) {
-		pcb_gui->draw_arc(GC, x, y, radius - wid, radius - wid, start_angle, delta);
-		pcb_gui->draw_arc(GC, x1, y1, wid, wid, start_angle, -180 * SGN(delta));
-		pcb_gui->draw_arc(GC, x2, y2, wid, wid, start_angle + delta, 180 * SGN(delta));
+		pcb_render->draw_arc(GC, x, y, radius - wid, radius - wid, start_angle, delta);
+		pcb_render->draw_arc(GC, x1, y1, wid, wid, start_angle, -180 * SGN(delta));
+		pcb_render->draw_arc(GC, x2, y2, wid, wid, start_angle + delta, 180 * SGN(delta));
 	}
 
 }
Index: trunk/src/tool_poly.c
===================================================================
--- trunk/src/tool_poly.c	(revision 27092)
+++ trunk/src/tool_poly.c	(revision 27093)
@@ -116,7 +116,7 @@
 {
 	/* draw only if starting point is set */
 	if (pcb_crosshair.AttachedLine.State != PCB_CH_STATE_FIRST)
-		pcb_gui->draw_line(pcb_crosshair.GC,
+		pcb_render->draw_line(pcb_crosshair.GC,
 									 pcb_crosshair.AttachedLine.Point1.X,
 									 pcb_crosshair.AttachedLine.Point1.Y, pcb_crosshair.AttachedLine.Point2.X, pcb_crosshair.AttachedLine.Point2.Y);
 
Index: trunk/src/tool_polyhole.c
===================================================================
--- trunk/src/tool_polyhole.c	(revision 27092)
+++ trunk/src/tool_polyhole.c	(revision 27093)
@@ -145,7 +145,7 @@
 {
 	/* draw only if starting point is set */
 	if (pcb_crosshair.AttachedLine.State != PCB_CH_STATE_FIRST)
-		pcb_gui->draw_line(pcb_crosshair.GC,
+		pcb_render->draw_line(pcb_crosshair.GC,
 									 pcb_crosshair.AttachedLine.Point1.X,
 									 pcb_crosshair.AttachedLine.Point1.Y, pcb_crosshair.AttachedLine.Point2.X, pcb_crosshair.AttachedLine.Point2.Y);
 
Index: trunk/src/tool_via.c
===================================================================
--- trunk/src/tool_via.c	(revision 27092)
+++ trunk/src/tool_via.c	(revision 27093)
@@ -87,7 +87,7 @@
 static void xor_draw_fake_via(pcb_coord_t x, pcb_coord_t y, pcb_coord_t dia, pcb_coord_t clearance)
 {
 	pcb_coord_t r = (dia/2)+clearance;
-	pcb_gui->draw_arc(pcb_crosshair.GC, x, y, r, r, 0, 360);
+	pcb_render->draw_arc(pcb_crosshair.GC, x, y, r, r, 0, 360);
 }
 
 
Index: trunk/src_plugins/ddraft/ddraft.c
===================================================================
--- trunk/src_plugins/ddraft/ddraft.c	(revision 27092)
+++ trunk/src_plugins/ddraft/ddraft.c	(revision 27093)
@@ -381,7 +381,7 @@
 	pcb_render->set_color(pcb_crosshair.GC, pcb_color_grey33);
 	for(n = 0; n < vtc0_len(&pcb_ddraft_attached.annot_lines); n += 4) {
 		pcb_coord_t *c = &pcb_ddraft_attached.annot_lines.array[n];
-		pcb_gui->draw_line(pcb_crosshair.GC, c[0], c[1], c[2], c[3]);
+		pcb_render->draw_line(pcb_crosshair.GC, c[0], c[1], c[2], c[3]);
 	}
 
 	if (pcb_ddraft_attached.line_valid) {
Index: trunk/src_plugins/dialogs/dlg_lib_pstk.c
===================================================================
--- trunk/src_plugins/dialogs/dlg_lib_pstk.c	(revision 27092)
+++ trunk/src_plugins/dialogs/dlg_lib_pstk.c	(revision 27093)
@@ -184,13 +184,13 @@
 
 	grid = ctx->dlg[ctx->wgrid].val.crd;
 	for(x = 0; x < x2; x += grid)
-		pcb_gui->draw_line(gc, x, y1, x, y2);
+		pcb_render->draw_line(gc, x, y1, x, y2);
 	for(x = -grid; x > x1; x -= grid)
-		pcb_gui->draw_line(gc, x, y1, x, y2);
+		pcb_render->draw_line(gc, x, y1, x, y2);
 	for(y = 0; y < y2; y += grid)
-		pcb_gui->draw_line(gc, x1, y, x2, y);
+		pcb_render->draw_line(gc, x1, y, x2, y);
 	for(y = -grid; y > y1; y -= grid)
-		pcb_gui->draw_line(gc, x1, y, x2, y);
+		pcb_render->draw_line(gc, x1, y, x2, y);
 
 	/* draw the mark only */
 	for(n = 0; n < pcb_proto_num_layers; n++)
Index: trunk/src_plugins/draw_fab/draw_fab.c
===================================================================
--- trunk/src_plugins/draw_fab/draw_fab.c	(revision 27092)
+++ trunk/src_plugins/draw_fab/draw_fab.c	(revision 27093)
@@ -63,13 +63,13 @@
 
 static void fab_line(pcb_hid_gc_t gc, int x1, int y1, int x2, int y2)
 {
-	pcb_gui->draw_line(gc, x1, y1, x2, y2);
+	pcb_render->draw_line(gc, x1, y1, x2, y2);
 }
 
 static void fab_circle(pcb_hid_gc_t gc, int x, int y, int r)
 {
-	pcb_gui->draw_arc(gc, x, y, r, r, 0, 180);
-	pcb_gui->draw_arc(gc, x, y, r, r, 180, 180);
+	pcb_render->draw_arc(gc, x, y, r, r, 0, 180);
+	pcb_render->draw_arc(gc, x, y, r, r, 180, 180);
 }
 
 /* align is 0=left, 1=center, 2=right, add 8 for underline */
@@ -182,12 +182,12 @@
 	pcb_hid_set_line_width(gc, PCB_MIL_TO_COORD(10));
 	PCB_LINE_LOOP(layer);
 	{
-		pcb_gui->draw_line(gc, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
+		pcb_render->draw_line(gc, line->Point1.X, line->Point1.Y, line->Point2.X, line->Point2.Y);
 	}
 	PCB_END_LOOP;
 	PCB_ARC_LOOP(layer);
 	{
-		pcb_gui->draw_arc(gc, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
+		pcb_render->draw_arc(gc, arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle, arc->Delta);
 	}
 	PCB_END_LOOP;
 	PCB_TEXT_LOOP(layer);
@@ -308,10 +308,10 @@
 	}
 	if (!found) {
 		pcb_hid_set_line_width(gc, PCB_MIL_TO_COORD(10));
-		pcb_gui->draw_line(gc, 0, 0, PCB->hidlib.size_x, 0);
-		pcb_gui->draw_line(gc, 0, 0, 0, PCB->hidlib.size_y);
-		pcb_gui->draw_line(gc, PCB->hidlib.size_x, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
-		pcb_gui->draw_line(gc, 0, PCB->hidlib.size_y, PCB->hidlib.size_x, PCB->hidlib.size_y);
+		pcb_render->draw_line(gc, 0, 0, PCB->hidlib.size_x, 0);
+		pcb_render->draw_line(gc, 0, 0, 0, PCB->hidlib.size_y);
+		pcb_render->draw_line(gc, PCB->hidlib.size_x, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
+		pcb_render->draw_line(gc, 0, PCB->hidlib.size_y, PCB->hidlib.size_x, PCB->hidlib.size_y);
 		/*FPrintOutline (); */
 		pcb_hid_set_line_width(gc, FAB_LINE_W);
 		text_at(info, gc, PCB_MIL_TO_COORD(2000), yoff, 0,
Index: trunk/src_plugins/export_gerber/gerber.c
===================================================================
--- trunk/src_plugins/export_gerber/gerber.c	(revision 27092)
+++ trunk/src_plugins/export_gerber/gerber.c	(revision 27093)
@@ -866,10 +866,10 @@
 				pcb_hid_set_line_width(gc, conf_core.design.min_wid);
 			else
 				pcb_hid_set_line_width(gc, AUTO_OUTLINE_WIDTH);
-			pcb_gui->draw_line(gc, 0, 0, PCB->hidlib.size_x, 0);
-			pcb_gui->draw_line(gc, 0, 0, 0, PCB->hidlib.size_y);
-			pcb_gui->draw_line(gc, PCB->hidlib.size_x, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
-			pcb_gui->draw_line(gc, 0, PCB->hidlib.size_y, PCB->hidlib.size_x, PCB->hidlib.size_y);
+			pcb_render->draw_line(gc, 0, 0, PCB->hidlib.size_x, 0);
+			pcb_render->draw_line(gc, 0, 0, 0, PCB->hidlib.size_y);
+			pcb_render->draw_line(gc, PCB->hidlib.size_x, 0, PCB->hidlib.size_x, PCB->hidlib.size_y);
+			pcb_render->draw_line(gc, 0, PCB->hidlib.size_y, PCB->hidlib.size_x, PCB->hidlib.size_y);
 			pcb_hid_destroy_gc(gc);
 		}
 	}
Index: trunk/src_plugins/jostle/jostle.c
===================================================================
--- trunk/src_plugins/jostle/jostle.c	(revision 27092)
+++ trunk/src_plugins/jostle/jostle.c	(revision 27093)
@@ -100,10 +100,10 @@
 				pcb_render->set_color(ddgc, color ? color : conf_core.appearance.color.connected);
 				pcb_hid_set_line_width(ddgc, 1);
 				for (i = 0; i < n - 1; i++) {
-					pcb_gui->draw_line(ddgc, x[i], y[i], x[i + 1], y[i + 1]);
-					pcb_gui->fill_circle (ddgc, x[i], y[i], 30);
+					pcb_render->draw_line(ddgc, x[i], y[i], x[i + 1], y[i + 1]);
+					pcb_render->fill_circle (ddgc, x[i], y[i], 30);
 				}
-				pcb_gui->draw_line(ddgc, x[n - 1], y[n - 1], x[0], y[0]);
+				pcb_render->draw_line(ddgc, x[n - 1], y[n - 1], x[0], y[0]);
 			}*/
 			free(x);
 			free(y);
Index: trunk/src_plugins/lib_hid_common/lead_user.c
===================================================================
--- trunk/src_plugins/lib_hid_common/lead_user.c	(revision 27092)
+++ trunk/src_plugins/lib_hid_common/lead_user.c	(revision 27093)
@@ -101,12 +101,12 @@
 
 /*		pcb_render->set_color(*gc, const pcb_color_t *color);*/
 
-		pcb_gui->draw_line(*gc, x, y, x - ARL, y);
-		pcb_gui->draw_line(*gc, x, y, x, y-ARL);
-		pcb_gui->draw_line(*gc, x - ARL, y, x, y-ARL);
+		pcb_render->draw_line(*gc, x, y, x - ARL, y);
+		pcb_render->draw_line(*gc, x, y, x, y-ARL);
+		pcb_render->draw_line(*gc, x - ARL, y, x, y-ARL);
 
 		pcb_gui->set_line_width(*gc, ARL/4);
-		pcb_gui->draw_line(*gc, x - ARL/2, y - ARL/2, x - LEAD_ARROW_LEN, y - LEAD_ARROW_LEN);
+		pcb_render->draw_line(*gc, x - ARL/2, y - ARL/2, x - LEAD_ARROW_LEN, y - LEAD_ARROW_LEN);
 
 	}
 }
Index: trunk/src_plugins/serpentine/serpentine.c
===================================================================
--- trunk/src_plugins/serpentine/serpentine.c	(revision 27092)
+++ trunk/src_plugins/serpentine/serpentine.c	(revision 27093)
@@ -98,10 +98,10 @@
 	const pcb_coord_t y2 = p_info->end.Y + ny;
 	
 	pcb_render->set_color(pcb_crosshair.GC, "#808080" /*conf_core.appearance.color.crosshair*/ );
-	pcb_gui->draw_line(pcb_crosshair.GC, p_info->start.X, p_info->start.Y, p_info->end.X, p_info->end.Y );
-	pcb_gui->draw_line(pcb_crosshair.GC, p_info->start.X, p_info->start.Y, x1, y1 );
-	pcb_gui->draw_line(pcb_crosshair.GC, p_info->end.X, p_info->end.Y, x2, y2 );
-	pcb_gui->draw_line(pcb_crosshair.GC, x1, y1, x2, y2 );
+	pcb_render->draw_line(pcb_crosshair.GC, p_info->start.X, p_info->start.Y, p_info->end.X, p_info->end.Y );
+	pcb_render->draw_line(pcb_crosshair.GC, p_info->start.X, p_info->start.Y, x1, y1 );
+	pcb_render->draw_line(pcb_crosshair.GC, p_info->end.X, p_info->end.Y, x2, y2 );
+	pcb_render->draw_line(pcb_crosshair.GC, x1, y1, x2, y2 );
 }
 
 int 
Index: trunk/src_plugins/sketch_route/sketch_route.c
===================================================================
--- trunk/src_plugins/sketch_route/sketch_route.c	(revision 27092)
+++ trunk/src_plugins/sketch_route/sketch_route.c	(revision 27093)
@@ -1083,7 +1083,7 @@
 		for (i = 0; i < vtp0_len(&attached_path.lines); i++) {
 			pcb_point_t *p1 = &((pcb_attached_line_t *) attached_path.lines.array[i])->Point1;
 			pcb_point_t *p2 = &((pcb_attached_line_t *) attached_path.lines.array[i])->Point2;
-			pcb_gui->draw_line(pcb_crosshair.GC, p1->X, p1->Y, p2->X, p2->Y);
+			pcb_render->draw_line(pcb_crosshair.GC, p1->X, p1->Y, p2->X, p2->Y);
 		}
 	}
 }