/* %Z%%M% %I% %E% */

/*
 * Copyright (c) 1994-2009 by Wayne C. Gramlich.
 * All rights reserved.
 */

/*
 * This file provide a bunch of interface routines for manipulating
 * an Xlib {XGCValues} object.
 */

#ifndef XLIB_H
#include "xlib.h"
#endif

/* The initial object: */
Xlib_gc_values_struct xlib_gc_values___initial_object = {
    &xlib_screen___initial_object,	/* Screen object */
    0					/* Flags ojbect */
};					/* Rest zeros */
Xlib_gc_values xlib_gc_values___initial = &xlib_gc_values___initial_object;

/*
 * xlib_gc_values___bogus(gc_values)
 *	This routine will output an error message for {gc_values}.
 */
void
xlib_gc_values___bogus(
    Xlib_gc_values gc_values)
{
    xlib_errors___add(gc_values->screen->display->errors,
      "Bogus field value for gc_values");
}

/*
 * xlib_gc_values___label_print(prefix, label, out_stream)
 *	This routine will output {prefix} and {label} to {out_stream}.
 *	A pointer to a new prefix is retuned.
 */
Str
xlib_gc_values___label_print(
    Str prefix,
    Str label,
    Out_stream out_stream)
{
    char buffer[128];

    string__put(string__unix_str(prefix, buffer), out_stream);
    string__put(string__unix_str(label, buffer), out_stream);
    string__put(string__unix_str("=", buffer), out_stream);
    return ", ";
}

/*
 * xlib_gc_values___number_print(prefix, label, number, out_stream)
 *	This routine will output {previx}, {label}, and {number}
 *	to {out_stream}.
 */
Str
xlib_gc_values___number_print(
    Str prefix,
    Str label,
    unsigned number,
    Out_stream out_stream)
{
    prefix = xlib_gc_values___label_print(prefix, label, out_stream);
    unsigned__print(number, out_stream);
    return prefix;
}

/*
 * xlib_gc_values__address_get(gc_values)
 *	This routine will return the address of {gc_values}.
 */
unsigned
xlib_gc_values__address_get(
    Xlib_gc_values gc_values)
{
    return (unsigned)gc_values;
}

/*
 * xlib_gc_values__arc_mode_set(gc_values, arc_mode)
 *	This routine will set the arc drawing mode in {gc_values}
 *	to {arc_mode}.
 */
void
xlib_gc_values__arc_mode_set(
    Xlib_gc_values gc_values,
    unsigned arc_mode)
{
    Xlib_display display;
    extern unsigned xlib_arc_mode__chord;
    extern unsigned xlib_arc_mode__pie_slice;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->arc_mode = arc_mode;
	if (arc_mode == xlib_arc_mode__chord) {
	    arc_mode = ArcChord;
	} else if (arc_mode == xlib_arc_mode__pie_slice) {
	    arc_mode = ArcPieSlice;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.arc_mode = arc_mode;
	gc_values->values_mask |= GCArcMode;
    }
}

/*
 * xlib_gc_values__background_set(gc_values, background)
 *	This routine will set the background mask in {gc_values}
 *	to {background}.
 */
void
xlib_gc_values__background_set(
    Xlib_gc_values gc_values,
    Xlib_pixel background)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.background = (unsigned)background;
	gc_values->values_mask |= GCBackground;
    }
}

/*
 * xlib_gc_values__clip_mask_set(gc_values, clip_mask)
 *	This routine will set the clip mask mask in {gc_values}
 *	to {clip_mask}.
 */
void
xlib_gc_values__clip_mask_set(
    Xlib_gc_values gc_values,
    Xlib_pixmap clip_mask)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else if (gc_values->screen != clip_mask->screen) {
	xlib_errors___add(display->errors,
	  "screen and clip mask not on same screen");
    } else {
	gc_values->values.clip_mask = clip_mask->pixmap;
	gc_values->clip_mask = clip_mask;
	gc_values->values_mask |= GCClipMask;
    }
}

/*
 * xlib_gc_values__clip_x_origin_set(gc_values, clip_x_origin)
 *	This routine will set the clip x origin in {gc_values}
 *	to {clip_x_origin}.
 */
void
xlib_gc_values__clip_x_origin_set(
    Xlib_gc_values gc_values,
    unsigned clip_x_origin)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.clip_x_origin = (unsigned)clip_x_origin;
	gc_values->values_mask |= GCClipXOrigin;
    }
}

/*
 * xlib_gc_values__clip_y_origin_set(gc_values, clip_y_origin)
 *	This routine will set the clip x origin in {gc_values}
 *	to {clip_y_origin}.
 */
void
xlib_gc_values__clip_y_origin_set(
    Xlib_gc_values gc_values,
    unsigned clip_y_origin)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.clip_y_origin = (unsigned)clip_y_origin;
	gc_values->values_mask |= GCClipYOrigin;
    }
}

/*
 * xlib_gc_values__new(screen)
 *	This routine will allocate and return an erased {gc_values}
 *	object that is permanently associated with {screen}.
 */
Xlib_gc_values
xlib_gc_values__create(
    Xlib_screen screen)
{
    Xlib_display display;
    Xlib_gc_values gc_values;

    display = screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    }
    gc_values = (Xlib_gc_values)malloc(sizeof(*gc_values));
    (void)memset((void *)gc_values, 0, sizeof(*gc_values));
    gc_values->values.plane_mask = AllPlanes;
    gc_values->screen = screen;
    xlib_gc_values__erase(gc_values);
    return gc_values;
}

/*
 * xlib_gc_values__erase(gc_values)
 *	This routine will erase the contents of {gc_values}.
 */
void
xlib_gc_values__erase(
    Xlib_gc_values gc_values)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values_mask = 0;
    }
}

/*
 * xlib_gc_values__external__initialize()
 *	This routine will "initialize" the {xlib_gc_values} external
 *	code.
 */
void
xlib_gc_values__external__initialize(void)
{
    /* Do nothing! */
}

/*
 * xlib_gc_values__fill_style_set(gc_values, fill_style);
 *	This routine will set the polygon fill style in {xlib_gc_values}
 *	to {fill_style}.
 */
void
xlib_gc_values__fill_style_set(
    Xlib_gc_values gc_values,
    unsigned fill_style)
{
    Xlib_display display;
    extern unsigned xlib_fill_style__solid;
    extern unsigned xlib_fill_style__tiled;
    extern unsigned xlib_fill_style__stippled;
    extern unsigned xlib_fill_style__opaque_stippled;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->fill_style = fill_style;
	if (fill_style == xlib_fill_style__solid) {
	    fill_style = FillSolid;
	} else if (fill_style == xlib_fill_style__tiled) {
	    fill_style = FillTiled;
	} else if (fill_style == xlib_fill_style__stippled) {
	    fill_style = FillStippled;
	} else if (fill_style == xlib_fill_style__opaque_stippled) {
	    fill_style = FillOpaqueStippled;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.fill_style = fill_style;
	gc_values->values_mask |= GCFillStyle;
    }
}

/*
 * xlib_gc_values__fill_rule_set(gc_values, fill_rule)
 *	This routine will set the polygon fill style in {gc_values}
 *	to {fill_rule}.
 */
void
xlib_gc_values__fill_rule_set(
    Xlib_gc_values gc_values,
    unsigned fill_rule)
{
    Xlib_display display;
    extern unsigned xlib_fill_rule__even_odd;
    extern unsigned xlib_fill_rule__winding;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->fill_rule = fill_rule;
	if (fill_rule == xlib_fill_rule__even_odd) {
	    fill_rule = EvenOddRule;
	} else if (fill_rule == xlib_fill_rule__winding) {
	    fill_rule = WindingRule;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.fill_rule = fill_rule;
	gc_values->values_mask |= GCFillRule;
    }
}

/*
 * xlib_gc_values__foreground_set(gc_values, foreground)
 *	This routine will set the foreground mask in {gc_values}
 *	to {foreground}.
 */
void
xlib_gc_values__foreground_set(
    Xlib_gc_values gc_values,
    Xlib_pixel foreground)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.foreground = (unsigned)foreground;
	gc_values->values_mask |= GCForeground;
    }
}

/*
 * xlib_gc_values__graphics_exposures_mode_set(gc_values,
 *    graphics_exposures_mode)
 *	This routine will set the graphics_exposures mode in {gc_values}
 *	to {graphics_exposures_mode}.
 */
void
xlib_gc_values__graphics_exposures_mode_set(
    Xlib_gc_values gc_values,
    unsigned graphics_exposures_mode)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.graphics_exposures = (Bool)graphics_exposures_mode;
	gc_values->graphics_exposures = graphics_exposures_mode;
	gc_values->values_mask |= GCGraphicsExposures;
    }
}

/*
 * xlib_gc_values__line_cap_style_set(gc_values, line_cap_style);
 *	This routine will set the line cap style in {xlib_gc_values}
 *	to {line_cap_style}.
 */
void
xlib_gc_values__line_cap_style_set(
    Xlib_gc_values gc_values,
    unsigned line_cap_style)
{
    Xlib_display display;
    extern unsigned xlib_line_cap_style__not_last;
    extern unsigned xlib_line_cap_style__butt;
    extern unsigned xlib_line_cap_style__round;
    extern unsigned xlib_line_cap_style__projecting;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->line_cap_style = line_cap_style;
	if (line_cap_style == xlib_line_cap_style__not_last) {
	    line_cap_style = CapNotLast;
	} else if (line_cap_style == xlib_line_cap_style__butt) {
	    line_cap_style = CapButt;
	} else if (line_cap_style == xlib_line_cap_style__round) {
	    line_cap_style = CapRound;
	} else if (line_cap_style == xlib_line_cap_style__projecting) {
	    line_cap_style = CapProjecting;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.cap_style = line_cap_style;
	gc_values->values_mask |= GCCapStyle;
    }
}

/*
 * xlib_gc_values__line_join_style_set(gc_values, line_join_style);
 *	This routine will set the line join style in {xlib_gc_values}
 *	to {line_join_style}.
 */
void
xlib_gc_values__line_join_style_set(
    Xlib_gc_values gc_values,
    unsigned line_join_style)
{
    Xlib_display display;
    extern unsigned xlib_line_join_style__miter;
    extern unsigned xlib_line_join_style__round;
    extern unsigned xlib_line_join_style__bevel;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->line_join_style = line_join_style;
	if (line_join_style == xlib_line_join_style__miter) {
	    line_join_style = JoinMiter;
	} else if (line_join_style == xlib_line_join_style__round) {
	    line_join_style = JoinRound;
	} else if (line_join_style == xlib_line_join_style__bevel) {
	    line_join_style = JoinBevel;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.join_style = line_join_style;
	gc_values->values_mask |= GCJoinStyle;
    }
}

/*
 * xlib_gc_values__line_style_set(gc_values, line_style);
 *	This routine will set the line join style in {gc_values}
 *	to {line_style}.
 */
void
xlib_gc_values__line_style_set(
    Xlib_gc_values gc_values,
    unsigned line_style)
{
    Xlib_display display;
    extern unsigned xlib_line_style__on_off_dash;
    extern unsigned xlib_line_style__solid;
    extern unsigned xlib_line_style__double_dash;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->line_style = line_style;
	if (line_style == xlib_line_style__on_off_dash) {
	    line_style = LineOnOffDash;
	} else if (line_style == xlib_line_style__solid) {
	    line_style = LineSolid;
	} else if (line_style == xlib_line_style__double_dash) {
	    line_style = LineDoubleDash;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.join_style = line_style;
	gc_values->values_mask |= GCLineStyle;
    }
}

/*
 * xib_gc_values__line_width_set(gc_values, width)
 *	This procedure will set the width of drawn lines
 *	in {xlib_gc_values} to {width}.
 */
void
xlib_gc_values__line_width_set(
    Xlib_gc_values gc_values,
    unsigned width)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values_mask |= GCLineWidth;
	gc_values->values.line_width = width;
    }
}

/*
 * xib_gc_values__plane_mask_set(gc_values, plane_mask)
 *	This procedure will set the plane mask in {gc_values}
 *	to {plane_mask}.
 */
void
xlib_gc_values__plane_mask_set(
    Xlib_gc_values gc_values,
    unsigned plane_mask)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values_mask |= GCPlaneMask;
	gc_values->values.plane_mask = plane_mask;
    }
}

/*
 * xlib_gc_values__pixmap_x_origin_set(gc_values, pixmap_x_origin)
 *	This routine will set the pixmap x origin in {gc_values}
 *	to {pixmap_x_origin}.
 */
void
xlib_gc_values__pixmap_x_origin_set(
    Xlib_gc_values gc_values,
    unsigned pixmap_x_origin)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.ts_x_origin = (unsigned)pixmap_x_origin;
	gc_values->values_mask |= GCTileStipXOrigin;
    }
}

/*
 * xlib_gc_values__pixmap_y_origin_set(gc_values, pixmap_y_origin)
 *	This routine will set the pixmap x origin in {gc_values}
 *	to {pixmap_y_origin}.
 */
void
xlib_gc_values__pixmap_y_origin_set(
    Xlib_gc_values gc_values,
    unsigned pixmap_y_origin)
{
    Xlib_display display;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->values.ts_y_origin = (unsigned)pixmap_y_origin;
	gc_values->values_mask |= GCTileStipYOrigin;
    }
}

/*
 * xlib_gc_values__print(gc_values, out_stream)
 *	This routine will output the contents of {gc_values} to
 *	{out_stream}.
 */
void
xlib_gc_values__print(
    Xlib_gc_values gc_values,
    Out_stream out_stream)
{
    char buffer[128];

    if (gc_values == xlib_gc_values___initial) {
	string__put(string__unix_str("{??@xlib_gc_values}",
	  buffer), out_stream);
    } else {
	Str prefix;
	unsigned long values_mask;
	XGCValues *values;

	values_mask = gc_values->values_mask;
	values = &gc_values->values;
	prefix = "";
	string__put(string__unix_str("{", buffer), out_stream);
	if ((values_mask & GCFunction) != 0) {
	    extern void xlib_transfer_function__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "transfer_function", out_stream);
	    xlib_transfer_function__print(gc_values->transfer_function,
	      out_stream);
	}
	if ((values_mask & GCPlaneMask) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "plane_mask",
	      values->plane_mask, out_stream);
	}
	if ((values_mask & GCForeground) != 0) {
	    extern void xlib_pixel__print(Xlib_pixel, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "forground", out_stream);
	    xlib_pixel__print((Xlib_pixel)values->foreground, out_stream);
	}
	if ((values_mask & GCBackground) != 0) {
	    extern void xlib_pixel__print(Xlib_pixel, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "backround", out_stream);
	    xlib_pixel__print((Xlib_pixel)values->background, out_stream);
	}
	if ((values_mask & GCLineWidth) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "line_width",
	      values->line_width, out_stream);
	}
	if ((values_mask & GCLineStyle) != 0) {
	    extern void xlib_line_style__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "line_style", out_stream);
	    xlib_line_style__print(gc_values->line_style, out_stream);
	}
	if ((values_mask & GCCapStyle) != 0) {
	    extern void xlib_line_cap_style__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "line_style", out_stream);
	    xlib_line_cap_style__print(gc_values->line_cap_style,
	      out_stream);
	}
	if ((values_mask & GCJoinStyle) != 0) {
	    extern void xlib_line_join_style__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "line_join_style", out_stream);
	    xlib_line_join_style__print(gc_values->line_join_style,
	      out_stream);
	}
	if ((values_mask & GCFillStyle) != 0) {
	    extern void xlib_fill_style__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "fill_mode", out_stream);
	    xlib_fill_style__print(gc_values->fill_style, out_stream);
	}
	if ((values_mask & GCFillRule) != 0) {
	    extern void xlib_fill_rule__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "fill_rule", out_stream);
	    xlib_fill_rule__print(gc_values->fill_rule, out_stream);
	}
	if ((values_mask & GCArcMode) != 0) {
	    extern void xlib_arc_mode__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "arc_mode", out_stream);
	    xlib_arc_mode__print(gc_values->arc_mode, out_stream);
	}
	if ((values_mask & GCTile) != 0) {
	    extern void xlib_pixmap__print(Xlib_pixmap, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "tile", out_stream);
	    xlib_pixmap__print(gc_values->tile, out_stream);
	}
	if ((values_mask & GCStipple) != 0) {
	    extern void xlib_pixmap__print(Xlib_pixmap, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "stipple", out_stream);
	    xlib_pixmap__print(gc_values->stipple, out_stream);
	}
	if ((values_mask & GCTileStipXOrigin) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "pixmap_x_origin",
	      values->ts_x_origin, out_stream);
	}
	if ((values_mask & GCTileStipYOrigin) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "pixmap_y_origin",
	      values->ts_y_origin, out_stream);
	}
	if ((values_mask & GCGraphicsExposures) != 0) {
	    extern void logical__print(unsigned, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "graphics_exposure_mode", out_stream);
	    logical__print(gc_values->graphics_exposures, out_stream);
	}
	if ((values_mask & GCSubwindowMode) != 0) {
	    extern void xlib_subwindow_mode__print(unsigned,
	      Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "subwindow_mode", out_stream);
	    xlib_subwindow_mode__print(gc_values->subwindow_mode,
	      out_stream);
	}
	if ((values_mask & GCClipMask) != 0) {
	    extern void xlib_pixmap__print(Xlib_pixmap, Out_stream);

	    prefix = xlib_gc_values___label_print(prefix,
	      "clip_mask", out_stream);
	    xlib_pixmap__print(gc_values->clip_mask, out_stream);
	}
	if ((values_mask & GCClipXOrigin) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "clip_x_origin",
	      values->clip_x_origin, out_stream);
	}
	if ((values_mask & GCClipYOrigin) != 0) {
	    prefix = xlib_gc_values___number_print(prefix, "clip_y_origin",
	      values->clip_y_origin, out_stream);
	}
	string__put(string__unix_str("}", buffer), out_stream);
    }
}

/*
 * xlib_gc_values__stipple_set(gc_values, stipple)
 *	This routine will set the stipple in {gc_values} to {stipple}.
 */
void
xlib_gc_values__stipple_set(
    Xlib_gc_values gc_values,
    Xlib_pixmap stipple)
{
    Xlib_display display;
    Xlib_screen screen;

    screen = gc_values->screen;
    display = screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else if (screen != stipple->screen) {
	xlib_errors___add(display->errors,
	  "stipple screen does not match gc_values screen");
    } else {
	gc_values->values.stipple = stipple->pixmap;
	gc_values->stipple = stipple;
	gc_values->values_mask |= GCStipple;
    }
}

/*
 * xlib_gc_values__subwindow_mode_set(gc_values, subwindow_mode)
 *	This routine will set the subwindow mode in {gc_values}
 *	to {subwindow_mode}.
 */
void
xlib_gc_values__subwindow_mode_set(
    Xlib_gc_values gc_values,
    unsigned subwindow_mode)
{
    Xlib_display display;
    extern unsigned xlib_subwindow_mode__clip_by_children;
    extern unsigned xlib_subwindow_mode__include_inferiors;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->subwindow_mode = subwindow_mode;
	if (subwindow_mode == xlib_subwindow_mode__clip_by_children) {
	    subwindow_mode = ClipByChildren;
	} else if (subwindow_mode == xlib_subwindow_mode__include_inferiors) {
	    subwindow_mode = IncludeInferiors;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.subwindow_mode = subwindow_mode;
	gc_values->values_mask |= GCSubwindowMode;
    }
}

/*
 * xlib_gc_values__tile_set(gc_values, tile)
 *	This routine will set the tile in {gc_values} to {tile}.
 */
void
xlib_gc_values__tile_set(
    Xlib_gc_values gc_values,
    Xlib_pixmap tile)
{
    Xlib_display display;
    Xlib_screen screen;

    screen = gc_values->screen;
    display = screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else if (screen != tile->screen) {
	xlib_errors___add(display->errors,
	  "tile screen does not match gc_values screen");
    } else {
	gc_values->values.tile = tile->pixmap;
	gc_values->tile = tile;
	gc_values->values_mask |= GCTile;
    }
}

/*
 * xlib_gc_values__transfer_function_set(gc_values, transfer_function);
 *	This routine will set the transfer function in {gc_values}
 *	to {transfer_function}.
 */
void
xlib_gc_values__transfer_function_set(
    Xlib_gc_values gc_values,
    unsigned transfer_function)
{
    Xlib_display display;
    extern unsigned xlib_transfer_function__clear;
    extern unsigned xlib_transfer_function__and;
    extern unsigned xlib_transfer_function__and_reverse;
    extern unsigned xlib_transfer_function__copy;
    extern unsigned xlib_transfer_function__and_inverted;
    extern unsigned xlib_transfer_function__no_operation;
    extern unsigned xlib_transfer_function__xor;
    extern unsigned xlib_transfer_function__or;
    extern unsigned xlib_transfer_function__nor;
    extern unsigned xlib_transfer_function__equiv;
    extern unsigned xlib_transfer_function__invert;
    extern unsigned xlib_transfer_function__or_reverse;
    extern unsigned xlib_transfer_function__copy_inverted;
    extern unsigned xlib_transfer_function__or_inverted;
    extern unsigned xlib_transfer_function__nand;
    extern unsigned xlib_transfer_function__set;

    display = gc_values->screen->display;
    if (display->closed) {
	xlib_display___closed(display);
    } else {
	gc_values->transfer_function = transfer_function;
	if (transfer_function == xlib_transfer_function__clear) {
	    transfer_function = GXclear;
	} else if (transfer_function == xlib_transfer_function__and) {
	    transfer_function = GXand;
	} else if (transfer_function == xlib_transfer_function__and_reverse) {
	    transfer_function = GXandReverse;
	} else if (transfer_function == xlib_transfer_function__copy) {
	    transfer_function = GXcopy;
	} else if (transfer_function == xlib_transfer_function__and_inverted) {
	    transfer_function = GXandInverted;
	} else if (transfer_function == xlib_transfer_function__no_operation) {
	    transfer_function = GXnoop;
	} else if (transfer_function == xlib_transfer_function__xor) {
	    transfer_function = GXxor;
	} else if (transfer_function == xlib_transfer_function__or) {
	    transfer_function = GXor;
	} else if (transfer_function == xlib_transfer_function__nor) {
	    transfer_function = GXnor;
	} else if (transfer_function == xlib_transfer_function__equiv) {
	    transfer_function = GXequiv;
	} else if (transfer_function == xlib_transfer_function__invert) {
	    transfer_function = GXinvert;
	} else if (transfer_function == xlib_transfer_function__or_reverse) {
	    transfer_function = GXorReverse;
	} else if (transfer_function == xlib_transfer_function__copy_inverted){
	    transfer_function = GXcopyInverted;
	} else if (transfer_function == xlib_transfer_function__or_inverted) {
	    transfer_function = GXorInverted;
	} else if (transfer_function == xlib_transfer_function__nand) {
	    transfer_function = GXnand;
	} else if (transfer_function == xlib_transfer_function__set) {
	    transfer_function = GXset;
	} else {
	    xlib_gc_values___bogus(gc_values);
	}
	gc_values->values.join_style = transfer_function;
	gc_values->values_mask |= GCFunction;
    }
}