/**
* gwy_vector_layer_draw:
* @layer: A vector data view layer.
* @drawable: A drawable to draw on.
* @target: Rendering target.
*
* Draws @layer on given drawable (which should be a #GwyDataView window).
**/
void
gwy_vector_layer_draw(GwyVectorLayer *layer,
GdkDrawable *drawable,
GwyRenderingTarget target)
{
GwyVectorLayerClass *layer_class = GWY_VECTOR_LAYER_GET_CLASS(layer);
GdkGC *gc = NULL;
g_assert(layer_class);
g_return_if_fail(layer_class->draw);
if (target == GWY_RENDERING_TARGET_PIXMAP_IMAGE) {
GwyDataView *data_view;
GdkGCValues gcvalues;
gint xres, yres, w, h;
gdouble zoom;
data_view = GWY_DATA_VIEW(GWY_DATA_VIEW_LAYER(layer)->parent);
g_return_if_fail(data_view);
gwy_data_view_get_pixel_data_sizes(data_view, &xres, &yres);
gdk_drawable_get_size(drawable, &w, &h);
zoom = sqrt(((gdouble)(w*h))/(xres*yres));
gc = gdk_gc_new(drawable);
gdk_gc_get_values(gc, &gcvalues);
gcvalues.line_width = ROUND(MAX(zoom, 1.0));
gcvalues.function = GDK_SET;
gdk_gc_set_values(gc, &gcvalues, GDK_GC_LINE_WIDTH | GDK_GC_FUNCTION);
GWY_SWAP(GdkGC*, layer->gc, gc);
}
static VALUE
rg_exposures_p(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return CBOOL2RVAL(val.graphics_exposures);
}
static VALUE
rg_subwindow_mode(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.subwindow_mode, GDK_TYPE_SUBWINDOW_MODE);
}
static VALUE
rg_clip_mask(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GOBJ2RVAL(val.clip_mask);
}
static VALUE
rg_stipple(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GOBJ2RVAL(val.stipple);
}
static VALUE
rg_fill(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.fill, GDK_TYPE_FILL);
}
static VALUE
rg_function(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.function, GDK_TYPE_FUNCTION);
}
static VALUE
rg_background(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return BOXED2RVAL(&val.background, GDK_TYPE_COLOR);
}
static VALUE
rg_clip_origin(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return rb_ary_new3(2, INT2NUM(val.clip_x_origin),
INT2NUM(val.clip_y_origin));
}
static VALUE
rg_line_attributes(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return rb_ary_new3(4, INT2NUM(val.line_width),
GENUM2RVAL(val.line_style, GDK_TYPE_LINE_STYLE),
GENUM2RVAL(val.cap_style, GDK_TYPE_CAP_STYLE),
GENUM2RVAL(val.join_style, GDK_TYPE_JOIN_STYLE));
}
gboolean Update(gpointer data)
{
int c,x,y,cx,cy;
GtkWidget *dc=GetWidget("drawingarea1");
GdkGC *gc=dc->style->fg_gc[GTK_WIDGET_STATE(dc)];
GdkGCValues gcsave;
gdk_gc_get_values(gc,&gcsave);
cx=dc->allocation.width/2;
cy=dc->allocation.height/2;
{ // clear the display
GdkColor c={0,0xffff,0xffff,0xffff};
gdk_gc_set_rgb_fg_color(gc,&c);
gdk_draw_rectangle(dc->window,gc,TRUE,0,0,dc->allocation.width,dc->allocation.height);
}
{ // Draw the listener
GdkColor c={0,0x8000,0x8000,0x8000};
gdk_gc_set_rgb_fg_color(gc,&c);
gdk_draw_arc(dc->window,gc,TRUE,cx-4,cy-4,8,8,0,360*64);
}
for (c=0;c<chanc;c++) {
// If the channel's playing then update it's position
if (BASS_ChannelIsActive(chans[c].channel)==BASS_ACTIVE_PLAYING) {
// Check if channel has reached the max distance
if (chans[c].pos.z>=MAXDIST || chans[c].pos.z<=-MAXDIST)
chans[c].vel.z=-chans[c].vel.z;
if (chans[c].pos.x>=MAXDIST || chans[c].pos.x<=-MAXDIST)
chans[c].vel.x=-chans[c].vel.x;
// Update channel position
chans[c].pos.z+=chans[c].vel.z*TIMERPERIOD/1000;
chans[c].pos.x+=chans[c].vel.x*TIMERPERIOD/1000;
BASS_ChannelSet3DPosition(chans[c].channel,&chans[c].pos,NULL,&chans[c].vel);
}
{ // Draw the channel position indicator
static GdkColor cols[2]={{0,0xffff,0xc000,0xc000},{0,0xffff,0,0}};
gdk_gc_set_rgb_fg_color(gc,&cols[chan==c]);
x=cx+(int)((cx-10)*chans[c].pos.x/MAXDIST);
y=cy-(int)((cy-10)*chans[c].pos.z/MAXDIST);
gdk_draw_arc(dc->window,gc,TRUE,x-4,y-4,8,8,0,360*64);
}
}
// Apply the 3D changes
BASS_Apply3D();
gdk_gc_set_values(gc,&gcsave,GDK_GC_FOREGROUND);
return TRUE;
}
GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
GdkColor *from, gfloat s)
{
GdkColor tmp_color;
GdkGCValues values;
shade (from, &tmp_color, s);
gdk_gc_get_values (gc, &values);
gdk_rgb_find_color (colormap, &tmp_color);
gdk_gc_set_foreground (gc, &tmp_color);
return values.foreground;
}
void SDC::SetLineWidth(int width) {
#ifdef __WXMSW__
wxColour c = m_pen.GetColour();
wxPen npen = wxPen(c, width == 1 ? 0 : width, wxSOLID);
(HPEN) SelectObject(m_gc, (HPEN)npen.GetResourceHandle());
m_pen = npen;
#else
GdkGCValues vals;
gdk_gc_get_values(m_gc, &vals);
vals.line_width = width == 1 ? 0 : width;
gdk_gc_set_values(m_gc, &vals, GDK_GC_LINE_WIDTH);
#endif
}
CAMLprim value ml_gdk_gc_get_values (value gc)
{
CAMLparam0();
GdkGCValues values;
CAMLlocal2(ret, tmp);
gdk_gc_get_values (GdkGC_val(gc), &values);
ret = alloc (18, 0);
tmp = Val_copy(values.foreground); Store_field(ret, 0, tmp);
tmp = Val_copy(values.background); Store_field(ret, 1, tmp);
if (values.font) {
tmp = ml_some(Val_GdkFont(values.font));
Store_field(ret, 2, tmp);
}
else
Store_field(ret, 2, Val_int(0));
Field(ret,3) = Val_function_type(values.function);
Field(ret,4) = Val_fill(values.fill);
if (values.tile) {
tmp = ml_some(Val_GdkPixmap(values.tile));
Store_field(ret, 5, tmp);
}
else
Store_field(ret, 5, Val_int(0));
if (values.stipple) {
tmp = ml_some(Val_GdkPixmap(values.stipple));
Store_field(ret, 6, tmp);
}
else
Store_field(ret, 6, Val_int(0));
if (values.clip_mask) {
tmp = ml_some(Val_GdkPixmap(values.clip_mask));
Store_field(ret, 7, tmp);
}
else
Store_field(ret, 7, Val_int(0));
Field(ret,8) = Val_subwindow_mode(values.subwindow_mode);
Field(ret,9) = Val_int(values.ts_x_origin);
Field(ret,10) = Val_int(values.ts_y_origin);
Field(ret,11) = Val_int(values.clip_x_origin);
Field(ret,12) = Val_int(values.clip_y_origin);
Field(ret,13) = Val_bool(values.graphics_exposures);
Field(ret,14) = Val_int(values.line_width);
Field(ret,15) = Val_line_style(values.line_style);
Field(ret,16) = Val_cap_style(values.cap_style);
Field(ret,17) = Val_join_style(values.join_style);
CAMLreturn(ret);
}
static void
gtk_plot_canvas_ellipse_select(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation area)
{
GdkGC *xor_gc = NULL;
GdkGCValues values;
gdk_gc_get_values(GTK_WIDGET(canvas)->style->fg_gc[0], &values);
values.function = GDK_INVERT;
values.foreground = GTK_WIDGET(canvas)->style->white;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
xor_gc = gdk_gc_new_with_values(GTK_WIDGET(canvas)->window,
&values,
GDK_GC_FOREGROUND |
GDK_GC_FUNCTION |
GDK_GC_SUBWINDOW);
gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
xor_gc,
FALSE,
area.x, area.y,
area.width, area.height);
draw_marker(canvas, xor_gc, area.x, area.y);
draw_marker(canvas, xor_gc, area.x, area.y + area.height);
draw_marker(canvas, xor_gc, area.x + area.width, area.y);
draw_marker(canvas, xor_gc, area.x + area.width, area.y + area.height);
if(area.height > DEFAULT_MARKER_SIZE * 2){
draw_marker(canvas, xor_gc, area.x, area.y + area.height / 2);
draw_marker(canvas, xor_gc, area.x + area.width,
area.y + area.height / 2);
}
if(area.width > DEFAULT_MARKER_SIZE * 2){
draw_marker(canvas, xor_gc, area.x + area.width / 2, area.y);
draw_marker(canvas, xor_gc, area.x + area.width / 2,
area.y + area.height);
}
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
gdk_draw_arc (GTK_WIDGET(canvas)->window, xor_gc,
FALSE,
roundint(area.x), roundint(area.y),
roundint(area.width), roundint(area.height), 0, 25000);
if(xor_gc) gdk_gc_unref(xor_gc);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkGraphics_clearRect
(JNIEnv *env, jobject obj, jint x, jint y, jint width, jint height)
{
struct graphics *g;
GdkGCValues saved;
GtkWidget *widget;
union widget_union w;
g = (struct graphics *) NSA_GET_PTR (env, obj);
gdk_threads_enter ();
if (!g)
{
gdk_threads_leave ();
return;
}
if (GDK_IS_WINDOW (g->drawable))
{
w.widget = &widget;
gdk_window_get_user_data (GDK_WINDOW (g->drawable), w.void_widget);
if (widget == NULL || !GTK_IS_EVENT_BOX (widget))
gdk_window_clear_area ((GdkWindow *) g->drawable,
x + g->x_offset, y + g->y_offset,
width, height);
}
else
{
gdk_gc_get_values (g->gc, &saved);
gdk_gc_set_foreground (g->gc, &(saved.background));
gdk_draw_rectangle (g->drawable, g->gc, TRUE,
x + g->x_offset, y + g->y_offset, width, height);
gdk_gc_set_foreground (g->gc, &(saved.foreground));
}
gdk_flush ();
gdk_threads_leave ();
}
static void
gerbv_gdk_draw_prim7(GdkPixmap *pixmap, GdkGC *gc, double *p,
double scale, gint x, gint y)
{
const int outside_dia_idx = 2;
const int inside_dia_idx = 3;
const int ch_thickness_idx = 4;
const int rotation_idx = 5;
const gint full_circle = 23360;
GdkGCValues gc_val;
int diameter, i;
GdkGC *local_gc = gdk_gc_new(pixmap);
GdkPoint point[4];
double ci_thickness = (p[outside_dia_idx] -
p[inside_dia_idx]) / 2.0;
gdk_gc_copy(local_gc, gc);
gdk_gc_set_line_attributes(local_gc,
(int)round(scale * ci_thickness),
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
/*
* Non filled circle
*/
diameter = (p[inside_dia_idx] + ci_thickness) * scale;
gdk_draw_arc(pixmap, local_gc, 0, x - diameter / 2, y - diameter / 2,
diameter, diameter, 0, full_circle);
/*
* Cross hair
*/
/* Calculate the end points of the crosshair */
/* GDK doesn't always remove all of the circle (round of error probably)
I extend the crosshair line with 2 (one pixel in each end) to make
sure all of the circle is removed with the crosshair */
for (i = 0; i < 4; i++) {
point[i].x = round((p[outside_dia_idx] / 2.0) * scale) + 2;
point[i].y = 0;
point[i] = rotate_point(point[i], p[rotation_idx] + 90 * i);
point[i].x += x;
point[i].y += y;
}
gdk_gc_set_line_attributes(local_gc,
(int)round(scale * p[ch_thickness_idx]),
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
/* The cross hair should "cut out" parts of the circle, hence inverse */
gdk_gc_get_values(local_gc, &gc_val);
if (gc_val.foreground.pixel == 1)
gc_val.foreground.pixel = 0;
else
gc_val.foreground.pixel = 1;
gdk_gc_set_foreground(local_gc, &(gc_val.foreground));
/* Draw the actual cross */
gdk_draw_line(pixmap, local_gc,
point[0].x, point[0].y, point[2].x, point[2].y);
gdk_draw_line(pixmap, local_gc,
point[1].x, point[1].y, point[3].x, point[3].y);
gdk_gc_unref(local_gc);
return;
} /* gerbv_gdk_draw_prim7 */
static GdkColor cl_gc_get_foreground(GdkGC *gc)
{
GdkGCValues values;
gdk_gc_get_values (gc, &values);
return values.foreground;
}
/* Retrieves the current values from a graphics context. */
int
clip_GDK_GCGETVALUES(ClipMachine * cm)
{
C_object *cgc = _fetch_co_arg(cm);
ClipVar *ret = RETPTR(cm);
GdkGCValues gcv;
C_object *cfont;
ClipVar *c = NEW(ClipVar);
C_widget *cw;
CHECKCOBJ(cgc,GDK_IS_GC(cgc));
gdk_gc_get_values(GDK_GC(cgc->object), &gcv);
memset(ret,0,sizeof(*ret)); _clip_map(cm,ret);
memset(c,0,sizeof(*c));
/* the foreground color. */
_clip_map(cm, c); _gdk_color_to_map(cm, gcv.foreground, c);
_clip_madd(cm, ret, HASH_FOREGROUND, c);
/* the background color. */
_clip_map(cm, c); _gdk_color_to_map(cm, gcv.background, c);
_clip_madd(cm, ret, HASH_BACKGROUND, c);
_clip_destroy(cm,c); free(c);
/* the default font */
cfont = _get_cobject(cm,gcv.font,GDK_OBJECT_FONT,
(coDestructor)gdk_object_font_destructor);
if (cfont) _clip_madd(cm, ret, HASH_FONT, &cfont->obj);
/* the bitwise operation used when drawing. */
_clip_mputn(cm,ret,HASH_FUNCTION,gcv.function);
/* the fill style. */
_clip_mputn(cm,ret,HASH_FILL,gcv.fill);
/* the tile pixmap. */
if (gcv.tile)
{
cw = _list_get_cwidget_by_data(cm,gcv.tile);
if (!cw)
{
GtkWidget *wxpm = gtk_pixmap_new(gcv.tile,NULL);
cw = _register_widget(cm,wxpm,NULL);
}
if (cw) _clip_madd( cm, ret, HASH_TILE, &cw->obj);
}
/* the stipple pixmap. */
if (gcv.stipple)
{
cw = _list_get_cwidget_by_data(cm,gcv.stipple);
if (!cw)
{
GtkWidget *wxpm = gtk_pixmap_new(gcv.stipple,NULL);
cw = _register_widget(cm,wxpm,NULL);
}
if (cw) _clip_madd( cm, ret, HASH_STIPPLE, &cw->obj);
}
/* the clip mask bitmap. */
if (gcv.clip_mask)
{
cw = _list_get_cwidget_by_data(cm,gcv.clip_mask);
if (!cw)
{
GtkWidget *wxpm = gtk_pixmap_new(gcv.clip_mask,NULL);
cw = _register_widget(cm,wxpm,NULL);
}
if (cw) _clip_madd( cm, ret, HASH_CLIPMASK, &cw->obj);
}
/* the subwindow mode. */
_clip_mputn(cm,ret,HASH_SUBWINDOWMODE,gcv.subwindow_mode);
/* the x origin of the tile or stipple. */
_clip_mputn(cm,ret,HASH_TSXORIGIN,gcv.ts_x_origin);
/* the y origin of the tile or stipple. */
_clip_mputn(cm,ret,HASH_TSYORIGIN,gcv.ts_y_origin);
/* the x origin of the clip mask. */
_clip_mputn(cm,ret,HASH_CLIPXORIGIN,gcv.clip_x_origin);
/* the y origin of the clip mask. */
_clip_mputn(cm,ret,HASH_CLIPYORIGIN,gcv.clip_y_origin);
/* whether graphics exposures are enabled. */
_clip_mputn(cm,ret,HASH_GRAPHICSEXPOSURES,gcv.graphics_exposures);
/* the line width */
_clip_mputn(cm,ret,HASH_LINEWIDTH,gcv.line_width);
/* the way dashed lines are drawn */
_clip_mputn(cm,ret,HASH_LINESTYLE,gcv.line_style);
/* the way the ends of lines are drawn */
_clip_mputn(cm,ret,HASH_CAPSTYLE,gcv.cap_style);
/* the way joins between lines are drawn */
_clip_mputn(cm,ret,HASH_JOINSTYLE,gcv.join_style);
return 0;
err:
return 1;
}
static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height,
CLRectangle *r, CLCornerSide corner)
{
GdkColor *color;
GdkColor aacolor; /* anti-aliasing color */
GdkGCValues values;
GdkColor tmp;
GdkColor *bgcolor;
int x1;
int y1;
if (r->corners[corner] == CL_CORNER_NONE)
return;
color = cl_get_gradient_corner_color (r, corner);
gdk_gc_get_values (r->bordergc, &values);
if (color == NULL)
{
tmp = values.foreground;
gdk_colormap_query_color (gtk_widget_get_colormap(widget), values.foreground.pixel, &tmp);
color = &tmp;
}
bgcolor = get_parent_bgcolor(widget);
if (bgcolor == NULL)
{
bgcolor = color;
}
blend (style->colormap, bgcolor, color, &aacolor, 70);
if (r->corners[corner] == CL_CORNER_ROUND)
{
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width - 2;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height - 2;
gdk_gc_set_foreground (r->bordergc, color);
gdk_draw_point (window, r->bordergc, x1, y1);
gdk_gc_set_foreground (r->bordergc, &aacolor);
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width-2;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
gdk_draw_point (window, r->bordergc, x1, y1);
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height-2;
gdk_draw_point (window, r->bordergc, x1, y1);
}
else if (r->corners[corner] == CL_CORNER_NARROW)
{
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
gdk_gc_set_foreground (r->bordergc, &aacolor);
gdk_draw_point (window, r->bordergc, x1, y1);
}
gdk_gc_set_foreground (r->bordergc, &values.foreground);
}
/*
* Convert a gerber image to a GDK clip mask to be used when creating pixmap
*/
int
draw_gdk_image_to_pixmap(GdkPixmap **pixmap, gerbv_image_t *image,
double scale, double trans_x, double trans_y,
gchar drawMode,
gerbv_selection_info_t *selectionInfo, gerbv_render_info_t *renderInfo,
gerbv_user_transformation_t transform)
{
GdkGC *gc = gdk_gc_new(*pixmap);
GdkGC *pgc = gdk_gc_new(*pixmap);
GdkGCValues gc_values;
struct gerbv_net *net;
gerbv_netstate_t *oldState;
gerbv_layer_t *oldLayer;
gint x1, y1, x2, y2;
glong xlong1, ylong1, xlong2, ylong2;
int p1, p2;
int cir_width = 0, cir_height = 0;
int cp_x = 0, cp_y = 0;
GdkColor transparent, opaque;
gerbv_polarity_t polarity;
gdouble tempX,tempY;
gdouble minX=0,minY=0,maxX=0,maxY=0;
if (transform.inverted) {
if (image->info->polarity == GERBV_POLARITY_POSITIVE)
polarity = GERBV_POLARITY_NEGATIVE;
else
polarity = GERBV_POLARITY_POSITIVE;
} else {
polarity = image->info->polarity;
}
if (drawMode == DRAW_SELECTIONS)
polarity = GERBV_POLARITY_POSITIVE;
gboolean useOptimizations = TRUE;
// if the user is using any transformations for this layer, then don't bother using rendering
// optimizations
if ((fabs(transform.translateX) > 0.00001) ||
(fabs(transform.translateY) > 0.00001) ||
(fabs(transform.scaleX - 1) > 0.00001) ||
(fabs(transform.scaleY - 1) > 0.00001) ||
(fabs(transform.rotation) > 0.00001) ||
transform.mirrorAroundX || transform.mirrorAroundY)
useOptimizations = FALSE;
// calculate the transformation matrix for the user_transformation options
cairo_matrix_t fullMatrix, scaleMatrix;
cairo_matrix_init (&fullMatrix, 1, 0, 0, 1, 0, 0);
cairo_matrix_init (&scaleMatrix, 1, 0, 0, 1, 0, 0);
cairo_matrix_translate (&fullMatrix, trans_x, trans_y);
cairo_matrix_scale (&fullMatrix, scale, scale);
cairo_matrix_scale (&scaleMatrix, scale, scale);
/* offset image */
cairo_matrix_translate (&fullMatrix, transform.translateX, -1*transform.translateY);
// don't use mirroring for the scale matrix
gdouble scaleX = transform.scaleX;
gdouble scaleY = -1*transform.scaleY;
cairo_matrix_scale (&scaleMatrix, scaleX, -1*scaleY);
if (transform.mirrorAroundX)
scaleY *= -1;
if (transform.mirrorAroundY)
scaleX *= -1;
cairo_matrix_scale (&fullMatrix, scaleX, scaleY);
/* do image rotation */
cairo_matrix_rotate (&fullMatrix, transform.rotation);
//cairo_matrix_rotate (&scaleMatrix, transform.rotation);
/* do image rotation */
cairo_matrix_rotate (&fullMatrix, image->info->imageRotation);
if (useOptimizations) {
minX = renderInfo->lowerLeftX;
minY = renderInfo->lowerLeftY;
maxX = renderInfo->lowerLeftX + (renderInfo->displayWidth /
renderInfo->scaleFactorX);
maxY = renderInfo->lowerLeftY + (renderInfo->displayHeight /
renderInfo->scaleFactorY);
}
if (image == NULL || image->netlist == NULL) {
/*
* Destroy GCs before exiting
*/
gdk_gc_unref(gc);
gdk_gc_unref(pgc);
return 0;
}
/* Set up the two "colors" we have */
opaque.pixel = 0; /* opaque will not let color through */
transparent.pixel = 1; /* transparent will let color through */
/*
* Clear clipmask and set draw color depending image on image polarity
*/
if (polarity == GERBV_POLARITY_NEGATIVE) {
gdk_gc_set_foreground(gc, &transparent);
gdk_draw_rectangle(*pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_foreground(gc, &opaque);
} else {
gdk_gc_set_foreground(gc, &opaque);
gdk_draw_rectangle(*pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_foreground(gc, &transparent);
}
oldLayer = image->layers;
oldState = image->states;
for (net = image->netlist->next ; net != NULL; net = gerbv_image_return_next_renderable_object(net)) {
int repeat_X=1, repeat_Y=1;
double repeat_dist_X=0.0, repeat_dist_Y=0.0;
int repeat_i, repeat_j;
/*
* If step_and_repeat (%SR%) used, repeat the drawing;
*/
repeat_X = net->layer->stepAndRepeat.X;
repeat_Y = net->layer->stepAndRepeat.Y;
repeat_dist_X = net->layer->stepAndRepeat.dist_X;
repeat_dist_Y = net->layer->stepAndRepeat.dist_Y;
/* check if this is a new netstate */
if (net->state != oldState){
/* it's a new state, so recalculate the new transformation matrix
for it */
draw_gdk_apply_netstate_transformation (&fullMatrix, &scaleMatrix, net->state);
oldState = net->state;
}
/* check if this is a new layer */
/* for now, only do layer rotations in GDK rendering */
if (net->layer != oldLayer){
cairo_matrix_rotate (&fullMatrix, net->layer->rotation);
oldLayer = net->layer;
}
if (drawMode == DRAW_SELECTIONS) {
int i;
gboolean foundNet = FALSE;
for (i=0; i<selectionInfo->selectedNodeArray->len; i++){
gerbv_selection_item_t sItem = g_array_index (selectionInfo->selectedNodeArray,
gerbv_selection_item_t, i);
if (sItem.net == net)
foundNet = TRUE;
}
if (!foundNet)
continue;
}
for(repeat_i = 0; repeat_i < repeat_X; repeat_i++) {
for(repeat_j = 0; repeat_j < repeat_Y; repeat_j++) {
double sr_x = repeat_i * repeat_dist_X;
double sr_y = repeat_j * repeat_dist_Y;
if ((useOptimizations)&&((net->boundingBox.right+sr_x < minX)
|| (net->boundingBox.left+sr_x > maxX)
|| (net->boundingBox.top+sr_y < minY)
|| (net->boundingBox.bottom+sr_y > maxY))) {
continue;
}
/*
* If circle segment, scale and translate that one too
*/
if (net->cirseg) {
tempX = net->cirseg->width;
tempY = net->cirseg->height;
cairo_matrix_transform_point (&scaleMatrix, &tempX, &tempY);
cir_width = (int)round(tempX);
cir_height = (int)round(tempY);
tempX = net->cirseg->cp_x;
tempY = net->cirseg->cp_y;
cairo_matrix_transform_point (&fullMatrix, &tempX, &tempY);
cp_x = (int)round(tempX);
cp_y = (int)round(tempY);
}
/*
* Set GdkFunction depending on if this (gerber) layer is inverted
* and allow for the photoplot being negative.
*/
gdk_gc_set_function(gc, GDK_COPY);
if ((net->layer->polarity == GERBV_POLARITY_CLEAR) != (polarity == GERBV_POLARITY_NEGATIVE))
gdk_gc_set_foreground(gc, &opaque);
else
gdk_gc_set_foreground(gc, &transparent);
/*
* Polygon Area Fill routines
*/
switch (net->interpolation) {
case GERBV_INTERPOLATION_PAREA_START :
draw_gdk_render_polygon_object (net,image,sr_x,sr_y,&fullMatrix,
&scaleMatrix,gc,pgc,pixmap);
continue;
/* make sure we completely skip over any deleted nodes */
case GERBV_INTERPOLATION_DELETED:
continue;
default :
break;
}
/*
* If aperture state is off we allow use of undefined apertures.
* This happens when gerber files starts, but hasn't decided on
* which aperture to use.
*/
if (image->aperture[net->aperture] == NULL) {
/* Commenting this out since it gets emitted every time you click on the screen
if (net->aperture_state != GERBV_APERTURE_STATE_OFF)
GERB_MESSAGE("Aperture D%d is not defined\n", net->aperture);
*/
continue;
}
/*
* Scale points with window scaling and translate them
*/
tempX = net->start_x + sr_x;
tempY = net->start_y + sr_y;
cairo_matrix_transform_point (&fullMatrix, &tempX, &tempY);
xlong1 = (int)round(tempX);
ylong1 = (int)round(tempY);
tempX = net->stop_x + sr_x;
tempY = net->stop_y + sr_y;
cairo_matrix_transform_point (&fullMatrix, &tempX, &tempY);
xlong2 = (int)round(tempX);
ylong2 = (int)round(tempY);
/* if the object is way outside our view window, just skip over it in order
to eliminate some GDK clipping problems at high zoom levels */
if ((xlong1 < -10000) && (xlong2 < -10000))
continue;
if ((ylong1 < -10000) && (ylong2 < -10000))
continue;
if ((xlong1 > 10000) && (xlong2 > 10000))
continue;
if ((ylong1 > 10000) && (ylong2 > 10000))
continue;
if (xlong1 > G_MAXINT) x1 = G_MAXINT;
else if (xlong1 < G_MININT) x1 = G_MININT;
else x1 = (int)xlong1;
if (xlong2 > G_MAXINT) x2 = G_MAXINT;
else if (xlong2 < G_MININT) x2 = G_MININT;
else x2 = (int)xlong2;
if (ylong1 > G_MAXINT) y1 = G_MAXINT;
else if (ylong1 < G_MININT) y1 = G_MININT;
else y1 = (int)ylong1;
if (ylong2 > G_MAXINT) y2 = G_MAXINT;
else if (ylong2 < G_MININT) y2 = G_MININT;
else y2 = (int)ylong2;
switch (net->aperture_state) {
case GERBV_APERTURE_STATE_ON :
tempX = image->aperture[net->aperture]->parameter[0];
cairo_matrix_transform_point (&scaleMatrix, &tempX, &tempY);
p1 = (int)round(tempX);
// p1 = (int)round(image->aperture[net->aperture]->parameter[0] * scale);
if (image->aperture[net->aperture]->type == GERBV_APTYPE_RECTANGLE)
gdk_gc_set_line_attributes(gc, p1,
GDK_LINE_SOLID,
GDK_CAP_PROJECTING,
GDK_JOIN_MITER);
else
gdk_gc_set_line_attributes(gc, p1,
GDK_LINE_SOLID,
GDK_CAP_ROUND,
GDK_JOIN_MITER);
switch (net->interpolation) {
case GERBV_INTERPOLATION_x10 :
case GERBV_INTERPOLATION_LINEARx01 :
case GERBV_INTERPOLATION_LINEARx001 :
GERB_MESSAGE(_("Linear != x1\n"));
gdk_gc_set_line_attributes(gc, p1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_ROUND,
GDK_JOIN_MITER);
gdk_draw_line(*pixmap, gc, x1, y1, x2, y2);
gdk_gc_set_line_attributes(gc, p1,
GDK_LINE_SOLID,
GDK_CAP_ROUND,
GDK_JOIN_MITER);
break;
case GERBV_INTERPOLATION_LINEARx1 :
if (image->aperture[net->aperture]->type != GERBV_APTYPE_RECTANGLE)
gdk_draw_line(*pixmap, gc, x1, y1, x2, y2);
else {
gint dx, dy;
GdkPoint poly[6];
tempX = image->aperture[net->aperture]->parameter[0]/2;
tempY = image->aperture[net->aperture]->parameter[1]/2;
cairo_matrix_transform_point (&scaleMatrix, &tempX, &tempY);
dx = (int)round(tempX);
dy = (int)round(tempY);
if(x1 > x2) dx = -dx;
if(y1 > y2) dy = -dy;
poly[0].x = x1 - dx; poly[0].y = y1 - dy;
poly[1].x = x1 - dx; poly[1].y = y1 + dy;
poly[2].x = x2 - dx; poly[2].y = y2 + dy;
poly[3].x = x2 + dx; poly[3].y = y2 + dy;
poly[4].x = x2 + dx; poly[4].y = y2 - dy;
poly[5].x = x1 + dx; poly[5].y = y1 - dy;
gdk_draw_polygon(*pixmap, gc, 1, poly, 6);
}
break;
case GERBV_INTERPOLATION_CW_CIRCULAR :
case GERBV_INTERPOLATION_CCW_CIRCULAR :
gerbv_gdk_draw_arc(*pixmap, gc, cp_x, cp_y, cir_width, cir_height,
net->cirseg->angle1, net->cirseg->angle2);
break;
default :
break;
}
break;
case GERBV_APERTURE_STATE_OFF :
break;
case GERBV_APERTURE_STATE_FLASH :
tempX = image->aperture[net->aperture]->parameter[0];
tempY = image->aperture[net->aperture]->parameter[1];
cairo_matrix_transform_point (&scaleMatrix, &tempX, &tempY);
p1 = (int)round(tempX);
p2 = (int)round(tempY);
tempX = image->aperture[net->aperture]->parameter[2];
cairo_matrix_transform_point (&scaleMatrix, &tempX, &tempY);
switch (image->aperture[net->aperture]->type) {
case GERBV_APTYPE_CIRCLE :
gerbv_gdk_draw_circle(*pixmap, gc, TRUE, x2, y2, p1);
/*
* If circle has an inner diameter we must remove
* that part of the circle to make a hole in it.
* We should actually support square holes too,
* but due to laziness I don't.
*/
if (p2) {
gdk_gc_get_values(gc, &gc_values);
if (gc_values.foreground.pixel == opaque.pixel) {
gdk_gc_set_foreground(gc, &transparent);
gerbv_gdk_draw_circle(*pixmap, gc, TRUE, x2, y2, p2);
gdk_gc_set_foreground(gc, &opaque);
} else {
gdk_gc_set_foreground(gc, &opaque);
gerbv_gdk_draw_circle(*pixmap, gc, TRUE, x2, y2, p2);
gdk_gc_set_foreground(gc, &transparent);
}
}
break;
case GERBV_APTYPE_RECTANGLE:
gerbv_gdk_draw_rectangle(*pixmap, gc, TRUE, x2, y2, p1, p2);
break;
case GERBV_APTYPE_OVAL :
gerbv_gdk_draw_oval(*pixmap, gc, TRUE, x2, y2, p1, p2);
break;
case GERBV_APTYPE_POLYGON :
gerbv_gdk_draw_circle(*pixmap, gc, TRUE, x2, y2, p1);
break;
case GERBV_APTYPE_MACRO :
gerbv_gdk_draw_amacro(*pixmap, gc,
image->aperture[net->aperture]->simplified,
scale, x2, y2);
break;
default :
GERB_MESSAGE(_("Unknown aperture type\n"));
return 0;
}
break;
default :
GERB_MESSAGE(_("Unknown aperture state\n"));
return 0;
}
}
}
}
/*
* Destroy GCs before exiting
*/
gdk_gc_unref(gc);
gdk_gc_unref(pgc);
return 1;
} /* image2pixmap */
int GCcreatewidget(Gwidget_t * parent, Gwidget_t * widget,
int attrn, Gwattr_t * attrp)
{
PIXsize_t ps;
int width, height;
int ai, i;
GdkGCValues gcv;
int r, g, b, color;
GdkColor *cp;
if (!parent) {
Gerr(POS, G_ERRNOPARENTWIDGET);
return -1;
}
canvas = widget;
WCU->func = NULL;
WCU->needredraw = FALSE;
WCU->buttonsdown = 0;
WCU->bstate[0] = WCU->bstate[1] = WCU->bstate[2] = 0;
ps.x = ps.y = MINCWSIZE;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRSIZE:
GETSIZE(attrp[ai].u.s, ps, MINCWSIZE);
break;
case G_ATTRBORDERWIDTH:
break;
#ifdef FEATURE_GMAP
case G_ATTRMODE:
if (Strcmp("gmap", attrp[ai].u.t) == 0) {
gmapmode = TRUE;
} else {
Gerr(POS, G_ERRBADATTRVALUE, attrp[ai].u.t);
return -1;
}
break;
#endif
case G_ATTRCURSOR:
break;
case G_ATTRCOLOR:
break;
case G_ATTRVIEWPORT:
break;
case G_ATTRWINDOW:
break;
case G_ATTRWINDOWID:
Gerr(POS, G_ERRCANNOTSETATTR2, "windowid");
return -1;
case G_ATTREVENTCB:
WCU->func = (Gcanvascb) attrp[ai].u.func;
break;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr(POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
/* XtSetValues (widget->w, argp, argn); */
widget->w = gtk_drawing_area_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(parent->w),
widget->w);
gtk_drawing_area_size(GTK_DRAWING_AREA(widget->w), ps.x, ps.y);
gtk_widget_add_events(widget->w, GDK_ALL_EVENTS_MASK);
gtk_signal_connect(GTK_OBJECT(widget->w), "key_release_event",
GTK_SIGNAL_FUNC(Gcwkeyaction), NULL);
gtk_signal_connect(GTK_OBJECT(widget->w), "key_press_event",
GTK_SIGNAL_FUNC(Gcwkeyaction), NULL);
gtk_signal_connect(G_OBJECT(widget->w), "button_press_event",
GTK_SIGNAL_FUNC(Gcwbutaction), NULL);
gtk_signal_connect(G_OBJECT(widget->w), "button_release_event",
GTK_SIGNAL_FUNC(Gcwbutaction), NULL);
gtk_signal_connect(G_OBJECT(widget->w), "visibility_notify_event",
GTK_SIGNAL_FUNC(cweventhandler), NULL);
gtk_signal_connect(G_OBJECT(widget->w), "expose_event",
GTK_SIGNAL_FUNC(exposeeventhandler), NULL);
gtk_signal_connect(G_OBJECT(widget->w), "motion_notify_event",
GTK_SIGNAL_FUNC(cweventhandler), NULL);
gtk_widget_show(widget->w);
gtk_widget_show(parent->w);
GC = gdk_gc_new(widget->w->window);
WCU->cmap = gdk_colormap_get_system();
WCU->colors[0].color.pixel = WCU->colors[1].color.pixel = 1000000;
if (WCU->colors[0].color.pixel == 1000000) {
gdk_gc_get_values(GC, &gcv);
WCU->colors[0].color = gcv.background;
}
if (WCU->colors[1].color.pixel == 1000000) {
gdk_gc_get_values(GC, &gcv);
WCU->colors[1].color = gcv.foreground;
}
WCU->colors[0].color.red = 65535;
WCU->colors[0].color.green = 65535;
WCU->colors[0].color.blue = 65535;
WCU->colors[1].color.red = 0;
WCU->colors[1].color.green = 0;
WCU->colors[1].color.blue = 0;
gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[0].color, FALSE,
TRUE);
WCU->colors[0].inuse = TRUE;
gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[1].color, FALSE,
TRUE);
WCU->colors[1].inuse = TRUE;
WCU->allocedcolor[0] = WCU->allocedcolor[1] = FALSE;
for (i = 2; i < G_MAXCOLORS; i++)
WCU->colors[i].inuse = FALSE;
WCU->gattr.color = 1;
/* gdk_gc_set_background(GC, widget->w->style->white_gc);
gdk_gc_set_foreground(GC, widget->w->style->black_gc);
*/
WCU->gattr.width = 0;
WCU->gattr.mode = 0;
WCU->gattr.fill = 0;
WCU->gattr.style = 0;
WCU->defgattr = WCU->gattr;
WCU->font = NULL;
WCU->wrect.o.x = 0.0, WCU->wrect.o.y = 0.0;
WCU->wrect.c.x = 1.0, WCU->wrect.c.y = 1.0;
WCU->vsize.x = ps.x, WCU->vsize.y = ps.y;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRCURSOR:
if (Strcmp(attrp[ai].u.t, "default") == 0) {
curcursori = -1;
}
break;
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color < 0 || color > G_MAXCOLORS) {
Gerr(POS, G_ERRBADCOLORINDEX, color);
return -1;
}
r = attrp[ai].u.c.r * 257;
g = attrp[ai].u.c.g * 257;
b = attrp[ai].u.c.b * 257;
cp = &WCU->colors[color].color;
if (WCU->colors[color].inuse)
if (cp->red != r || cp->green != g || cp->blue != b)
if (color > 1 || WCU->allocedcolor[color])
gdk_colormap_free_colors(WCU->cmap, cp, 1);
cp->red = r, cp->green = g, cp->blue = b;
if (gdk_colormap_alloc_color(WCU->cmap, cp, TRUE, TRUE)) {
WCU->colors[color].inuse = TRUE;
if (color <= 1)
WCU->allocedcolor[color] = TRUE;
}
cp->red = r, cp->green = g, cp->blue = b;
if (color == WCU->gattr.color)
WCU->gattr.color = -1;
break;
case G_ATTRVIEWPORT:
WCU->vsize.x = (int) (attrp[ai].u.s.x + 0.5);
WCU->vsize.y = (int) (attrp[ai].u.s.y + 0.5);
break;
case G_ATTRWINDOW:
WCU->wrect = attrp[ai].u.r;
break;
}
}
adjustclip(widget);
return 0;
}
void
draw_check_mark(GdkWindow * window,
GdkGC * gc,
GdkRectangle * area,
gint x,
gint y,
gint width,
gint height,
gint check_style)
{
switch (check_style) {
case FAST_CHECK : /* most common style */
gdk_draw_line(window, gc, x, y+height-1, x, y+(height/2)-1);
gdk_draw_line(window, gc, x+1, y+height-1, x+1, y+(height/2)-1);
gdk_draw_line(window, gc, x+1, y+height-1, x+width, y - 1);
gdk_draw_line(window, gc, x, y+height-1, x+width, y);
break;
case SLOPPY_CHECK : /* default theme style, not done so just fall through*/
case CLEAN_CHECK :/* classic redmond style */
x+=1;
y+=1;
width-=2;
height-=2;
/* short diagonal */
gdk_draw_line(window, gc, x+0, y+height-5, x+0, y+height-2);/* Left Line */
gdk_draw_line(window, gc, x+1, y+height-4, x+1, y+height-1);/* Right Line */
/* Long Diagonal */
gdk_draw_line(window, gc, x+2, y+height-3, x+width-1, y+0);/* Top Line */
gdk_draw_line(window, gc, x+2, y+height-2, x+width-1, y+1);/* Center Line */
gdk_draw_line(window, gc, x+2, y+height-1, x+width-1, y+2);/* Bottom Line */
break;
case X_CHECK : /* common(default?) style in kde themes */
{
GdkGC * line_gc = NULL;
if (width>=16)
{
GdkGCValues gc_vals;
gint off_1, off_2, off_3;
gint line_width = ceil(((width + 1)/5));
if (!(line_width % 2)) line_width -= 1;
gdk_gc_get_values(gc, &gc_vals);
gc_vals.line_width = line_width;
gc_vals.cap_style = GDK_CAP_ROUND;
off_2 = gc_vals.line_width;
off_1 = off_2 - 1;
off_3 = off_2 + 1;
line_gc = gdk_gc_new_with_values(window, &gc_vals, GDK_GC_FOREGROUND | GDK_GC_BACKGROUND | GDK_GC_FUNCTION |
GDK_GC_CLIP_MASK | GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN | GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE |
GDK_GC_CAP_STYLE);
/* Backward Diagonal */
gdk_draw_line(window, line_gc, x+off_1, y+off_1, x+width-off_2, y+height-off_2);/* Center Line */
/* Forward Diagonal */
gdk_draw_line(window, line_gc, x+off_1, y+height - off_2, x+width-off_2, y+off_1);/* Center Line */
gdk_gc_unref(line_gc);
} else {
/* Backward Diagonal */
if (width>=7)
gdk_draw_line(window, gc, x+2, y+1, x+width-2, y+height-3);/* Top Line */
gdk_draw_line(window, gc, x+1, y+1, x+width-2, y+height-2);/* Center Line */
if (width>=7)
gdk_draw_line(window, gc, x+1, y+2, x+width-3, y+height-2);/* Bottom Line */
/* Forward Diagonal */
if (width>=7)
gdk_draw_line(window, gc, x+1, y+height-3, x+width-3, y+1);/* Top Line */
gdk_draw_line(window, gc, x+1, y+height - 2, x+width-2, y+1);/* Center Line */
if (width>=7)
gdk_draw_line(window, gc, x+2, y+height - 2, x+width-2, y+2);/* Bottom Line */
}
}
break;
case BLOCK_CHECK : /* square check style, like mist */
gdk_draw_rectangle(window, gc, TRUE, x+1, y+1, width-2, height-2);
break;
case CIRCLE_CHECK : /* round check style, like mist, but with circles */
gdk_draw_arc(window, gc, TRUE, x + width / 4, y + height / 4, width / 2 + 1, height / 2 + 1, 0, 360*64);
gdk_draw_arc(window, gc, FALSE, x + width / 4, y + height / 4, width / 2 + 1, height / 2 + 1, 0, 360*64);
break;
case DIAMOND_CHECK : /* diamond check style, like mist, but with diamonds */
{
GdkPoint * points = g_new(GdkPoint, 5);
x+=1;
y+=1;
width-=2;
height-=2;
points[0].x = x + width/2;
points[0].y = y;
points[1].x = x + width;
points[1].y = y + height/2;
points[2].x = x + width/2;
points[2].y = y + height;
points[3].x = x;
points[3].y = y + height/2;
points[4].x = x + width/2;
points[4].y = y;
gdk_draw_polygon(window, gc, TRUE, points, 5);
gdk_draw_polygon(window, gc, FALSE, points, 5);
g_free(points);
}
break;
case XPM_CHECK : /* custom check in xpm format */
break;
case NO_CHECK :
default :
return;
}
}
GdkFunction vik_gc_get_function ( GdkGC *gc )
{
static GdkGCValues values;
gdk_gc_get_values ( gc, &values );
return values.function;
}
void vik_gc_get_fg_color ( GdkGC *gc, GdkColor *dest )
{
static GdkGCValues values;
gdk_gc_get_values ( gc, &values );
gdk_colormap_query_color ( gdk_colormap_get_system(), values.foreground.pixel, dest );
}
