static void
gnucash_grid_realize (GnomeCanvasItem *item)
{
GdkWindow *window;
GnucashGrid *gnucash_grid;
GdkGC *gc;
if (GNOME_CANVAS_ITEM_CLASS (gnucash_grid_parent_class)->realize)
(GNOME_CANVAS_ITEM_CLASS
(gnucash_grid_parent_class)->realize)(item);
gnucash_grid = GNUCASH_GRID (item);
window = gtk_widget_get_window (GTK_WIDGET (item->canvas));
/* Configure the default grid gc */
gnucash_grid->grid_gc = gc = gdk_gc_new (window);
gnucash_grid->fill_gc = gdk_gc_new (window);
gnucash_grid->gc = gdk_gc_new (window);
/* Allocate the default colors */
gnucash_grid->background = gn_white;
gnucash_grid->grid_color = gn_black;
gnucash_grid->default_color = gn_black;
gdk_gc_set_foreground (gc, &gnucash_grid->grid_color);
gdk_gc_set_background (gc, &gnucash_grid->background);
gdk_gc_set_foreground (gnucash_grid->fill_gc,
&gnucash_grid->background);
gdk_gc_set_background (gnucash_grid->fill_gc,
&gnucash_grid->grid_color);
}
void SetPenAttr( GdkGC *fgGc, GdkGC *bgGc, curs_attr_t *attr )
{
if( attr == NULL )
return;
GdkColor colorFg;
GdkColor colorBg;
CvColorRGB( &colorFg, attr->fg );
CvColorRGB( &colorBg, attr->bg );
if( (attr->attr) & A_REVERSE ){
if( fgGc != NULL ){
gdk_gc_set_foreground( fgGc, &colorBg );
gdk_gc_set_background( fgGc, &colorFg );
}
if( bgGc != NULL ){
gdk_gc_set_foreground( bgGc, &colorFg );
gdk_gc_set_background( bgGc, &colorBg );
}
} else {
if( fgGc != NULL ){
gdk_gc_set_foreground( fgGc, &colorFg );
gdk_gc_set_background( fgGc, &colorBg );
}
if( bgGc != NULL ){
gdk_gc_set_foreground( bgGc, &colorBg );
gdk_gc_set_background( bgGc, &colorFg );
}
}
}
static void get_alpha_mask(float_shape_t *shape)
{
GdkColormap *colormap;
GdkColor black;
GdkColor white;
GdkGC *gc;
int rowstride, nchannels, x, y;
guchar *pixels, *p;
bool bright_green, has_alpha;
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
shape->mask_bitmap =
(GdkDrawable*)gdk_pixmap_new(NULL, shape->width, shape->height, 1);
gc = gdk_gc_new(shape->mask_bitmap);
gdk_gc_set_foreground(gc, &black);
gdk_gc_set_background(gc, &white);
gdk_draw_rectangle(shape->mask_bitmap, gc, TRUE, 0, 0,
shape->width, shape->height);
nchannels = gdk_pixbuf_get_n_channels(shape->pixbuf);
g_assert(gdk_pixbuf_get_colorspace(shape->pixbuf) == GDK_COLORSPACE_RGB);
g_assert(gdk_pixbuf_get_bits_per_sample(shape->pixbuf) == 8);
has_alpha = gdk_pixbuf_get_has_alpha(shape->pixbuf);
rowstride = gdk_pixbuf_get_rowstride(shape->pixbuf);
pixels = gdk_pixbuf_get_pixels(shape->pixbuf);
gdk_gc_set_foreground(gc, &white);
gdk_gc_set_background(gc, &black);
for (y = 0; y < shape->height; y++) {
for (x = 0; x < shape->width; x++) {
p = pixels + y*rowstride + x*nchannels;
bright_green = 0 == p[0] && 255 == p[1] && 0 == p[2];
if (has_alpha) {
if (255 == p[3]) // p[3] is alpha channel
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
else if (!bright_green) { // Bright green is alpha for RGB images
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
}
}
}
/* *****************************************************************************
* Draw Text (lat/lon) into Grid
*/
void
draw_grid_text (GtkWidget * widget, gdouble posx, gdouble posy, gchar * txt)
{
/* prints in pango */
PangoFontDescription *pfd;
PangoLayout *grid_label_layout;
gint width, height;
grid_label_layout = gtk_widget_create_pango_layout (map_drawingarea, txt);
pfd = pango_font_description_from_string ("Sans 8");
pango_layout_set_font_description (grid_label_layout, pfd);
pango_layout_get_pixel_size (grid_label_layout, &width, &height);
gdk_gc_set_function (kontext_map, GDK_XOR);
gdk_gc_set_background (kontext_map, &colors.white);
gdk_gc_set_foreground (kontext_map, &colors.mygray);
gdk_draw_layout_with_colors (drawable, kontext_map, posx - width / 2,
posy - height / 2, grid_label_layout, &colors.black,
NULL);
if (grid_label_layout != NULL)
g_object_unref (G_OBJECT (grid_label_layout));
/* freeing PangoFontDescription, cause it has been copied by prev. call */
pango_font_description_free (pfd);
}
void color_selected_data(GdkColor *color)
{
state_context *sx;
sx = ss->sgx;
sx->selected_data_color = color;
gdk_gc_set_foreground(sx->selected_basic_gc, color);
gdk_gc_set_background(sx->selected_erase_gc, color);
}
void SetBgColor( GdkGC *gc, long r, long g, long b )
{
GdkColor color;
color.red = r;
color.green = g;
color.blue = b;
gdk_color_alloc( gdk_colormap_get_system(), &color );
gdk_gc_set_background( gc, &color );
}
static void draw (QCADDesignObject *obj, GdkDrawable *dst, GdkFunction rop, GdkRectangle *rcClip)
{
int Nix, Nix1 ;
QCADClockingLayer *clocking_layer = QCAD_CLOCKING_LAYER (obj) ;
QCADLayer *layer = QCAD_LAYER (obj) ;
GdkGC *gc = NULL ;
double potential ;
GList *llItr = NULL ;
double x, y;
QCAD_DESIGN_OBJECT_CLASS (g_type_class_peek (g_type_parent (QCAD_TYPE_CLOCKING_LAYER)))->draw (obj, dst, rop, rcClip) ;
gc = gdk_gc_new (dst) ;
gdk_gc_set_foreground (gc, clr_idx_to_clr_struct (RED)) ;
gdk_gc_set_background (gc, clr_idx_to_clr_struct (RED)) ;
gdk_gc_set_clip_rectangle (gc, rcClip) ;
if (NULL != layer->lstObjs && clocking_layer->bDrawPotential)
{
GdkPixbuf *pb = NULL ;
pb = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, clocking_layer->tile_size, clocking_layer->tile_size) ;
for (Nix = 0; Nix < Nx; Nix++) {
x = xmin+dx*Nix;
for (Nix1 = 0; Nix1 < Ny; Nix1++) {
y = ymin+dy*Nix1;
potential = get_potential (x, y, clocking_layer->z_to_draw, Nx, Ny, Nz, dx, dy, dz, xmin, ymin) ;
/*
if (fabs (potential) < clocking_layer->dExtremePotential / 100.0)
{
fprintf (stderr, "Potential too small - breaking out\n") ;
// continue ;
}
*/
gdk_pixbuf_fill (pb,
((potential > 0) ? 0xFF000000 : 0x0000FF00) | (((int)((fabs (potential) / clocking_layer->dExtremePotential) * 128.0)) & 0xFF)) ;
// fprintf (stderr, "opacity = %lf/%lf * 255\n", potential, clocking_layer->dExtremePotential) ;
gdk_draw_pixbuf (dst, gc, pb, 0, 0, Nix * clocking_layer->tile_size, Nix1 * clocking_layer->tile_size, clocking_layer->tile_size, clocking_layer->tile_size, GDK_RGB_DITHER_NONE, 0, 0) ;
//gdk_draw_pixbuf (dst, gc, pb, 0, 0, Nix * clocking_layer->tile_size, Nix1 * clocking_layer->tile_size, clocking_layer->tile_size, clocking_layer->tile_size, GDK_RGB_DITHER_NONE, 0, 0) ;
// gdk_draw_rectangle (dst, gc, TRUE,
// Nix * clocking_layer->tile_size + (clocking_layer->tile_size >> 1) - 2,
// Nix1 * clocking_layer->tile_size + (clocking_layer->tile_size >> 1) - 2,
// 5, 5) ;
}
}
g_object_unref (pb) ;
}
g_object_unref (gc) ;
}
/**
* exp_pixmap_clean:
* @exp_pixmap: An "expanding pixmap"
*
* Paints the entire surface area of an #EXP_PIXMAP black.
*/
void exp_pixmap_clean (EXP_PIXMAP *exp_pixmap)
{
GdkGC *gc = NULL ;
gc = gdk_gc_new (exp_pixmap->pixmap) ;
gdk_gc_set_function (gc, GDK_COPY) ;
gdk_gc_set_foreground (gc, &clrBlack) ;
gdk_gc_set_background (gc, &clrBlack) ;
gdk_draw_rectangle (exp_pixmap->pixmap, gc, TRUE, 0, 0, exp_pixmap->cxUsed, exp_pixmap->cyUsed) ;
g_object_unref (gc) ;
}
void color_selected_graph(GdkColor *color)
{
state_context *sx;
sx = ss->sgx;
sx->selected_graph_color = color;
gdk_gc_set_background(sx->selected_basic_gc, color);
gdk_gc_set_foreground(sx->selected_erase_gc, color);
gc_set_foreground_xor(sx->selected_selection_gc, sx->selection_color, color);
gc_set_foreground_xor(sx->selected_cursor_gc, sx->cursor_color, color);
gc_set_foreground_xor(sx->selected_mark_gc, sx->mark_color, color);
}
void set_background_color(GdkGC *gc, int red, int green, int blue)
{
GdkColormap * cmap = gdk_colormap_get_system();
GdkColor color;
color.red = red;
color.green = green;
color.blue = blue;
if (gdk_colormap_alloc_color(cmap, &color, FALSE, TRUE))
{
gdk_gc_set_background(gc, &color);
}
}
/* Sets the background color for a graphics context. */
int
clip_GDK_GCSETBACKGROUND(ClipMachine * cm)
{
C_object *cgc = _fetch_co_arg(cm);
ClipVar *mcolor = _clip_spar ( cm, 2);
GdkColor color;
CHECKCOBJ(cgc,GDK_IS_GC(cgc));
CHECKARG(2,MAP_t);
_map_colors_to_gdk(cm, mcolor, &color);
gdk_gc_set_background(GDK_GC(cgc->object), &color);
return 0;
err:
return 1;
}
static void draw (QCADDesignObject *obj, GdkDrawable *dst, GdkFunction rop, GdkRectangle *rcClip)
{
int Nix, Nix1 ;
GdkGC *gc = NULL ;
GdkRectangle rcReal ;
GdkPoint ptSrc, ptDst ;
QCADRectangleElectrode *rc_electrode = QCAD_RECTANGLE_ELECTRODE (obj) ;
GdkColor *clr = NULL ;
world_to_real_rect (&(obj->bounding_box), &rcReal) ;
if (!RECT_INTERSECT_RECT (rcReal.x, rcReal.y, rcReal.width, rcReal.height, rcClip->x, rcClip->y, rcClip->width, rcClip->height))
return ;
clr = obj->bSelected ? clr_idx_to_clr_struct (RED) : &(obj->clr) ;
gc = gdk_gc_new (dst) ;
gdk_gc_set_foreground (gc, clr) ;
gdk_gc_set_background (gc, clr) ;
gdk_gc_set_function (gc, rop) ;
gdk_gc_set_clip_rectangle (gc, rcClip) ;
ptSrc.x = world_to_real_x (rc_electrode->precompute_params.pt[0].xWorld) ;
ptSrc.y = world_to_real_y (rc_electrode->precompute_params.pt[0].yWorld) ;
ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[1].xWorld) ;
ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[1].yWorld) ;
gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ;
ptSrc = ptDst ;
ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[2].xWorld) ;
ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[2].yWorld) ;
gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ;
ptSrc = ptDst ;
ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[3].xWorld) ;
ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[3].yWorld) ;
gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ;
ptSrc = ptDst ;
ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[0].xWorld) ;
ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[0].yWorld) ;
gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ;
for (Nix = 0 ; Nix < rc_electrode->n_x_divisions ; Nix++)
for (Nix1 = 0 ; Nix1 < rc_electrode->n_y_divisions ; Nix1++)
{
ptSrc.x = world_to_real_x (exp_array_index_2d (rc_electrode->precompute_params.pts, WorldPoint, Nix1, Nix).xWorld) ;
ptSrc.y = world_to_real_y (exp_array_index_2d (rc_electrode->precompute_params.pts, WorldPoint, Nix1, Nix).yWorld) ;
if (PT_IN_RECT (ptSrc.x, ptSrc.y, rcClip->x, rcClip->y, rcClip->width, rcClip->height))
gdk_draw_point (dst, gc, ptSrc.x, ptSrc.y) ;
}
g_object_unref (gc) ;
}
static void
gc_set_color(struct graphics_gc_priv *gc, struct color *c, int fg)
{
GdkColor gdkc;
gdkc.pixel=0;
gdkc.red=c->r;
gdkc.green=c->g;
gdkc.blue=c->b;
gdk_colormap_alloc_color(gc->gr->colormap, &gdkc, FALSE, TRUE);
if (fg)
gdk_gc_set_foreground(gc->gc, &gdkc);
else
gdk_gc_set_background(gc->gc, &gdkc);
}
/**
* gwy_vector_layer_setup_gc:
* @layer: A vector data view layer.
*
* Sets up Gdk graphic context of the vector layer for its parent window.
*
* This function is intended only for layer implementation.
**/
void
gwy_vector_layer_setup_gc(GwyVectorLayer *layer)
{
GtkWidget *parent;
GdkColor fg, bg;
g_return_if_fail(GWY_IS_VECTOR_LAYER(layer));
parent = GWY_DATA_VIEW_LAYER(layer)->parent;
if (!GTK_WIDGET_REALIZED(parent))
return;
if (!layer->gc)
layer->gc = gdk_gc_new(parent->window);
gdk_gc_set_function(layer->gc, GDK_XOR);
fg.pixel = 0xFFFFFFFF; /* FIXME */
bg.pixel = 0x00000000; /* FIXME */
gdk_gc_set_foreground(layer->gc, &fg);
gdk_gc_set_background(layer->gc, &bg);
}
/* {EV_PIXMAP_IMP}.make */
void F1202_17193 (EIF_REFERENCE Current)
{
GTCX
EIF_POINTER loc1 = (EIF_POINTER) 0;
EIF_POINTER loc2 = (EIF_POINTER) 0;
EIF_REFERENCE loc3 = (EIF_REFERENCE) 0;
EIF_POINTER tp1;
EIF_POINTER tp2;
EIF_INTEGER_32 ti4_1;
RTLD;
RTLI(2);
RTLR(0,Current);
RTLR(1,loc3);
RTGC;
tp1 = (EIF_POINTER) gtk_image_new();
F1079_14134(Current, tp1);
F1142_15736(Current);
loc3 = RTOSCF(14148,F1079_14148,(Current));
tp1 = (EIF_POINTER) NULL;
ti4_1 = *(EIF_INTEGER_32 *)(RTCV(loc3)+ _LNGOFF_49_16_0_19_);
loc1 = (EIF_POINTER) gdk_pixmap_new((GdkWindow*) tp1, (gint) ((EIF_INTEGER_32) 1L), (gint) ((EIF_INTEGER_32) 1L), (gint) ti4_1);
F1202_17215(Current, loc1, loc2);
tp1 = (EIF_POINTER) gdk_gc_new((GdkWindow*) loc1);
*(EIF_POINTER *)(Current+ _PTROFF_46_11_12_3_0_1_) = (EIF_POINTER) tp1;
tp1 = *(EIF_POINTER *)(Current+ _PTROFF_46_11_12_3_0_1_);
tp2 = RTOSCF(17071,F1198_17071,(Current));
gdk_gc_set_foreground((GdkGC*) tp1, (GdkColor*) tp2);
tp1 = *(EIF_POINTER *)(Current+ _PTROFF_46_11_12_3_0_1_);
tp2 = RTOSCF(17072,F1198_17072,(Current));
gdk_gc_set_background((GdkGC*) tp1, (GdkColor*) tp2);
F1198_17006(Current);
F1198_17038(Current, ((EIF_INTEGER_32) 0L), ((EIF_INTEGER_32) 0L), ((EIF_INTEGER_32) 1L), ((EIF_INTEGER_32) 1L));
RTLE;
}
static VALUE
rg_set_background(VALUE self, VALUE color)
{
gdk_gc_set_background(_SELF(self), RVAL2GDKCOLOR(color));
return self;
}
/* ****************************************************************************
* draw lines showing the route
*/
void
draw_route (void)
{
GdkSegment *route_seg;
gint destpos_x, destpos_y, curpos_x, curpos_y;
gint i, j;
gint t = 0;
gchar t_routept[5];
GtkTreeIter iter_route;
gdouble t_lon, t_lat;
if (route.items < 1)
return;
i = (route.items + 5);
route_seg = g_new0 (GdkSegment, i);
if (local_config.use_database)
{
/* poi mode */
g_snprintf (t_routept, sizeof (t_routept), "%d",
(route.pointer));
gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (route_list_tree),
&iter_route, t_routept);
calcxy (&curpos_x, &curpos_y,
coords.current_lon, coords.current_lat, current.zoom);
(route_seg)->x1 = curpos_x;
(route_seg)->y1 = curpos_y;
do
{
gtk_tree_model_get
(GTK_TREE_MODEL (route_list_tree), &iter_route,
ROUTE_LON, &t_lon, ROUTE_LAT, &t_lat, -1);
if (t != 0)
{
(route_seg + t)->x1 = (route_seg + t - 1)->x2;
(route_seg + t)->y1 = (route_seg + t - 1)->y2;
}
calcxy (&destpos_x, &destpos_y, t_lon, t_lat,
current.zoom);
(route_seg + t)->x2 = destpos_x;
(route_seg + t)->y2 = destpos_y;
t++;
}
while (gtk_tree_model_iter_next (GTK_TREE_MODEL
(route_list_tree), &iter_route));
}
else
{
/* waypoints mode */
/* start beginning with actual route.pointer */
for (j = route.pointer; j < route.items; j++)
{
/* start drawing with current_pos */
if (j == route.pointer)
{
calcxy (&curpos_x, &curpos_y,
coords.current_lon,
coords.current_lat, current.zoom);
(route_seg + t)->x1 = curpos_x;
(route_seg + t)->y1 = curpos_y;
}
else
{
(route_seg + t)->x1 = (route_seg + t - 1)->x2;
(route_seg + t)->y1 = (route_seg + t - 1)->y2;
}
calcxy (&destpos_x, &destpos_y, (routelist +
j)->lon, (routelist + j)->lat, current.zoom);
(route_seg + t)->x2 = destpos_x;
(route_seg + t)->y2 = destpos_y;
t++;
}
}
gdk_gc_set_foreground (kontext_map, &colors.route);
gdk_gc_set_background (kontext_map, &colors.white);
gdk_gc_set_line_attributes (kontext_map, 4, GDK_LINE_ON_OFF_DASH, 0, 0);
gdk_gc_set_dashes (kontext_map, 0, (gpointer) linestyles[local_config.style_route], 4);
gdk_gc_set_function (kontext_map, GDK_COPY);
gdk_draw_segments (drawable, kontext_map, (GdkSegment *) route_seg, t);
g_free (route_seg);
}
void _HYPlatformGraphicPane::_SetBColor (_HYColor c)
{
saveBG = HYColorToGDKColor(c);
gdk_gc_set_background (theContext, &saveBG);
}
static void
gnc_header_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height)
{
GncHeader *header = GNC_HEADER(item);
SheetBlockStyle *style = header->style;
Table *table = header->sheet->table;
VirtualLocation virt_loc;
VirtualCell *vcell;
CellDimensions *cd;
GdkColor *bg_color;
int xpaint, ypaint;
const char *text;
CellBlock *cb;
guint32 argb, color_type;
int i, j;
int w, h;
PangoLayout *layout;
virt_loc.vcell_loc.virt_row = 0;
virt_loc.vcell_loc.virt_col = 0;
virt_loc.phys_row_offset = 0;
virt_loc.phys_col_offset = 0;
if (header->sheet->use_theme_colors)
{
color_type = gnc_table_get_gtkrc_bg_color (table, virt_loc,
NULL);
bg_color = get_gtkrc_color(header->sheet, color_type);
}
else
{
argb = gnc_table_get_bg_color (table, virt_loc, NULL);
bg_color = gnucash_color_argb_to_gdk (argb);
}
h = style->dimensions->height;
h *= header->num_phys_rows;
h /= header->style->nrows;
gdk_gc_set_foreground (header->gc, bg_color);
gdk_draw_rectangle (drawable, header->gc, TRUE, 0, 0,
style->dimensions->width, h);
gdk_gc_set_line_attributes (header->gc, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gdk_gc_set_foreground (header->gc, &gn_black);
gdk_draw_rectangle (drawable, header->gc, FALSE, -x, -y,
style->dimensions->width, h);
gdk_draw_line (drawable, header->gc, 0, h + 1,
style->dimensions->width, h + 1);
gdk_gc_set_line_attributes (header->gc, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gdk_gc_set_background (header->gc, &gn_white);
gdk_gc_set_foreground (header->gc, &gn_black);
/*font = gnucash_register_font;*/
vcell = gnc_table_get_virtual_cell
(table, table->current_cursor_loc.vcell_loc);
cb = vcell ? vcell->cellblock : NULL;
ypaint = -y;
h = 0;
for (i = 0; i < style->nrows; i++)
{
xpaint = -x;
virt_loc.phys_row_offset = i;
/* TODO: This routine is duplicated in several places.
Can we abstract at least the cell drawing routine?
That way we'll be sure everything is drawn
consistently, and cut down on maintenance issues. */
for (j = 0; j < style->ncols; j++)
{
/* gint x_offset, y_offset;*/
GdkRectangle rect;
BasicCell *cell;
virt_loc.phys_col_offset = j;
cd = gnucash_style_get_cell_dimensions (style, i, j);
if (header->in_resize && (j == header->resize_col))
w = header->resize_col_width;
else
w = cd->pixel_width;
cell = gnc_cellblock_get_cell (cb, i, j);
if (!cell || !cell->cell_name)
{
xpaint += w;
continue;
}
h = cd->pixel_height;
gdk_draw_rectangle (drawable, header->gc, FALSE,
xpaint, ypaint, w, h);
virt_loc.vcell_loc =
table->current_cursor_loc.vcell_loc;
text = gnc_table_get_label (table, virt_loc);
if (!text)
text = "";
layout = gtk_widget_create_pango_layout (GTK_WIDGET (header->sheet), text);
/*y_offset = ((h / 2) +
(((font->ascent + font->descent) / 2) -
font->descent));
y_offset++;*/
switch (gnc_table_get_align (table, virt_loc))
{
default:
case CELL_ALIGN_LEFT:
pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
break;
case CELL_ALIGN_RIGHT:
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
break;
case CELL_ALIGN_CENTER:
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
break;
}
rect.x = xpaint + CELL_HPADDING;
rect.y = ypaint + 1;
rect.width = MAX (0, w - (2 * CELL_HPADDING));
rect.height = h - 2;
gdk_gc_set_clip_rectangle (header->gc, &rect);
gdk_draw_layout (drawable,
header->gc,
xpaint + CELL_HPADDING,
ypaint + 1,
layout);
g_object_unref (layout);
gdk_gc_set_clip_rectangle (header->gc, NULL);
xpaint += w;
}
ypaint += h;
}
}