void
draw_preview_wireframe (void)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_INVERT);
pw = PREVIEW_WIDTH * mapvals.zoom;
ph = PREVIEW_HEIGHT * mapvals.zoom;
startx = (PREVIEW_WIDTH - pw) / 2;
starty = (PREVIEW_HEIGHT - ph) / 2;
clear_wireframe ();
draw_wireframe (startx, starty, pw, ph);
}
gboolean gaugebar_expose (GtkWidget *widget, GdkEventExpose *event,
gpointer data)
{
GList* it;
GdkGC *gc;
GdkColor black = {0, 0, 0, 0};
PangoLayout *layout;
GtkDrawingArea *gaugebar = GTK_DRAWING_AREA (widget);
g_return_val_if_fail (gaugebar != NULL, FALSE);
GAUGELIST *gl = (GAUGELIST *) g_object_get_data (GTK_OBJECT (gaugebar),
"gaugelist");
g_return_val_if_fail (gl != NULL, FALSE);
int width = widget->allocation.width;
int height = widget->allocation.height;
gc = gdk_gc_new (widget->window);
// clear the widget
GdkColor bgc = gtk_widget_get_style (
GTK_WIDGET (gl->sess->tab))->bg[GTK_STATE_NORMAL];
gdk_gc_set_rgb_bg_color (gc, &bgc);
gdk_gc_set_rgb_fg_color (gc, &bgc);
gdk_gc_set_fill (gc, GDK_SOLID);
gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0, width+1, height+1);
// paint the new widget ...
int X = 2;
for (it = g_list_first (gl->list); it; it = g_list_next (it))
{
GAUGE *g = (GAUGE *) it->data;
// paint the text
int xd;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (gaugebar),
g->variable);
gdk_gc_set_rgb_fg_color (gc, &black);
gdk_draw_layout (widget->window, gc, X, 2, layout);
pango_layout_get_pixel_size (layout, &xd, NULL);
X += xd + 2;
// paint the gauge
int val = g->cur * 100 / (g->max ? g->max : 100);
if (val > 100) val = 100;
gdk_gc_set_line_attributes (gc, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST,
GDK_JOIN_MITER);
gdk_gc_set_rgb_fg_color (gc, &black);
gdk_draw_rectangle (widget->window, gc, FALSE, X, 2, 102, 20);
if (val) {
gdk_gc_set_rgb_fg_color (gc, &g->color);
gdk_draw_rectangle (widget->window, gc, TRUE, X+1, 3, val+1, 19);
}
g_object_unref (layout);
X += 110;
}
}
static void
clear_light_marker (void)
{
/* Restore background if it has been saved */
/* ======================================= */
if (backbuf.image != NULL)
{
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
gdk_draw_image (previewarea->window, gc,
backbuf.image,
0, 0,
backbuf.x, backbuf.y,
backbuf.w, backbuf.h);
g_object_unref (backbuf.image);
backbuf.image = NULL;
}
}
void
draw_preview_image (gboolean recompute)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
compute_preview_rectangle (&startx, &starty, &pw, &ph);
if (recompute)
{
GdkDisplay *display = gtk_widget_get_display (previewarea);
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
compute_preview (startx, starty, pw, ph);
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
gdk_flush ();
/* if we recompute, clear backbuf, so we don't
* restore the wrong bitmap */
if (backbuf.image != NULL)
{
g_object_unref (backbuf.image);
backbuf.image = NULL;
}
}
gdk_draw_rgb_image (previewarea->window, gc,
0, 0, PREVIEW_WIDTH, PREVIEW_HEIGHT,
GDK_RGB_DITHER_MAX, preview_rgb_data,
3 * PREVIEW_WIDTH);
/* draw symbols if enabled in UI */
if (mapvals.interactive_preview)
{
draw_handles ();
}
}
static void
draw_light_marker (gint xpos,
gint ypos)
{
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0x0;
color.green = 0x4000;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
if (mapvals.lightsource.type == POINT_LIGHT)
{
lightx = xpos;
lighty = ypos;
/* Save background */
/* =============== */
backbuf.x = lightx - 7;
backbuf.y = lighty - 7;
backbuf.w = 14;
backbuf.h = 14;
/* X doesn't like images that's outside a window, make sure */
/* we get the backbuffer image from within the boundaries */
/* ======================================================== */
if (backbuf.x < 0)
backbuf.x = 0;
else if ((backbuf.x + backbuf.w) > PREVIEW_WIDTH)
backbuf.w = (PREVIEW_WIDTH - backbuf.x);
if (backbuf.y < 0)
backbuf.y = 0;
else if ((backbuf.y + backbuf.h) > PREVIEW_HEIGHT)
backbuf.h = (PREVIEW_WIDTH - backbuf.y);
backbuf.image = gdk_drawable_get_image (previewarea->window,
backbuf.x, backbuf.y,
backbuf.w, backbuf.h);
gdk_draw_arc (previewarea->window, gc,
TRUE,
lightx - 7, lighty - 7, 14, 14,
0, 360 * 64);
}
}
/* gdk_cursor_new_from_pixmap is broken on Windows.
this is a workaround using gdk_cursor_new_from_pixbuf. */
GdkCursor* fixed_gdk_cursor_new_from_pixmap(GdkPixmap *source, GdkPixmap *mask,
const GdkColor *fg, const GdkColor *bg,
gint x, gint y)
{
GdkPixmap *rgb_pixmap;
GdkGC *gc;
GdkPixbuf *rgb_pixbuf, *rgba_pixbuf;
GdkCursor *cursor;
int width, height;
/* HACK! It seems impossible to work with RGBA pixmaps directly in
GDK-Win32. Instead we pick some third color, different from fg
and bg, and use that as the 'transparent color'. We do this using
colors_too_similar (see above) because two colors could be
unequal in GdkColor's 16-bit/sample, but equal in GdkPixbuf's
8-bit/sample. */
GdkColor candidates[3] = {{0,65535,0,0}, {0,0,65535,0}, {0,0,0,65535}};
GdkColor *trans = &candidates[0];
if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
trans = &candidates[1];
if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
trans = &candidates[2];
}
} /* trans is now guaranteed to be unique from fg and bg */
/* create an empty pixmap to hold the cursor image */
gdk_drawable_get_size(source, &width, &height);
rgb_pixmap = gdk_pixmap_new(NULL, width, height, 24);
/* blit the bitmaps defining the cursor onto a transparent background */
gc = gdk_gc_new(rgb_pixmap);
gdk_gc_set_fill(gc, GDK_SOLID);
gdk_gc_set_rgb_fg_color(gc, trans);
gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
gdk_gc_set_fill(gc, GDK_OPAQUE_STIPPLED);
gdk_gc_set_stipple(gc, source);
gdk_gc_set_clip_mask(gc, mask);
gdk_gc_set_rgb_fg_color(gc, fg);
gdk_gc_set_rgb_bg_color(gc, bg);
gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
gdk_gc_unref(gc);
/* create a cursor out of the created pixmap */
rgb_pixbuf = gdk_pixbuf_get_from_drawable(
NULL, rgb_pixmap, gdk_colormap_get_system(), 0, 0, 0, 0, width, height);
gdk_pixmap_unref(rgb_pixmap);
rgba_pixbuf = gdk_pixbuf_add_alpha(
rgb_pixbuf, TRUE, trans->red, trans->green, trans->blue);
gdk_pixbuf_unref(rgb_pixbuf);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), rgba_pixbuf, x, y);
gdk_pixbuf_unref(rgba_pixbuf);
return cursor;
}
void
draw_preview_image (gint docompute)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
linetab[0].x1 = -1;
pw = PREVIEW_WIDTH * mapvals.zoom;
ph = PREVIEW_HEIGHT * mapvals.zoom;
startx = (PREVIEW_WIDTH - pw) / 2;
starty = (PREVIEW_HEIGHT - ph) / 2;
if (docompute == TRUE)
{
GdkDisplay *display = gtk_widget_get_display (previewarea);
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
compute_preview (0, 0, width - 1, height - 1, pw, ph);
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gdk_window_set_cursor(previewarea->window, cursor);
gdk_cursor_unref (cursor);
clear_light_marker ();
}
if (pw != PREVIEW_WIDTH || ph != PREVIEW_HEIGHT)
gdk_window_clear (previewarea->window);
gdk_draw_rgb_image (previewarea->window, gc,
startx, starty, pw, ph,
GDK_RGB_DITHER_MAX,
preview_rgb_data, 3 * pw);
draw_lights (startx, starty, pw, ph);
}
static void
draw_handles (void)
{
gdouble dxpos, dypos;
gint startx, starty, pw, ph;
GimpVector3 viewpoint;
GimpVector3 light_position;
gint k = mapvals.light_selected;
gfloat length;
gfloat delta_x = 0.0;
gfloat delta_y = 0.0;
/* calculate handle position */
compute_preview_rectangle (&startx, &starty, &pw, &ph);
switch (mapvals.lightsource[k].type)
{
case NO_LIGHT:
return;
case POINT_LIGHT:
case SPOT_LIGHT:
/* swap z to reverse light position */
viewpoint = mapvals.viewpoint;
viewpoint.z = -viewpoint.z;
light_position = mapvals.lightsource[k].position;
gimp_vector_3d_to_2d (startx, starty, pw, ph, &dxpos, &dypos,
&viewpoint, &light_position);
handle_xpos = (gint) (dxpos + 0.5);
handle_ypos = (gint) (dypos + 0.5);
break;
case DIRECTIONAL_LIGHT:
light_position.x = light_position.y = 0.5;
light_position.z = 0;
viewpoint.z = -viewpoint.z;
gimp_vector_3d_to_2d (startx, starty, pw, ph, &dxpos, &dypos,
&viewpoint, &light_position);
length = PREVIEW_HEIGHT / 4;
delta_x = mapvals.lightsource[k].direction.x * length;
delta_y = mapvals.lightsource[k].direction.y * length;
handle_xpos = dxpos + delta_x;
handle_ypos = dypos + delta_y;
break;
}
gdk_gc_set_function (gc, GDK_COPY);
if (mapvals.lightsource[k].type != NO_LIGHT)
{
GdkColor color;
/* Restore background if it has been saved */
/* ======================================= */
if (backbuf.image != NULL)
{
gdk_gc_set_function (gc, GDK_COPY);
gdk_draw_image (previewarea->window, gc,
backbuf.image, 0, 0, backbuf.x,
backbuf.y, backbuf.w, backbuf.h);
g_object_unref (backbuf.image);
backbuf.image = NULL;
}
/* calculate backbuffer */
switch (mapvals.lightsource[k].type)
{
case POINT_LIGHT:
backbuf.x = handle_xpos - LIGHT_SYMBOL_SIZE / 2;
backbuf.y = handle_ypos - LIGHT_SYMBOL_SIZE / 2;
backbuf.w = LIGHT_SYMBOL_SIZE;
backbuf.h = LIGHT_SYMBOL_SIZE;
break;
case DIRECTIONAL_LIGHT:
if (delta_x <= 0)
backbuf.x = handle_xpos;
else
backbuf.x = startx + pw/2;
if (delta_y <= 0)
backbuf.y = handle_ypos;
else
backbuf.y = starty + ph/2;
backbuf.x -= LIGHT_SYMBOL_SIZE/2;
backbuf.y -= LIGHT_SYMBOL_SIZE/2;
backbuf.w = fabs(delta_x) + LIGHT_SYMBOL_SIZE;
backbuf.h = fabs(delta_y) + LIGHT_SYMBOL_SIZE;
break;
case SPOT_LIGHT:
backbuf.x = handle_xpos - LIGHT_SYMBOL_SIZE / 2;
backbuf.y = handle_ypos - LIGHT_SYMBOL_SIZE / 2;
backbuf.w = LIGHT_SYMBOL_SIZE;
backbuf.h = LIGHT_SYMBOL_SIZE;
break;
case NO_LIGHT:
break;
}
/* Save background */
/* =============== */
if ((backbuf.x >= 0) &&
(backbuf.x <= PREVIEW_WIDTH) &&
(backbuf.y >= 0) && (backbuf.y <= PREVIEW_HEIGHT))
{
/* clip coordinates to preview widget sizes */
if ((backbuf.x + backbuf.w) > PREVIEW_WIDTH)
backbuf.w = (PREVIEW_WIDTH - backbuf.x);
if ((backbuf.y + backbuf.h) > PREVIEW_HEIGHT)
backbuf.h = (PREVIEW_HEIGHT - backbuf.y);
backbuf.image = gdk_drawable_get_image (previewarea->window,
backbuf.x, backbuf.y,
backbuf.w, backbuf.h);
}
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0x0;
color.green = 0x4000;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
/* draw circle at light position */
switch (mapvals.lightsource[k].type)
{
case POINT_LIGHT:
case SPOT_LIGHT:
gdk_draw_arc (previewarea->window, gc, TRUE,
handle_xpos - LIGHT_SYMBOL_SIZE / 2,
handle_ypos - LIGHT_SYMBOL_SIZE / 2,
LIGHT_SYMBOL_SIZE,
LIGHT_SYMBOL_SIZE, 0, 360 * 64);
break;
case DIRECTIONAL_LIGHT:
gdk_draw_arc (previewarea->window, gc, TRUE,
handle_xpos - LIGHT_SYMBOL_SIZE / 2,
handle_ypos - LIGHT_SYMBOL_SIZE / 2,
LIGHT_SYMBOL_SIZE,
LIGHT_SYMBOL_SIZE, 0, 360 * 64);
gdk_draw_line (previewarea->window, gc,
handle_xpos, handle_ypos, startx+pw/2 , starty + ph/2);
break;
case NO_LIGHT:
break;
}
}
}
static GdkGC *
gimp_canvas_gc_new (GimpCanvas *canvas,
GimpCanvasStyle style)
{
GdkGC *gc;
GdkGCValues values;
GdkGCValuesMask mask = 0;
GdkColor fg = { 0, 0, 0, 0 };
GdkColor bg = { 0, 0, 0, 0 };
if (! GTK_WIDGET_REALIZED (canvas))
return NULL;
switch (style)
{
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_WHITE:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
break;
case GIMP_CANVAS_STYLE_RENDER:
mask |= GDK_GC_EXPOSURES;
values.graphics_exposures = TRUE;
break;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
mask |= GDK_GC_LINE_STYLE;
values.line_style = GDK_LINE_ON_OFF_DASH;
/* fallthrough */
case GIMP_CANVAS_STYLE_XOR:
mask |= GDK_GC_FUNCTION | GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE;
if (gimp_canvas_get_xor_color (canvas, &fg))
values.function = GDK_XOR;
else
values.function = GDK_INVERT;
values.cap_style = GDK_CAP_NOT_LAST;
values.join_style = GDK_JOIN_MITER;
break;
case GIMP_CANVAS_STYLE_SELECTION_IN:
case GIMP_CANVAS_STYLE_SELECTION_OUT:
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
mask |= GDK_GC_CAP_STYLE | GDK_GC_FILL | GDK_GC_STIPPLE;
values.cap_style = GDK_CAP_NOT_LAST;
values.fill = GDK_OPAQUE_STIPPLED;
values.stipple = canvas->stipple[0];
break;
case GIMP_CANVAS_STYLE_CUSTOM:
default:
return NULL;
}
gc = gdk_gc_new_with_values (GTK_WIDGET (canvas)->window, &values, mask);
if (style == GIMP_CANVAS_STYLE_XOR_DOTTED)
{
gint8 one = 1;
gdk_gc_set_dashes (gc, 0, &one, 1);
}
switch (style)
{
default:
return gc;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
case GIMP_CANVAS_STYLE_XOR:
break;
case GIMP_CANVAS_STYLE_WHITE:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_SELECTION_IN:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SELECTION_OUT:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
bg.red = 0x7f7f;
bg.green = 0x7f7f;
bg.blue = 0x7f7f;
break;
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0x0;
bg.green = 0x7f7f;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0x0;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
fg.red = 0x0;
fg.green = 0x7f7f;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
fg.red = 0xffff;
fg.green = 0x0;
fg.blue = 0x0;
break;
}
gdk_gc_set_rgb_fg_color (gc, &fg);
gdk_gc_set_rgb_bg_color (gc, &bg);
return gc;
}
static long int cdbackground(cdCtxCanvas *ctxcanvas, long int color)
{
ctxcanvas->bg = cdColorToGdk(color);
gdk_gc_set_rgb_bg_color(ctxcanvas->gc, &ctxcanvas->bg);
return color;
}
void gc_set_bg (GdkGC *gc, const char *spec) {
GdkColor color;
gdk_color_parse (spec, &color);
gdk_gc_set_rgb_bg_color (gc, &color);
}
static GdkRectangle *
select_area ()
{
GdkWindow *root;
GdkCursor *cursor;
select_area_filter_data data;
GdkGCValues values;
GdkColor color;
GdkRectangle *rectangle;
root = gdk_get_default_root_window ();
cursor = gdk_cursor_new (GDK_CROSSHAIR);
if (gdk_pointer_grab (root, FALSE,
GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK,
NULL, cursor,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
gdk_cursor_unref (cursor);
return FALSE;
}
gdk_keyboard_grab (root, FALSE, GDK_CURRENT_TIME);
gdk_window_add_filter (root, (GdkFilterFunc) select_area_filter, &data);
gdk_flush ();
data.rect.x = 0;
data.rect.y = 0;
data.rect.width = 0;
data.rect.height = 0;
data.button_pressed = FALSE;
data.root = root;
values.function = GDK_XOR;
values.fill = GDK_SOLID;
values.clip_mask = NULL;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
values.clip_x_origin = 0;
values.clip_y_origin = 0;
values.graphics_exposures = 0;
values.line_width = 0;
values.line_style = GDK_LINE_SOLID;
values.cap_style = GDK_CAP_BUTT;
values.join_style = GDK_JOIN_MITER;
data.gc = gdk_gc_new_with_values (root, &values,
GDK_GC_FUNCTION | GDK_GC_FILL |
GDK_GC_CLIP_MASK | GDK_GC_SUBWINDOW |
GDK_GC_CLIP_X_ORIGIN |
GDK_GC_CLIP_Y_ORIGIN | GDK_GC_EXPOSURES |
GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE |
GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE);
gdk_color_parse ("white", &color);
gdk_gc_set_rgb_fg_color (data.gc, &color);
gdk_color_parse ("black", &color);
gdk_gc_set_rgb_bg_color (data.gc, &color);
gtk_main ();
g_object_unref (data.gc);
gdk_window_remove_filter (root, (GdkFilterFunc) select_area_filter, &data);
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
gdk_pointer_ungrab (GDK_CURRENT_TIME);
gdk_cursor_unref (cursor);
if (data.rect.width == 0 && data.rect.height == 0)
return NULL;
rectangle = g_new0 (GdkRectangle, 1);
rectangle->x = data.rect.x;
rectangle->y = data.rect.y;
rectangle->width = data.rect.width + 1;
rectangle->height = data.rect.height + 1;
return rectangle;
}
/*
* vga_set_textattr:
* @vga: VGAtext object
* @textattr: VGA text attribute byte
*
* Set the VGAText's graphics context to use the text attribute given using
* the current VGA palette. May not actually result in a call to the
* graphics server, since redundant calls may be optimized out.
*/
static void
vga_set_textattr(VGAText *vga, guchar textattr)
{
guchar fg, bg;
/*
* Blink logic for text attributes
* -----------------------------------
*
* has no blink bit: normal (fg = fg, bg = bg)
* has blink bit, icecolor: high intensity bg (bg = hi(bg))
* has blink bit, no icecolor, blink_state off: fg = bg [hide]
* has blink bit, no icecolor, blink_state on: normal (fg = fg)
*/
if (!GETBLINK(textattr))
{
fg = GETFG(textattr);
bg = GETBG(textattr);
}
else if (vga->pvt->icecolor)
{ /* High intensity background / iCEColor */
fg = GETFG(textattr);
bg = BRIGHT(GETBG(textattr));
}
else if (vga->pvt->blink_state)
{ /* Blinking, but in on state so it appears normal */
fg = GETFG(textattr);
bg = GETBG(textattr);
if (vga->pvt->blink_timeout_id == -1)
vga_start_blink_timer(vga);
}
else
{ /* Hide, blink off state */
fg = GETBG(textattr);
bg = GETBG(textattr);
if (vga->pvt->blink_timeout_id == -1)
vga_start_blink_timer(vga);
}
if (vga->pvt->fg != fg)
{
#ifdef USE_DEPRECATED_GDK
gdk_gc_set_rgb_fg_color(vga->pvt->gc,
vga_palette_get_color(vga->pvt->pal, fg));
#else
/* Nothing we can really do like this */
#endif
vga->pvt->fg = fg;
}
if (vga->pvt->bg != bg)
{
#ifdef USE_DEPRECATED_GDK
gdk_gc_set_rgb_bg_color(vga->pvt->gc,
vga_palette_get_color(vga->pvt->pal, bg));
#else
#endif
vga->pvt->bg = bg;
}
}
static void
vga_realize(GtkWidget *widget)
{
GdkWindowAttr attributes;
gint attributes_mask;
//GdkCursor * cursor;
VGAText *vga;
#ifdef VGA_DEBUG
fprintf(stderr, "vga_realize()\n");
#endif
g_return_if_fail(widget != NULL);
g_return_if_fail(VGA_IS_TEXT(widget));
vga = VGA_TEXT(widget);
/* Set the realized flag. */
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
/* Main widget window */
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = 0;
attributes.y = 0;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual(widget);
attributes.colormap = gtk_widget_get_colormap(widget);
attributes.event_mask = gtk_widget_get_events(widget) |
GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK;
attributes_mask = GDK_WA_X |
GDK_WA_Y |
GDK_WA_VISUAL |
GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attributes,
attributes_mask);
gdk_window_move_resize(widget->window,
widget->allocation.x,
widget->allocation.y,
widget->allocation.width,
widget->allocation.height);
gdk_window_set_user_data(widget->window, widget);
gdk_window_show(widget->window);
#ifdef USE_DEPRECATED_GDK
/* Initialize private data that depends on the window */
if (vga->pvt->gc == NULL)
{
vga->pvt->glyphs = vga_font_get_bitmap(vga->pvt->font,
widget->window);
vga->pvt->gc = gdk_gc_new(widget->window);
// not needed i guess?
//gdk_gc_set_colormap(vga->pvt->gc, attributes.colormap);
gdk_gc_set_rgb_fg_color(vga->pvt->gc,
vga_palette_get_color(vga->pvt->pal, vga->pvt->fg));
gdk_gc_set_rgb_bg_color(vga->pvt->gc,
vga_palette_get_color(vga->pvt->pal, vga->pvt->bg));
gdk_gc_set_stipple(vga->pvt->gc, vga->pvt->glyphs);
gdk_gc_set_fill(vga->pvt->gc, GDK_OPAQUE_STIPPLED);
}
#else
#if 0
if (vga->pvt->cr == NULL) {
vga->pvt->cr = gdk_cairo_create(widget->window);
cairo_set_source_rgb(vga->pvt->cr, 0.5, 0.5, 0.0);
cairo_set_operator(vga->pvt->cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(vga->pvt->cr);
cairo_set_font_face(vga->pvt->cr, vga->pvt->font->face);
cairo_set_font_size(vga->pvt->cr, 1.0);
cairo_move_to(vga->pvt->cr, 10.0, 370.0);
cairo_set_source_rgb(vga->pvt->cr, 1.0, 1.0, 1.0);
cairo_show_text(vga->pvt->cr, "Testing");
#endif
#if 0
cairo_select_font_face (vga->pvt->cr, "Sans", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size(vga->pvt->cr, 12.0);
}
#endif
#endif
/* create a gdk window? is that what we really want? */
gtk_widget_grab_focus(widget);
}
static VALUE
rg_set_rgb_bg_color(VALUE self, VALUE color)
{
gdk_gc_set_rgb_bg_color(_SELF(self), RVAL2GDKCOLOR(color));
return self;
}
