x_display = cluster

    init = proc (display: string) signals (error(string))
	% open connection to given display or $DISPLAY if string is empty

    root = proc () returns (x_window)
	% returns root window

    width = proc () returns (int)
	% returns root window width

    height = proc () returns (int)
	% returns root window height

    device = proc () returns (int)
	% returns device type

    protocol = proc () returns (int)
	% returns protocol version

    planes = proc () returns (int)
	% returns number of bit planes

    cells = proc () returns (int)
	% returns number of color map cells

    grab = proc ()
	% grabs sole control of server

    ungrab = proc ()
	% ungrabs sole control of server

    alloc_color = proc (red, green, blue: int) returns (int)
					       signals (error(string))
	% allocates a (shared) read-only color

    alloc_cell = proc () returns (int) signals (error(string))
	% allocates a writable color map entry

    alloc_cells = proc (ncolors, nplanes: int, contig: bool)
			returns (pixellist, int) signals (error(string))
	% allocates writable color map entries

    free_color = proc (pixel: int)
	% free a color/cell

    free_colors = proc (pixels: pixellist, mask: int)
	% free colors/cells

    store_color = proc (pixel, red, green, blue: int)
	% change/initialize a color map entry

    store_colors = proc (defs: colordeflist)
	% change/initialize color map entries

    query_color = proc (pixel: int) returns (int, int, int)
				    signals (error(string))
	% returns (red, green, blue)

    lookup_color = proc (name: string) returns (int, int, int, int, int, int)
				       signals (error(string))
	% returns (red, green, blue, h/w red, h/w green, h/w blue)

    black = proc () returns (x_pixmap)
	% returns tile of BlackPixel

    white = proc () returns (x_pixmap)
	% returns tile of WhitePixel

x_bitmap = cluster

    none = proc () returns (cvt)
	% returns placeholder

    create = proc (width, height: int, bits: _wordvec) returns (cvt)
	       signals (error(string))
	% _wordvec can be larger than needed

    destroy = proc (bit: cvt)

    c2b = proc (font: x_font, c: char) returns (cvt) signals (error(string))
	% returns bitmap of char

    get_id = proc (bit: cvt) returns (int)

    equal = proc (bit1, bit2: cvt) returns (bool)

    similar = proc (bit1, bit2: cvt) returns (bool)

    copy = proc (bit: cvt) returns (cvt)

x_cursor = cluster

    none = proc () returns (cvt)
	% returns placeholder

    create = proc (image, mask: x_bitmap, fore, back, xoff, yoff, func: int)
	       returns (cvt) signals (error(string))

    cons = proc (width, height: int, image, mask: _wordvec, fore, back: int,
		 xoff, yoff, func: int) returns (x_cursor)
					signals (error(string))
	% _wordvecs can be larger than needed

    destroy = proc (cursor: cvt)

    shape = proc (width, height: int) returns (int, int)
				      signals (error(string))
	% returns (supported width, supported height)

    get_id = proc (cursor: cvt) returns (int)

    equal = proc (cursor1, cursor2: cvt) returns (bool)

    similar = proc (cursor1, cursor2: cvt) returns (bool)

    copy = proc (cursor: cvt) returns (cvt)

x_font = cluster

    create = proc (name: string) returns (cvt) signals (error(string))

    destroy = proc (font: cvt)

    query = proc (font: cvt) returns (int, int, char, char, int, bool)
	      signals (error(string))
	% returns (avg_width, height, first_char, last_char, baseline, fixedwidth)

    widths = iter (font: cvt, s: string) yields (char, int)
					 signals (error(string))

    width = proc (font: cvt, s: string) returns (int) signals (error(string))

    all_widths = proc (font: cvt) returns (_wordvec) signals (error(string))
	% returns widths for first_char thru last_char, each width is 16 bits

    get_id = proc (font: cvt) returns (int)

    equal = proc (font1, font2: cvt) returns (bool)

    similar = proc (font1, font2: cvt) returns (bool)

    copy = proc (font: cvt) returns (cvt)

x_pixmap = cluster

    none = proc () returns (cvt)
	% returns placeholder

    create = proc (mask: x_bitmap, fore, back: int) returns (cvt)
	       signals (error(string))

    create_xy = proc (width, height: int, bits: _wordvec) returns (cvt)
		  signals (error(string))
	% _wordvec can be larger than needed

    create_z = proc (width, height: int, bits: _wordvec) returns (cvt)
		 signals (error(string))
	% _wordvec can be larger than needed

    tile = proc (pixel: int) returns (cvt) signals (error(string))

    destroy = proc (pix: cvt)

    shape = proc (width, height: int) returns (int, int)
				      signals (error(string))
	returns (supported width, supported height)

    get_id = proc (pix: cvt) returns (int)

    equal = proc (pix1, pix2: cvt) returns (bool)

    similar = proc (pix1, pix2: cvt) returns (bool)

    copy = proc (pix: cvt) returns (cvt)

x_window = cluster

    none = proc () returns (cvt)
	% returns placeholder

    create = proc (x, y, width, height: int, background: x_pixmap, parent: cvt,
		   borderwidth: int, border: x_pixmap) returns (cvt)
	       signals (error(string))
	% (x, y) for outer left, (width, height) exclude border

    create_transparency = proc (x, y, width, height: int, parent: cvt)
					returns (cvt) signals (error(string))

    destroy = proc (w: cvt)

    destroy_subwindows = proc (w: cvt)

    map = proc (w: cvt)

    map_subwindows = proc (w: cvt)

    unmap = proc (w: cvt)

    unmap_subwindows = proc (w: cvt)

    unmap_transparent = proc (w: cvt)

    raise = proc (w: cvt)

    lower = proc (w: cvt)

    circulate_up = proc (w: cvt)

    circulate_down = proc (w: cvt)

    move = proc (w: cvt, x, y: int)
	% (x, y) for outer left

    change = proc (w: cvt, width, height: int)
	% (width, height) exclude border

    configure = proc (w: cvt, x, y, width, height: int)
	% (x, y) for outer left, (width, height) exclude border

    set_background = proc (w: cvt, background: x_pixmap)
	% does not cause redisplay

    set_border = proc (w: cvt, border: x_pixmap)

    set_tilemode = proc (w: cvt, relative: bool)

    set_clipmode = proc (w: cvt, drawthru: bool)

    query = proc (w: cvt) returns (int, int, int, int, int, int, int, cvt)
	      signals (error(string))
	% returns (x, y, width, height, border, map, kind, icon)

    query_tree = proc (w: cvt) returns (cvt, wlist) signals (error(string))
	wlist = array[x_window]
	% returns (parent, children in bottom->top order)

    get_name = proc (w: cvt) returns (string) signals (error(string))

    set_name = proc (w: cvt, n: string)

    set_icon = proc (w, icon: cvt)

    get_resize = proc (w: cvt) returns (int, int, int, int)
			       signals (error(string))
	% returns (base width, width increment, base height, height increment)

    set_resize = proc (w: cvt, width0, widthinc, height0, heightinc: int)

    set_cursor = proc (w: cvt, cursor: x_cursor)

    set_input = proc (w: cvt, mask: int)

    grab_mouse = proc (w: cvt, mask: int, cursor: x_cursor)
							signals (error(string))

    ungrab_mouse = proc ()

    grab_button = proc (w: cvt, button, mask: int, cursor: x_cursor)
		    signals (error(string))

    ungrab_button = proc (button: int)

    query_mouse = proc (w: cvt) returns (int, int, cvt) signals (error(string))
	% returns (x, y, sub window)

    interpret_locator = proc (w: cvt, x, y: int) returns (int, int, cvt)
			  signals (error(string))
	% returns (x, y, sub window)

    warp_mouse = proc (w: cvt, x, y: int)

    cond_warp_mouse = proc (dstw: cvt, dstx, dsty: int, srcw: cvt,
			    srcx, srcy, srcwidth, srcheight: int)

    focus_keyboard = proc (w: cvt)

    clear = proc (w: cvt)

    pix_set = proc (w: cvt, pixel, x, y, width, height: int)
	% GXcopy to all planes

    pix_fill = proc (w: cvt, pixel: int, mask: x_bitmap,
		     x, y, width, height, func, planes: int)

    tile_set = proc (w: cvt, tile: x_pixmap, x, y, width, height: int)
	% GXcopy to all planes

    tile_fill = proc (w: cvt, tile: x_pixmap, mask: x_bitmap,
		      x, y, width, height, func, planes: int)

    pixmap_put = proc (w: cvt, pix: x_pixmap,
		       srcx, srcy, width, height, dstx, dsty, func, planes: int)

    pixmap_zbitsput = proc (w: cvt, width, height: int, bits: _wordvec,
			    mask: x_bitmap, x, y, func, planes: int)
	% _wordvec can be larger than needed

    pixmap_xybitsput = proc (w: cvt, width, height: int, bits: _wordvec,
			     mask: x_bitmap, x, y, func, planes: int)
	% _wordvec can be larger than needed

    bitmap_bitsput = proc (w: cvt, width, height: int, bits: _wordvec,
			   fore, back: int, mask: x_bitmap, x, y, func, planes: int)
	% _wordvec can be larger than needed

    move_area = proc (w: cvt, srcx, srcy, width, height, dstx, dsty: int)
	% GXcopy to all planes

    copy_area = proc (w: cvt, srcx, srcy, width, height, dstx, dsty: int,
		      func, planes: int)

    text = proc (w: cvt, s: string, font: x_font, fore, back, x, y: int)
	% GXcopy to all planes

    textv = proc (w: cvt, b: _bytevec, start, z: int, font: x_font,
		  fore, back, x, y: int)
	% GXcopy to all planes

    texta = proc (w: cvt, a: array[char], start, z: int, font: x_font,
		  fore, back, x, y: int)
	% GXcopy to all planes

    text_pad = proc (w: cvt, s: string, font: x_font,
		     fore, back, cpad, spad, x, y: int, func, planes: int)

    textv_pad = proc (w: cvt, b: _bytevec, start, z: int, font: x_font,
		      fore, back, cpad, spad: int, x, y: int, func, planes: int)

    texta_pad = proc (w: cvt, a: array[char], start, z: int, font: x_font,
		      fore, back, cpad, spad: int, x, y: int, func, planes: int)

    text_mask = proc (w: cvt, s: string, font: x_font, pixel, x, y: int)
	% GXcopy to all planes

    textv_mask = proc (w: cvt, b: _bytevec, start, z: int, font: x_font,
		       pixel, x, y: int)
	% GXcopy to all planes

    texta_mask = proc (w: cvt, a: array[char], start, z: int, font: x_font,
		       pixel, x, y: int)
	% GXcopy to all planes

    text_mask_pad = proc (w: cvt, s: string, font: x_font,
			  pixel, cpad, spad, x, y: int, func, planes: int)

    textv_mask_pad = proc (w: cvt, b: _bytevec, start, z: int, font: x_font,
			   pixel, cpad, spad: int, x, y: int, func, planes: int)

    texta_mask_pad = proc (w: cvt, a: array[char], start, z: int, font: x_font,
			   pixel, cpad, spad: int, x, y: int, func, planes: int)

    line = proc (w: cvt, pixel, width, height, x1, y1, x2, y2, func, planes: int)

    draw = proc (w: cvt, verts: x_vlist, z, pixel, width, height, func, planes: int)

    draw_dashed = proc (w: cvt, verts: x_vlist, z, pixel, width, height: int,
			pattern, patlen, patmul, func, planes: int)

    draw_patterned = proc (w: cvt, verts: x_vlist, z, pixel, altpix: int,
			    width, height, pattern, patlen, patmul, func, planes: int)

    draw_filled = proc (w: cvt, verts: x_vlist, z, pixel, func, planes: int)

    draw_tiled = proc (w: cvt, verts: x_vlist, z: int, tile: x_pixmap,
		       func, planes: int)

    save_region = proc (w: cvt, x, y, width, height: int) returns (x_pixmap)
		    signals (error(string))

    read_xyregion = proc (w: cvt, x, y, width, height: int) returns (_wordvec)
		    signals (error(string))

    read_zregion = proc (w: cvt, x, y, width, height: int) returns (_wordvec)
		    signals (error(string))

    get_id = proc (w: cvt) returns (int)

    equal = proc (w1, w2: cvt) returns (bool)

    similar = proc (w1, w2: cvt) returns (bool)

    copy = proc (w: cvt) returns (cvt)

x_input = cluster

    init = proc ()
	% called automatically by x_display$init

    set_squish = proc (flag: bool)
	% control mouse motion event compaction

    enq = proc (e: event)
	% copy of event will be made

    deq = proc (e: event)
	% wait for next event, stores results in argument

    edeq = proc (kind: int, e: event)
	% wait for single kind of event, stores results in argument

    mdeq = proc (kinds: int, e: event)
	% wait for any event in kinds, stores results in argument

    wdeq = proc (w: x_window, kinds: int, e: event)
	% wait for any event on w in kinds, stores results in argument

    pending = proc () returns (bool)
	% if any event pending

    epending = proc (kind: int) returns (bool)
	% if any event of single kind pending

    mpending = proc (kinds: int) returns (bool)
	% if any event of kinds pending

    wpending = proc (w: x_window, kinds: int) returns (bool)
	% if any event on w of kinds pending

    empty_event = proc () returns (event)
	% returns empty event suitable for calling deq

x_keymap = cluster

    load = proc (fs: string)
	% load keymap file (if empty string, load ~/.Xkeymap)

    getc = proc (key, mask: int) returns (char) signals (none, multi(string))
	% map to assumed single character

    gets = proc (key, mask: int) returns (string) signals (none)
	% map to assumed character string

x_cons = proc (name: string, back, border: x_pixmap, spec, defspec: string,
	       minwidth, minheight, bwidth: int) returns (x_window, int, int)
	% create a top-level window
	% spec is usual =spec from command line, defspec is default

x_tcons = proc (name: string, back, border: x_pixmap, spec, defspec: string,
		f: x_font, fwidth, fheight: int,
		add, minwidth, minheight, bwidth: int)
	    returns (x_window, int, int)
	% create a top-level (text) window
	% spec is usual =spec from command line, defspec is default
	% width (height) be 2*add plus multiple of fwidth (fheight)

x_default = proc (prog, option: string) returns (string) signals (not_found)
	% return option value from .Xdefaults file

x_parse_color = proc (spec: string) returns (int, int, int)
		  signals (bad_format, undefined)
	% returns (red, green, blue)

x_flush = proc ()
	% flush buffered output

x_feep = proc (volume: int)

x_store_cut = proc (buf: int, s: string)

x_fetch_cut = proc (buf: int) returns (string) signals (error(string))

x_rotate_cuts = proc (buf: int)

x_mouse_control = proc (accel, thresh: int)

x_feep_control = proc (volume: int)

x_shift_lock = proc (toggle: bool)

x_key_click = proc (volume: int)

x_auto_repeat = proc (on: bool)

x_screen_saver = proc (video: bool, timeout, shift: int)

x_error = proc (why: string)
	% routine called on internal X error