Chapter 2 X11 R5 Xlib Functions

Header files for these functions can be found in libXi.a, Xcms.h, Xlib.h, Xresource.h, and Xutil.h.

void XActivateScreenSaver(display)

     Display  *display;

XExtCodes *XAddExtension(display)

     Display  *display;

XAddToExtensionList(ext_data)

     XExtData  **ext_data;

void XAddHost(display, host)

     Display  *display;

     XHostAddress  *host;

void XAddHosts(display, hosts, num_hosts)

     Display  *display;

     XHostAddress  *hosts;

     int  num_hosts;

XAddPixel(ximage, value)

     XImage  *ximage;

     long  value;

void XAddToSaveSet(display, w)

     Display  *display;

     Window  w;

XClassHint *XAllocClassHint()

Status XAllocColor(display, colormap, screen_in_out)

     Display  *display;

     Colormap  colormap;

     XColor  *screen_in_out;

Status XAllocColorCells(display, colormap, contig, plane_masks_return, nplanes, pixels_return, npixels)

     Display  *display;

     Colormap  colormap;

     Bool  contig;

     unsigned long  *plane_masks_return;

     unsigned int  nplanes;

     unsigned long  *pixels_return;

     unsigned int  npixels;

Status XAllocColorPlanes(display, colormap, contig, pixels_return, ncolors, nreds, ngreens, nblues, rmask_return, gmask_return, bmask_return)

     Display  *display;

     Colormap  colormap;

     Bool  contig;

     unsigned long  *pixels_return;

     int  ncolors, nreds, ngreens, nblues;

     unsigned long  *rmask_return, *gmask_return, *bmask_return;

XIconSize *XAllocIconSize()

Status XAllocNamedColor(display, colormap, color_name, screen_def_return, exact_def_return)

     Display  *display;

     Colormap  colormap;

     char  *color_name;

     XColor  *screen_def_return, *exact_def_return;

XSizeHints *XAllocSizeHints()

XStandardColormap *XAllocStandardColormap()

XWMHints *XAllocWMHints()

int XAllowDeviceEvents(display, device, event_mode, time)

     Display  *display;

     XDevice  *device;

     int  event_mode;

     Time  time;

void XAllowEvents(display, event_mode, time)

     Display  *display;

     int  event_mode;

     Time  time;

unsigned long XAllPlanes()

void XAutoRepeatOff(display)

     Display  *display;

void XAutoRepeatOn(display)

     Display  *display;

char *XBaseFontNameListOfFontSet(font_set)

     XFontSet font_set;

void XBell(display, percent)

     Display  *display;

     int  percent;

int XBitmapBitOrder(display)

      Display  *display;

int XBitmapPad(display)

      Display  *display;

int XBitmapUnit(display)

      Display  *display;

unsigned long XBlackPixel(display, screen_number)

      Display  *display;

      int screen_number;

unsigned long XBlackPixelOfScreen(screen)

      Screen  *screen;

int XCellsOfScreen(screen)

      Screen  *screen;

void XChangeActivePointerGrab(display, event_mask, cursor, time)

     Display  *display;

     unsigned int  event_mask;

     Cursor  cursor;

     Time  time;

int XChangeDeviceControl(display, device, controlType, control)

      Display  *display;

      XDevice  *device;

      int  controlType;

      XDeviceControl  *control;

int XChangeDeviceDontPropagateList(display, window, count, event_list, mode)

     Display  *display;

     Window  window;

     int  count, mode;

     XEventClass  *event_list;

int XChangeDeviceKeyMapping(display, device, first_keycode, keysyms_per_keycode, keysyms, keycode_count)

     Display  *display;

     XDevice  *device;

     int  first_keycode, keysyms_per_keycode, keycode_count;

     KeySym  *keysyms;

int XChangeFeedbackControl(display, device, mask, control)

     Display  *display;

     XDevice  *device;

     Mask  mask;

     XFeedbackControl  *control;

void XChangeGC(display, gc, valuemask, values)

     Display  *display;

     GC  gc;

     unsigned long  valuemask;

     XGCValues  *values;

void XChangeKeyboardControl(display, value_mask, values)

     Display  *display;

     unsigned long  value_mask;

     XKeyboardControl  *values;

Status XChangeKeyboardDevice(display, device)

     Display  *display;

     XDevice  *device;

void XChangeKeyboardMapping(display, first_keycode, keysyms_per_keycode, keysyms, num_codes)

     Display  *display;

     int  first_keycode, keysyms_per_keycode;

     KeySym  *keysyms;

     int  num_codes;

void XChangePointerControl(display, do_accel, do_threshold, accel_numerator, accel_denominator, threshold)

     Display  *display;

     Bool  do_accel, do_threshold;

     int  accel_numerator, accel_denominator, threshold;

Status XChangePointerDevice(display, device xaxis, yaxis)

     Display  *display;

     XDevice  *device;

     int  xaxis, yaxis;

void XChangeProperty(display, w, property, type, format, mode, data, nelements)

     Display  *display;

     Window  w;

     Atom  property, type;

     int  format, mode;

     unsigned char  *data;

     int  nelements;

void XChangeSaveSet(display, w, change_mode)

     Display  *display;

     Window  w;

     int  change_mode;

void XChangeWindowAttributes(display, w, valuemask, attributes)

     Display  *display;

     Window  w;

     unsigned long  valuemask;

     XSetWindowAttributes  *attributes;

Bool XCheckIfEvent(display, event_return, predicate, arg)

     Display  *display;

     XEvent  *event_return;

     Bool (*predicate)();

     XPointer  *arg;

Bool XCheckMaskEvent(display, event_mask, event_return)

     Display  *display;

     long  event_mask;

     XEvent  *event_return;

Bool XCheckTypedEvent(display, event_type, event_return)

     Display  *display;

     int  event_type;

     XEvent  *event_return;

Bool XCheckTypedWindowEvent(display, w, event_type, event_return)

     Display  *display;

     Window  w;

     int  event_type;

     XEvent  *event_return;

Bool XCheckWindowEvent(display, w, event_mask, event_return)

     Display  *display;

     Window  w;

     long  event_mask;

     XEvent  *event_return;

void XCirculateSubwindows(display, w, direction)

     Display  *display;

     Window  w;

     int  direction;

void XCirculateSubwindowsDown(display, w)

     Display  *display;

     Window  w;

void XCirculateSubwindowsUp(display, w)

     Display  *display;

     Window  w;

void XClearArea(display, w, x, y, width, height, exposures)

     Display  *display;

     Window  w;

     int  x, y;

     unsigned int  width, height;

     Bool  exposures;

void XClearWindow(display, w)

     Display  *display;

     Window  w;

void XClipBox(r, rect_return)

     Region  r;

     XRectangle  *rect_return;

int XCloseDevice(display, device)

     Display  *display;

     XDevice  *device;

void XCloseDisplay(display)

     Display  *display;

Status XCloseIM(im)

     XIM im;

Status XcmsAllocColor(display, colormap, color_in_out, result_format)

     Display  *display;

     Colormap  colormap;

     XcmsColor  *color_in_out;

     XcmsColorFormat  result_format;

Status XcmsAllocNamedColor(display, colormap, color_string, result_format, color_screen_return, color_exact_return)

      Display  *display;

      Colormap  colormap;

      char  *color_string;

      XcmsColorFormat  result_format;

      XcmsColor  *color_screen_return, *color_exact_return;

XcmsCCC XcmsCCCofColormap(display, colormap)

     Display  *display;

     Colormap  colormap;

Status XcmsCIELabQueryMaxC(ccc, hue_angle, L_star, color_return)

      XcmsCCC  ccc;

      XcmsFloat  hue_angle, L_star;

      XcmsColor  *color_return;

Status XcmsCIELabQueryMaxL(ccc, hue_angle, chroma, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, chroma;

     XcmsColor  *color_return;

Status XcmsCIELabQueryMaxLC(ccc, hue_angle, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, *color_return;

Status XcmsCIELabQueryMinL(ccc, hue_angle, chroma, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, chroma;

     XcmsColor  *color_return;

Status XcmsCIELuvQueryMaxC(ccc, hue_angle, L_star, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, L_star;

     XcmsColor  *color_return;

Status XcmsCIELuvQueryMaxL(ccc, hue_angle, chroma, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, chroma;

     XcmsColor  *color_return;

Status XcmsCIELuvQueryMaxLC(ccc, hue_angle, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle;

     XcmsColor  *color_return;

Status XcmsCIELuvQueryMinL(ccc, hue_angle, chroma, color_return)

     XcmsCCC  ccc;

     XcmsFloat  hue_angle, chroma;

     XcmsColor  *color_return;

Status XcmsConvertColors(ccc, colors_in_out, ncolors, target_format, compression_flags_return)

     XcmsCCC  ccc;

     XcmsColor  colors_in_out[];

     unsigned int  ncolors;

     XcmsColorFormat  target_format;

     Bool  compression_flags_return[];

XcmsCCC XcmsCreateCCC(display, screen_number, visual, client_white_point, compression_proc, compression_client_data, white_adjust_proc, white_adjust_client_data)

     Display   *display;

     int   screen_number;

     Visual   *visual;

     XcmsColor   *client_white_point;

     XcmsCompressionProc   compression_proc;

     XPointer   compression_client_data;

     XcmsWhiteAdjustProc   white_adjust_proc;

     XPointer   white_adjust_client_data;

XcmsCCC XcmsDefaultCCC(display, screen_number)

     Display   *display;

     int   screen_number;

void XcmsFreeCCC(ccc)

     XcmsCCC   ccc;

Status XcmsLookupColor(display, colormap, color_string, color_exact_return, color_screen_return, result_format)

      Display   *display;

      Colormap   colormap;

      char   *color_string;

      XcmsColor   *color_exact_return, *color_screen_return;

      XcmsColorFormat   result_format;

Status XcmsQueryBlack(ccc, target_format, color_return)

     XcmsCCC   ccc;

     XcmsColorFormat   target_format;

     XcmsColor   *color_return;

Status XcmsQueryBlue(ccc, target_format, color_return)

     XcmsCCC   ccc;

     XcmsColorFormat   target_format;

     XcmsColor   *color_return;

Status XcmsQueryColor(display, colormap, color_in_out, result_format)

     Display   *display;

     Colormap   colormap;

     XcmsColor   *color_in_out;

     XcmsColorFormat   result_format;

Status XcmsQueryColors(display, colormap, colors_in_out, ncolors, result_format)

     Display   *display;

     Colormap   colormap;

     XcmsColor   colors_in_out[];

     unsigned int   ncolors;

     XcmsColorFormat   result_format;

Status XcmsQueryGreen(ccc, target_format, color_return)

     XcmsCCC   ccc;

     XcmsColorFormat   target_format;

     XcmsColor   *color_return;

Status XcmsQueryRed(ccc, target_format, color_return)

     XcmsCCC   ccc;

     XcmsColorFormat   target_format;

     XcmsColor   *color_return;

Status XcmsQueryWhite(ccc, target_format, color_return)

     XcmsCCC   ccc;

     XcmsColorFormat   target_format;

     XcmsColor   *color_return;

XcmsCCC XcmsSetCCCOfColormap(display, colormap, ccc)

      Display   *display;

      Colormap   colormap;

XcmsWhiteAdjustProc XcmsSetWhiteAdjustProc(ccc, white_adjust_proc, client_data)

      XcmsCCC   ccc;

      XcmsWhiteAdjustProc   white_adjust_proc;

      XPointer   client_data;

Status XcmsSetWhitePoint(ccc, color)

      XcmsCCC   ccc;

      XcmsColor   *color;

Status XcmsStoreColor(display, colormap, color)

      Display   *display;

      Colormap   colormap;

      XcmsColor   *color;

Status XcmsStoreColors(display, colormap, colors, ncolors, compression_flags_return)

      Display   *display; 

      Colormap   colormap;

      XcmsColor   colors[];

      int   ncolors;

      Bool   compression_flags_return[];

Status XcmsTekHVCQueryMaxC(ccc, hue, value, color_return)

      XcmsCCC   ccc;

      XcmsFloat   hue, value;

      XcmsColor  *color_return;

Status XcmsTekHVCQueryMaxV(ccc, hue, chroma, color_return)

      XcmsCCC   ccc;

      XcmsFloat   hue, chroma;

      XcmsColor   *color_return;

Status XcmsTekHVCQueryMaxVC(ccc, hue, color_return)

      XcmsCCC   ccc;

      XcmsFloat   hue;

      XcmsColor   *color_return;

Status XcmsTekHVCQueryMaxVSamples(ccc, hue, colors_return, nsamples)

      XcmsCCC   ccc;

      XcmsFloat   hue;

      XcmsColor   colors_return[];

      unsigned int   nsamples;

Status XcmsTekHVCQueryMinV(ccc, hue, chroma, color_return)

      XcmsCCC   ccc;

      XcmsFloat   hue, chroma;

      XcmsColor   *color_return;

void XConfigureWindow(display, w, value_mask, values)

     Display  *display;

     Window  w;

     unsigned int  value_mask;

     XWindowChanges  *values;

int XConnectionNumber(display)

      Display  *display;

Bool XContextDependentDrawing(font_set)

     XFontSet  font_set;

void XConvertSelection(display, selection, target, property, requestor, time)

     Display  *display;

     Atom  selection, target, property;

     Window  requestor;

     Time  time;

void XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y)

     Display  *display;

     Drawable  src, dest;

     GC  gc;

     int  src_x, src_y;

     unsigned int  width, height;

     int  dest_x, dest_y;

Colormap XCopyColormapAndFree(display, colormap)

     Display  *display;

     Colormap  colormap;

void XCopyGC(display, src, valuemask, dest)

     Display  *display;

     GC  src;

     unsigned long  valuemask;

     GC  dest;

void XCopyPlane(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y, plane)

     Display  *display;

     Drawable  src, dest;

     GC  gc;

     int  src_x, src_y;

     unsigned int  width, height;

     int  dest_x, dest_y;

     unsigned long  plane;

Pixmap XCreateBitmapFromData(display, d, data, width, height)

     Display  *display;

     Drawable  d;

     char  *data;

     unsigned int  width, height;

Colormap XCreateColormap(display, w, visual, alloc)

     Display  *display;

     Window  w;

     Visual  *visual;

     int  alloc;

Cursor XCreateFontCursor(display, shape)

     Display  *display;

     unsigned int  shape;

XFontSet XCreateFontSet(display, base_font_name_list, missing_charset_list_return, missing_charset_count_return,

def_string_return)

     Display  *display;

     char  *base_font_name_list;

     char  ***missing_charset_list_return;

     int  *missing_charset_count_return;

     char  **def_string_return;

GC XCreateGC(display, d, valuemask, values)

     Display  *display;

     Drawable  d;

     unsigned long  valuemask;

     XGCValues  *values;

Cursor XCreateGlyphCursor(display, source_font, mask_font, source_char, mask_char, foreground_color, background_color)

     Display  *display;

     Font  source_font, mask_font;

     unsigned int  source_char, mask_char;

     XColor  *foreground_color, *background_color;

XIC XCreateIC(im, ...)

     XIM  im;

XImage *XCreateImage(display, visual, depth, format, offset, data, width, height, bitmap_pad, bytes_per_line)

     Display  *display;

     Visual  *visual;

     unsigned int  depth;

     int  format, offset;

     char  *data;

     unsigned int  width, height;

     int  bitmap_pad, bytes_per_line;

Pixmap XCreatePixmap(display, d, width, height, depth)

     Display  *display;

     Drawable  d;

     unsigned int  width, height, depth;

Cursor XCreatePixmapCursor(display, source, mask, foreground_color, background_color, x, y)

     Display  *display;

     Pixmap  source, mask;

     XColor  *foreground_color, *background_color;

     unsigned int  x, y;

Pixmap XCreatePixmapFromBitmapData(display, d, data, width, height, fg, bg, depth)

     Display  *display;

     Drawable  d;

     char  *data;

     unsigned int  width, height;

     unsigned long  fg, bg;

     unsigned int  depth;

Region XCreateRegion()

Window XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background)

     Display  *display;

     Window  parent;

     int  x, y;

     unsigned int  width, height, border_width;

     unsigned long  border, background;

Window XCreateWindow(display, parent, x, y, width, height, border_width, depth, class, visual, valuemask, attributes)

     Display  *display;

     Window  parent;

     int  x, y;

     unsigned int width, height, border_width;

     int  depth;

     unsigned int  class;

     Visual *visual

     unsigned long  valuemask;

     XSetWindowAttributes  *attributes;

Colormap XDefaultColormap(display, screen_number)

      Display  *display;

      int screen_number;

Colormap XDefaultColormapOfScreen(screen)

      Screen  *screen;

void XDefineCursor(display, w, cursor)

     Display  *display;

     Window  w;

     Cursor  cursor;

int XDefaultDepth(display, screen_number)

      Display  *display;

      int screen_number;

int XDefaultDepthOfScreen(screen)

      Screen  *screen;

GC XDefaultGC(display, screen_number)

      Display  *display;

      int screen_number;

GC XDefaultGCOfScreen(screen)

      Screen  *screen;

Window XDefaultRootWindow(display)

      Display  *display;

int XDefaultScreen(display)

      Display  *display;

Screen *XDefaultScreenOfDisplay(display)

      Display  *display;

char *XDefaultString()

Visual *XDefaultVisual(display, screen_number)

      Display  *display;

      int  screen_number;

Visual *XDefaultVisualOfScreen(screen)

      Screen  *screen;

int XDeleteContext(display, rid, context)

     Display  *display;

     XID  rid;

     XContext  context;

XModifierKeymap *XDeleteModifiermapEntry(modmap, keycode_entry, modifier)

     XModifierKeymap  *modmap;

     KeyCode  keycode_entry;

     int  modifier;

void XDeleteProperty(display, w, property)

     Display  *display;

     Window  w;

     Atom  property;

void XDestroyIC(ic)

     XIC  ic;

XDestroyImage(ximage)

     XImage  *ximage;

void XDestroyRegion(r)

     Region  r;

void XDestroySubwindows(display, w)

     Display  *display;

     Window  w;

void XDestroyWindow(display, w)

     Display  *display;

     Window  w;

Status XDeviceBell(display, device, feedbackclass, feedbackid, percent)

     Display  *display;

     XDevice  *device;

     XID  feedbackclass;

     XID  feedbackid;

     int percent;

void XDisableAccessControl(display)

     Display  *display;

int XDisplayCells(display, screen_number)

      Display  *display;

      int screen_number;

int XDisplayHeight(display, screen_number)

      Display  *display;

      int screen_number;

int XDisplayHeightMM(display, screen_number)

      Display  *display;

      int screen_number;

void XDisplayKeycodes(display, min_keycodes_return, max_keycodes_return)

     Display  *display;

     int  *min_keycodes_return, *max_keycodes_return;

unsigned long XDisplayMotionBufferSize(display)

     Display  *display;

char *XDisplayName(string)

     char  *string;

DisplayOfCCC(ccc)

     XcmsCCC  ccc;

Display * XDisplayOfIM(im)

     XIM  im;

Display *XDisplayOfScreen(screen)

      Screen  *screen;

int XDisplayPlanes(display, screen_number)

      Display  *display;

      int screen_number;

char *XDisplayString(display)

      Display  *display;

int XDisplayWidth(display, screen_number)

      Display  *display;

      int screen_number;

int XDisplayWidthMM(display, screen_number)

      Display  *display;

      int screen_number;

int XDoesBackingStore(screen)

      Screen  *screen;

Bool XDoesSaveUnders(screen)

      Screen  *screen;

void XDrawArc(display, d, gc, x, y, width, height, angle1, angle2)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     unsigned int   width, height;

     int  angle1, angle2;

void XDrawArcs(display, d, gc, arcs, narcs)

     Display  *display;

     Drawable  d;

     GC  gc;

     XArc  *arcs;

     int  narcs;

void XDrawImageString(display, d, gc, x, y, string, length)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     char  *string;

     int  length;

void XDrawImageString16(display, d, gc, x, y, string, length)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     XChar2b  *string;

     int  length;

void XDrawLine(display, d, gc, x1, y1, x2, y2)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x1, y1, x2, y2;

void XDrawLines(display, d, gc, points, npoints, mode)

     Display  *display;

     Drawable  d;

     GC  gc;

     XPoint  *points;

     int  npoints, mode;

void XDrawPoint(display, d, gc, x, y)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

void XDrawPoints(display, d, gc, points, npoints, mode)

     Display  *display;

     Drawable  d;

     GC  gc;

     XPoint  *points;

     int  npoints, mode;

void XDrawRectangle(display, d, gc, x, y, width, height)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     unsigned int   width, height;

void XDrawRectangles(display, d, gc, rectangles, nrectangles)

     Display  *display;

     Drawable  d;

     GC  gc;

     XRectangle  *rectangles;

     int  nrectangles;

void XDrawSegments(display, d, gc, segments, nsegments)

     Display  *display;

     Drawable  d;

     GC  gc;

     XSegment  *segments;

     int  nsegments;

void XDrawString(display, d, gc, x, y, string, length)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     char  *string;

     int  length;

void XDrawString16(display, d, gc, x, y, string, length)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     XChar2b  *string;

     int  length;

void XDrawText(display, d, gc, x, y, items, nitems)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     XTextItem  *items;

     int  nitems;

void XDrawText16(display, d, gc, x, y, items, nitems)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     XTextItem16  *items;

     int  nitems;

XextData **XEHeadOfExtensionList(object)

     XEDataObject  object;

Bool XEmptyRegion(r)

     Region  r;

void XEnableAccessControl(display)

     Display  *display;

Bool XEqualRegion(r1, r2)

     Region  r1, r2;

long XEventMaskOfScreen(screen)

      Screen  *screen;

int XEventsQueued(display, mode)

     Display  *display;

     int  mode;

XFontSetExtents *XExtentsOfFontSet(font_set)

     XFontSet  font_set;

char *XFetchBuffer(display, nbytes_return, buffer)

     Display  *display;

     int  *nbytes_return, buffer;

char *XFetchBytes(display, nbytes_return)

     Display  *display;

     int  *nbytes_return;

Status XFetchName(display, w, window_name_return)

     Display  *display;

     Window  w;

     char  **window_name_return;

void XFillArc(display, d, gc,  x, y, width, height, angle1, angle2)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     unsigned int   width, height;

     int  angle1, angle2;

void XFillArcs(display, d, gc, arcs, narcs)

     Display  *display;

     Drawable  d;

     GC  gc;

     XArc  *arcs;

     int  narcs;

void XFillPolygon(display, d, gc, points, npoints, shape, mode)

     Display  *display;

     Drawable  d;

     GC  gc;

     XPoint  *points;

     int  npoints, shape, mode;

void XFillRectangle(display, d, gc, x, y, width, height)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     unsigned int   width, height;

void XFillRectangles(display, d, gc, rectangles, nrectangles)

     Display  *display;

     Drawable  d;

     GC  gc;

     XRectangle  *rectangles;

     int  nrectangles;

Bool XFilterEvent(event, w)

     XEvent  *event;

     Window  w;

int XFindContext(display, rid, context, data_return)

     Display  *display;

     XID  rid;

     XContext  context;

     XPointer  *data_return;

XExtData *XFindOnExtensionList(structure, number)

     XExtData  **structure;

     int  number;

void XFlush(display)

     Display  *display;

void XFlushGC(display, gc)

    Display  *display;

    GC gc;

int XFontsOfFontSet(font_set, font_struct_list_return, font_name_list_return)

     XFontSet  font_set;

     XFontStruct  ***font_struct_list_return;

     char  ***font_name_list_return;

void XForceScreenSaver(display, mode)

     Display  *display;

     int  mode;

void XFree(data)

     char  *data;

void XFreeColormap(display, colormap)

     Display  *display;

     Colormap  colormap;

void XFreeColors(display, colormap, pixels, npixels, planes)

     Display  *display;

     Colormap  colormap;

     unsigned long  *pixels;

     int  npixels;

     unsigned long   planes;

void XFreeCursor(display, cursor)

     Display  *display;

     Cursor  cursor;

void XFreeDeviceList(list)

     XDeviceInfo  *list;

void XFreeExtensionList(list)

        char *  *list;

void XFreeFont(display, font_struct)

     Display  *display;

     XFontStruct  *font_struct;

void XFreeFontInfo(names, free_info, actual_count)

     char  **names;

     XFontStruct  *free_info;

     int  actual_count;

void XFreeFontNames(list)

     char  *list[];

void XFreeFontPath(list)

     char  **list;

void XFreeFontSet(display, font_set)

     Display  *display;

     XFontSet  font_set;

void XFreeGC(display, gc)

     Display  *display;

     GC  gc;

void XFreeModifiermap(modmap)

     XModifierKeymap  *modmap;

void XFreePixmap(display, pixmap)

     Display  *display;

     Pixmap  pixmap;

void XFreeStringList(list)

     char  **list;

GContext XGContextFromGC(gc)

     GC  gc;

int XGeometry(display, screen, position, default_position, bwidth, fwidth, fheight, xadder, yadder, x_return, y_return, height_return, width_return, height_return)

        Display *display;

        int  screen;

        char  *position, *default_position;

        unsigned int  bwidth;

        unsigned int  fwidth, fheight;

        int  xadder, yadder;

        int  *x_return, *y_return, *width_return, *height_return;

char *XGetAtomName(display, atom)

     Display  *display;

     Atom  atom;

Status XGetClassHint(display, w, class_hints_return)

     Display  *display;

     Window  w;

     XClassHint  *class_hints_return;

Status XGetCommand(display, w, argv_return, argc_return)

     Display  *display;

     Window  w;

     char  ***argv_return;

     int  *argc_return;

char *XGetDefault(display, program, option)

     Display  *display;

     char  *program, *option;

int XGetDeviceButtonMapping(display, device, map_return, nmap)

     Display  *display;

     XDevice  *device;

     unsigned  char map_return[];

     int  nmap;

XDeviceControl *XGetDeviceControl(display, device, control)

      Display  *display;

      XDevice  *device;

      int  *controlType;

unsigned XEventClass *XGetDeviceDontPropagateList(display, window, count)

     Display  *display;

     Window  window;

     int  *count;

int XGetDeviceFocus(display, device, focus_return, revert_to_return, time_return)

     Display  *display, *device;

     Window  *focus_return;

     int  *revert_to_return, *time_return;

KeySym *XGetDeviceKeyMapping(display, device, first_keycode, keycode_count, keysyms_per_keycode_return)

     Display  *display;

     XDevice  *device;

     KeyCode  first_keycode;

     int  keycode_count, *keysyms_per_keycode_return;

XModifierKeymap *XGetDeviceModifierMapping(display, device)

     Display  *display;

     XDevice  *device;

XDeviceTimeCoord *XGetDeviceMotionEvents(display, device, start, stop, nevents_return, mode_return, axis_count_return)

     Display  *display;

     XDevice  *device;

     Time  start, stop;

     int  *nevents_return, *mode_return, *axis_count_return;

void XGetErrorDatabaseText(display, name, message, default_string, buffer_return, length)

     Display  *display;

     char  *name, *message, *default_string, *buffer_return;

     int  length;

void XGetErrorText(display, code, buffer_return, length)

     Display  *display;

     int  code;

     char  *buffer_return;

     int  length;

XExtensionVersion *XGetExtensionVersion(display, name)

     Display  *display;

     char  *name;

XFeedbackState *XGetFeedbackControl(display, device, num_feedbacks)

     Display  *display;

     XDevice  *device;

     int  *num_feedbacks;

char **XGetFontPath(display, npaths_return)

     Display  *display;

     int  *npaths_return;

Bool XGetFontProperty(font_struct, atom, value_return)

     XFontStruct  *font_struct;

     Atom  atom;

     unsigned long   *value_return;

Status XGetGCValues(display, gc, valuemask, values_return)

     Display  *display;

     GC  gc;

     unsigned long  valuemask;

     XGCValues  *values_return;

Status XGetGeometry(display, d, root_return, x_return, y_return, width_return, height_return, border_width_return, depth_return)

     Display  *display;

     Drawable  d;

     Window  *root_return;

     int  *x_return, *y_return;

     unsigned int  *width_return, *height_return;

     unsigned int  *border_width_return, *depth_return;

Status XGetIconName(display, w, icon_name_return)

     Display  *display;

     Window  w;

     char  **icon_name_return;

Status XGetIconSizes(display, w, size_list_return, count_return)

     Display  *display;

     Window  w;

     XIconSize  **size_list_return;

     int  *count_return;

char * XGetICValues(ic, ...)

     XIC  ic;

XImage *XGetImage(display, d, x, y, width, height, plane_mask, format)

     Display  *display;

     Drawable  d;

     int  x, y;

     unsigned int   width, height;

     unsigned long  plane_mask;

     int  format;

char *XGetIMValues(im, ...)

     XIM  im;

void XGetInputFocus(display, focus_return, revert_to_return)

     Display  *display;

     Window  *focus_return;

     int  *revert_to_return;

void XGetKeyboardControl(display, values_return)

     Display  *display;

     XKeyboardState  *values_return;

KeySym *XGetKeyboardMapping(display, first_keycode, keycode_count, keysyms_per_keycode_return)

     Display  *display;

     KeyCode  first_keycode;

     int  keycode_count, *keysyms_per_keycode_return;

XModifierKeymap *XGetModifierMapping(display)

     Display  *display;

XTimeCoord *XGetMotionEvents(display, w, start, stop, nevents_return)

     Display  *display;

     Window  w;

     Time  start, stop;

     int  *nevents_return;

unsigned long XGetPixel(ximage, x, y)

     XImage  *ximage;

     int  x, y;

void XGetPointerControl(display, accel_numerator_return, accel_denominator_return, threshold_return)

     Display  *display;

     int  *accel_numerator_return, *accel_denominator_return;

     int  *threshold_return;

int XGetPointerMapping(display, map_return, nmap)

     Display  *display;

     unsigned char  map_return[];

     int  nmap;

Status XGetRGBColormaps(display, w, std_colormap_return, count_return, property)

     Display  *display;

     Window  w;

     XStandardColormap  **std_colormap_return;

     int  *count_return;

     Atom  property;

void XGetScreenSaver(display, timeout_return, interval_return, prefer_blanking_return, allow_exposures_return)

     Display  *display;

     int  *timeout_return, *interval_return;

     int  *prefer_blanking_return, *allow_exposures_return;

int XGetSelectedExtensionEvents(display, w, this_client_event_count_return, this_client_event_list_return, all_clients_event_count_return, all_clients_event_list_return)

     Display  *display;

     Window  w;

     int  *this_client_event_count_return;

     int  *all_clients_event_count_return;

     XEventClass  **this_client_event_list_return;

     XEventClass  **all_clients_event_list_return;

Window XGetSelectionOwner(display, selection)

     Display  *display;

     Atom  selection;

XImage *XGetSubImage(display, d, x, y, width, height, plane_mask, format, dest_image, dest_x, dest_y)

     Display  *display;

     Drawable  d;

     int  x, y;

     unsigned int   width, height;

     unsigned long   plane_mask;

     int  format;

     XImage  *dest_image;

     int  dest_x, dest_y;

Status XGetTextProperty(display, w, text_prop_return, property)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop_return;

     Atom  property;

Status XGetTransientForHint(display, w, prop_window_return)

     Display  *display;

     Window  w, *prop_window_return;

XVisualInfo *XGetVisualInfo(display, vinfo_mask, vinfo_template, nitems_return)

     Display  *display;

     long  vinfo_mask;

     XVisualInfo  *vinfo_template;

     int  *nitems_return;

Status XGetWindowAttributes(display, w, window_attributes_return)

     Display  *display;

     Window  w;

     XWindowAttributes  *window_attributes_return;

int XGetWindowProperty(display, w, property, long_offset, long_length, delete, req_type, actual_type_return, actual_format_return, nitems_return, bytes_after_return, prop_return)

     Display  *display;

     Window  w;

     Atom  property;

     long  long_offset, long_length;

     Bool  delete;

     Atom  req_type;

     Atom  *actual_type_return;

     int  *actual_format_return;

     unsigned long   *nitems_return, *bytes_after_return;

     unsigned char  **prop_return;

Status XGetWMClientMachine(display, w, text_prop_return)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop_return;

Status XGetWMColormapWindows(display, w, colormap_windows_return, count_return)

     Display  *display;

     Window  w, **colormap_windows_return;

     int  *count_return;

XWMHints *XGetWMHints(display, w)

     Display  *display;

     Window  w;

Status XGetWMIconName(display, w, text_prop_return)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop_return;

Status XGetWMName(display, w, text_prop_return)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop_return;

Status XGetWMNormalHints(display, w, hints_return, supplied_return)

     Display  *display;

     Window  w;

     XSizeHints  *hints_return;

     long  *supplied_return;

Status XGetWMProtocols(display, w, protocols_return, count_return)

     Display  *display;

     Window  w;

     Atom  **protocols_return;

     int  *count_return;

Status XGetWMSizeHints(display, w, hints_return, supplied_return, property)

     Display  *display;

     Window  w;

     XSizeHints  *hints_return;

     long  *supplied_return;

     Atom  property;

void XGrabButton(display, button, modifiers, grab_window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor)

     Display  *display;

     unsigned int   button, modifiers;

     Window  grab_window;

     Bool  owner_events;

     unsigned int  event_mask;

     int  pointer_mode, keyboard_mode;

     Window  confine_to;

     Cursor  cursor;

int XGrabDevice(display, device, grab_window, owner_events, event_count, event_list, this_device_mode, other_devices_mode, time)

     Display  *display;

     XDevice  *device;

     Window  grab_window;

     Bool  owner_events;

     int  event_count, this_device_mode, other_devices_mode;

     XEventClass  *event_list;

     Time  time;

int XGrabDeviceButton(display, device, button, modifiers, modifier_device, grab_window, owner_events, event_count, event_list, this_device_mode, other_devices_mode)

     Display  *display;

     XDevice  *device, *modifier_device;

     unsigned int   button, modifiers, event_count;

     Window  grab_window;

     Bool  owner_events;

     XEventClass  *event_list;

     int  this_device_mode, other_devices_mode;

int XGrabDeviceKey(display, device, Key, modifiers, modifier_device, grab_window, owner_events, event_count, event_list, this_device_mode, other_devices_mode)

     Display  *display;

     XDevice  *device, *modifier_device;

     unsigned int  Key, modifiers, event_count;

     Window  grab_window;

     Bool  owner_events;

     XEventClass  event_list;

     int  this_device_mode, other_devices_mode;

void XGrabKey(display, keycode, modifiers, grab_window, owner_events, pointer_mode, keyboard_mode)

     Display  *display;

     int  keycode;

     unsigned int   modifiers;

     Window  grab_window;

     Bool  owner_events;

     int  pointer_mode, keyboard_mode;

int XGrabKeyboard(display, grab_window, owner_events, pointer_mode, keyboard_mode, time)

     Display  *display;

     Window  grab_window;

     Bool  owner_events;

     int  pointer_mode, keyboard_mode;

     Time  time;

int XGrabPointer(display, grab_window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time)

     Display  *display;

     Window  grab_window;

     Bool  owner_events;

     unsigned int   event_mask;

     int  pointer_mode, keyboard_mode;

     Window  confine_to;

     Cursor  cursor;

     Time  time;

void XGrabServer(display)

     Display  *display;

int XHeightMMOfScreen(screen)

      Screen  *screen;

int XHeightOfScreen(screen)

      Screen  *screen;

int XHPAcknowledge(display, deviceid, acknowledge)

     Display  *display;

     XID  deviceid;

     int   acknowledge;

int XHPChangeDeviceControl(display, deviceid, value_mask, values)

     Display  *display;

     XID  deviceid;

     unsigned long   value_mask;

     XHPDeviceControl  *values;

int XHPChangeDeviceKeyMapping(display, deviceid, first_keycode, keysyms_per_keycode, keysyms, num_codes)

     Display  *display;

     XID  deviceid;

     int  first_keycode, keysyms_per_keycode, num_codes;

     KeySyms  *keysyms;

int XHPConvertLookup(event_struct, buffer_return, bytes_buffer, keysym_return, status_in_out, convert_routine)

     XKeyEvent  *event_struct;

     char  *buffer_return;

     int  bytes_buffer;

     KeySym  *keysym_return;

     XComposeStatus  *status_in_out;

     int (*convert_routine)()

int XHPDeviceAutoRepeatOff(display, deviceid)

     Display  *display;

     XID  deviceid;

int XHPDeviceAutoRepeatOn(display, deviceid, rate)

     Display  *display;

     XID  deviceid;

     unsigned int   rate;

int XHPDisableReset(display)

     Display  *display;

int XHPEnableReset(display)

     Display  *display;

XHPFreeDeviceList(list)

     XHPDeviceList  *list;

XFontStruct *XHPGet16bitMixedFontStruct(font)

     Font  font;

int XHPGetCurrentDeviceMask(display, window, deviceid, mask_return)

     Display  *display;

     Window  window;

     XID  deviceid;

     Mask  *mask_return;

int XHPGetDeviceControl(display, deviceid, values_return)

     Display  *display;

     XID  deviceid;

     XHPDeviceState  *values_return;

int XHPGetDeviceFocus(display, deviceid, focus_return, revert_to_return)

     Display  *display;

     XID  deviceid;

     Window  *focus_return;

     int  *revert_to_return;

KeySym *XHPGetDeviceKeyMapping(display, deviceid, first_keycode_wanted, keycode_count, keysyms_per_keycode_return)

     Display  *display;

     XID  deviceid;

     KeyCode  first_keycode_wanted;

     int  keycode_count, *keysyms_per_keycode_return;

XModifierKeyMap *XHPGetDeviceModifierMapping(display, deviceid)

     Display  *display;

     XID  deviceid;

XHPTimeCoord *XHPGetDeviceMotionEvents(display, deviceid, w, start, stop, nevents_return)

     Display  *display;

     XID  deviceid;

     Window  w;

     Time  start, stop;

     int  *nevents_return;

PtrFuncInt XHPGetEurasianCvt(display)

     Display  *display;

int XHPGetExtEventMask(display, event_constant, event_type, event_mask)

     Display  *display;

     long  event_constant, *event_type;

     Mask  *event_mask;

XHPGetServerMode(display, screen)

     Display  *display;

     int  screen;

int XHPGrabDevice(display, deviceid, grab_window, owner_events, pointer_mode, device_mode, time)

     Display  *display;

     XID  deviceid;

     Window  grab_window;

     Bool  owner_events;

     int  pointer_mode, device_mode;

     Time  time;

int XHPGrabDeviceButton(display, deviceid, button, modifiers, grab_window, owner_events, event_mask, pointer_mode, device_mode)

     Display  *display;

     XID  deviceid;

     unsigned int   button, modifiers, event_mask;

     Window  grab_window;

     Bool  owner_events;

     int  pointer_mode, device_mode;

int XHPGrabDeviceKey(display, deviceid, keycode, modifiers, grab_window, owner_events, pointer_mode, device_mode)

     Display  *display;

     XID  deviceid;

     unsigned int   keycode, modifiers;

     Window  grab_window;

     Bool  owner_events;

     int  pointer_mode, device_mode;

int XHPInputChinese_s(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

int XHPInputChinese_t(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

int XHPInputISO7sub(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

int XHPInputJapanese(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

int XHPInputKorean(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

int XHPInputRoman8(display, keysym, modifiers, buffer_return, bytes_buffer, status_in_out)

     Display  *display;

     KeySym  *keysym;

     unsigned int   modifiers;

     char  *buffer_return;

     int  bytes_buffer;

     XComposeStatus  *status_in_out;

Bool XHPIs16bitCharacter(font, byte1, byte2)

     font  font;

     unsigned char byte1;

     unsigned char byte2;

int XHPKeysymToRoman8(keysym, r8_return)

     KeySym  keysym;

     char  *r8_return;

XHPDeviceList *XHPListInputDevices(display, ndevices)

     Display  *display;

     int *ndevices	

Status XHPNlioctl(display, status_in_out, command, arg)

     Display  *display;

     XComposeStatus  *status_in_out;

     int  command;

     char  *arg;

int XHPPrompt(display, deviceid, prompt)

     Display  *display;

     XID  deviceid;

     unsigned int   prompt;

XHPRefreshKeyboardMapping(event_map)

     XMappingEvent  *event_map;

KeySym XHPRoman8ToKeysym(r8_char)

     char  r8_char;

int XHPSelectExtensionEvent(display, window, deviceid, mask)

     Display  *display;

     Window  window;

     XID  deviceid;

     Mask  mask;

int XHPSetDeviceFocus(display, deviceid, focus, revert_to, time)

     Display  *display;

     XID  deviceid;

     Window  focus;

     int  revert_to;

     Time  time;

int XHPSetDeviceModifierMapping(display, deviceid, modmap)

     Display  *display;

     XID  deviceid;

     XModifierKeymap  *modmap;

PFI XHPSetErrorHandler(display, routine)

    Display  *display;

    int  (*routine)();

int XHPSetInputDevice(display, deviceid, mode)

     Display  *display;

     XID  deviceid;

     int  mode;

XHPSetKbdMapInit(display, kbd_id, force_read, status_in_out)

     Display  *display;

     KEYBOARD_ID  kbd_id;

     int  force_read;

     XComposeStatus  *status_in_out;

Status XHPSetKeyboardMapping(display, kbd_id, force_read)

     Display  *display;

     KEYBOARD_ID  kbd_id;

     int  force_read;

int XHPUngrabDevice(display, deviceid, time)

     Display  *display;

     XID  deviceid;

     Time  time;

int XHPUngrabDeviceButton(display, deviceid, button, modifiers, ungrab_window) 

     Display  *display;

     XID  deviceid;

     unsigned int   button, modifiers;

     Window  ungrab_window;

int XHPUngrabDeviceKey(display, deviceid, keycode, modifiers, ungrab_window)

     Display  *display;

     XID  deviceid;

     unsigned int   keycode, modifiers;

     Window  ungrab_window;

Status XIconifyWindow(display, w, screen_number)

     Display  *display;

     Window  w;

     int  screen_number;

XIfEvent(display, event_return, predicate, arg)

     Display  *display;

     XEvent  *event_return;

     Bool (*predicate)();

     XPointer  arg;

int XImageByteOrder(display)

      Display  *display;

XIM XIMOfIC(ic)

     XIC ic;

XExtCode *XInitExtension(display, name)

     Display  *display;

     char  *name;

XModifierKeymap *XInsertModifiermapEntry(modmap, keycode_entry, modifier)

     XModifierKeymap  *modmap;

     KeyCode  keycode_entry;

     int  modifier;

void XInstallColormap(display, colormap)

     Display  *display;

     Colormap  colormap;

Atom XInternAtom(display, atom_name, only_if_exists)

     Display  *display;

     char  *atom_name;

     Bool  only_if_exists;

void XIntersectRegion(sra, srb, dr_return)

     Region  sra, srb, dr_return;

KeySym XKeycodeToKeysym(display, keycode, index)

     Display  *display;

     KeyCode  keycode;

     int  index;

KeyCode XKeysymToKeycode(display, keysym)

     Display  *display;

     KeySym  keysym;

char *XKeysymToString(keysym)

     KeySym  keysym;

void XKillClient(display, resource)

     Display  *display;

     XID  resource;

unsigned long XLastKnownRequestProcessed(display)

     Display  *display;

int *XListDepths(display, screen_number, count_return)

     Display  *display;

     int  screen_number;

     int  *count_return;

char **XListExtensions(display, nextensions_return)

        Display  *display;

        int  *nextensions_return;

char **XListFonts(display, pattern, maxnames, actual_count_return)

     Display  *display;

     char  *pattern;

     int  maxnames, *actual_count_return;

char **XListFontsWithInfo(display, pattern, maxnames, count_return, info_return)

     Display  *display;

     char  *pattern;

     int  maxnames, *count_return;

     XFontStruct  **info_return;

XHostAddress *XListHosts(display, nhosts_return, state_return)

     Display  *display;

     int  *nhosts_return;

     Bool  *state_return;

XDeviceInfo *XListInputDevices(display, ndevices_return)

     Display  *display;

     int  *ndevices_return;

Colormap *XListInstalledColormaps(display, w, num_return)

     Display  *display;

     Window  w;

     int  *num_return;

XPixmapFormatValues *XListPixmapFormats(display, count_return)

     Display  *display;

     int  *count_return;

Atom *XListProperties(display, w, num_prop_return)

     Display  *display;

     Window  w;

     int  *num_prop_return;

Font XLoadFont(display, name)

     Display  *display;

     char  *name;

XFontStruct *XLoadQueryFont(display, name)

     Display  *display;

     char  *name;

char *XLocaleOfFontSet(font_set)

     XFontSet  font_set;

char * XLocaleOfIM(im)

     XIM  im;

Status XLookupColor(display, colormap, color_name, exact_def_return, screen_def_return)

     Display  *display;

     Colormap  colormap;

     char  *color_name;

     XColor  *exact_def_return, *screen_def_return;

KeySym XLookupKeysym(key_event, index)

     XKeyEvent  *key_event;

     int  index;

int XLookupString(event_struct, buffer_return, bytes_buffer, keysym_return, status_in_out)

     XKeyEvent  *event_struct;

     char  *buffer_return;

     int  bytes_buffer;

     KeySym  *keysym_return;

     XComposeStatus  *status_in_out;

void XLowerWindow(display, w)

     Display  *display;

     Window  w;

void XMapRaised(display, w)

     Display  *display;

     Window  w;

void XMapSubwindows(display, w)

     Display  *display;

     Window  w;

void XMapWindow(display, w)

     Display  *display;

     Window  w;

void XMaskEvent(display, event_mask, event_return)

     Display  *display;

     long  event_mask;

     XEvent  *event_return;

Status XMatchVisualInfo(display, screen, depth, class, vinfo_return)

     Display  *display;

     int  screen, depth, class;

     XVisualInfo  *vinfo_return;

int XMaxCmapsOfScreen(screen)

      Screen  *screen;

long XMaxRequestSize(display)

        Display  *display;

void XmbDrawImageString(display, d, font_set, gc, x, y string, num_bytes)

     Display  *display

     Drawable  d;

     XFontSet  font_set;

     GC  gc;

     int  x, y;

     char  *string;

     int  num_bytes;

void XmbDrawString(display, d, font_set, gc, x, y, string, num_bytes)

     Display  *display;

     Drawable  d;

     XFontSet  font_set;

     GC  gc;

     int  x, y;

     char  *string;

     int  num_bytes;

void XmbDrawText(display, d, gc, x, y, items, nitems)

     Display  *display;

     Drawable  d;

     GC  gc;

     int  x, y;

     XmbTextItem  *items;

     int  nitems;

int XmbLookupString(ic, event, buffer_return, bytes_buffer, keysym_return,status_return)

     XIC  ic;

     XKeyPressedEvent  *event;

     char  *buffer_return;

     int  bytes_buffer;

     KeySym  *keysym_return;

     Status  *status_return;

char * XmbResetIC(ic)

      XIC  ic;

void XmbSetWMProperties(display, w, window_name, icon_name, argv, argc, normal_hints, wm_hints, class_hints)

     Display  *display;

     Window  w;

     char  *window_name, *icon_name, *argv[];

     int  argc;

     XSizeHints  *normal_hints;

     XWMHints  *wm_hints;

     XClassHint  *class_hints;

int XmbTextEscapement(font_set, string, num_bytes)

      XFontSet  font_set;

      char  *string;

      int  num_bytes;

int XmbTextExtents(font_set, string, num_bytes, overall_return)

      XFontSet  font_set;

      char  *string;

      int  num_bytes;

      XRectangle  *overall_ink_return, *overall_logical_return;

int XmbTextListToTextProperty(display, list, count, style, text_prop_return)

     Display  *display;

     char  **list;

     int  count;

     XICCEncodingStyle  style;

     XTextProperty  *text_prop_return;

Status XmbTextPerCharExtents(font_set, string, num_bytes, ink_array_return, logical_array_return, array_size, num_chars_return, overall_return)

      XFontSet  font_set;

      char  *string;

      int  num_bytes;

      XRectangle  *ink_array_return, *logical_array_return;

      int array_size, *um_chars_return;

      XRectangle *overall_ink_return, *overall_logical_return;

int XmbTextPropertyToTextList(display, text_prop, list_return, count_return)

     Display  *display;

     XTextProperty  *text_prop;

     char  ***list_return;

     int  *count_return;

int XMinCmapsOfScreen(screen)

      Screen  *screen;

void XMoveResizeWindow(display, w, x, y, width, height)

     Display  *display;

     Window  w;

     int  x, y;

     unsigned int   width, height;

void XMoveWindow(display, w, x, y)

     Display  *display;

     Window  w;

     int  x, y;

XModifierKeymap *XNewModifiermap(max_keys_per_mod)

     int  max_keys_per_mod;

void XNextEvent(display, event_return)

     Display  *display;

     XEvent  *event_return;

void XNoOp(display)

     Display  *display;

void XOffsetRegion(r, dx, dy)

     Region  r;

     int  dx, dy;

XDevice *XOpenDevice(display, device_id)

     Display  *display;

     XID  device_id;

Display *XOpenDisplay(display_name)

     char  *display_name;

XIM XOpenIM(display, db, res_name, res_class)

     Display  *display;

     XrmDatabase  db;

     char  *res_name;

     char  *res_class;

Status XParseColor(display, colormap, spec, exact_def_return)

     Display  *display;

     Colormap  colormap;

     char  *spec;

     XColor  *exact_def_return;

int XParseGeometry(parsestring, x_return, y_return, width_return, height_return)

     char  *parsestring;

     int  *x_return, *y_return, *width_return, *height_return;

void XPeekEvent(display, event_return)

     Display  *display;

     XEvent  *event_return;

void XPeekIfEvent(display, event_return, predicate, arg)

     Display  *display;

     XEvent  *event_return;

     Bool (*predicate)();

     XPointer  arg;

int XPending(display)

     Display  *display;

int XPlanesOfScreen(screen)

      Screen  *screen;

Bool XPointInRegion(r, x, y)

     Region  r;

     int  x, y;

Region XPolygonRegion(points, n, fill_rule)

     XPoint  *points;

     int  n, fill_rule;

int XProtocolRevision(display)

      Display  *display;

int XProtocolVersionR(display)

      Display  *display;

void XPutBackEvent(display, event)

     Display  *display;

     XEvent  *event;

void XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height)

     Display  *display;

     Drawable  d;

     GC  gc;

     XImage  *image;

     int  src_x, src_y, dest_x, dest_y;

     unsigned int   width, height;

XPutPixel(ximage, x, y, pixel)

     XImage  *ximage;

     int  x, y;

     unsigned long   pixel;

int XQLength(display)

      Display  *display;

Status XQueryBestCursor(display, d, width, height, width_return, height_return)

     Display  *display;

     Drawable  d;

     unsigned int   width, height, *width_return, *height_return;

Status XQueryBestSize(display, class, which_screen, width, height, width_return, height_return) 

     Display  *display;

     int  class;

     Drawable  which_screen;

     unsigned int   width, height, *width_return, *height_return;

Status XQueryBestStipple(display, which_screen, width, height, width_return, height_return) 

     Display  *display;

     Drawable  which_screen;

     unsigned int   width, height, *width_return, *height_return;

Status XQueryBestTile(display, which_screen, width, height, width_return, height_return) 

     Display  *display;

     Drawable  which_screen;

     unsigned int   width, height, *width_return, *height_return;

void XQueryColor(display, colormap, def_in_out)

     Display  *display;

     Colormap  colormap;

     XColor  *def_in_out;

void XQueryColors(display, colormap, defs_in_out, ncolors)

     Display  *display;

     Colormap  colormap;

     XColor  *defs_in_out;

     int  ncolors;

XDeviceState *XQueryDeviceState(display, device)

     Display  *display;

     XDevice  *device;

Bool XQueryExtension(display, name, major_opcode_return, first_event_return, first_error_return)

        Display  *display;

        char  *name;

        int  *major_opcode_return;

        int  *first_event_return;

        int  *first_error_return;

XFontStruct *XQueryFont(display, font_ID)

     Display  *display;

     XID  font_ID;

void XQueryKeymap(display, keys_return)

     Display  *display;

     char  keys_return[32];

Bool XQueryPointer(display, w, root_return, child_return, root_x_return, root_y_return, win_x_return, win_y_return, mask_return)

     Display  *display;

     Window  w, *root_return, *child_return;

     int  *root_x_return, *root_y_return, *win_x_return, *win_y_return;

     unsigned int   *mask_return;

void XQueryTextExtents(display, font_ID, string, nchars, direction_return, font_ascent_return, font_descent_return, overall_return)

     Display  *display;

     XID  font_ID;

     char  *string;

     int  nchars, *direction_return; 

     int  *font_ascent_return, *font_descent_return;

     XCharStruct  *overall_return;

void XQueryTextExtents16(display, font_ID, string, nchars, direction_return, font_ascent_return, font_descent_return, overall_return)

     Display  *display;

     XID  font_ID;

     XChar2b  *string;

     int  nchars, *direction_return;

     int  *font_ascent_return, *font_descent_return;

     XCharStruct  *overall_return;

Status XQueryTree(display, w, root_return, parent_return, children_return, nchildren_return)

     Display  *display;

     Window  w, *root_return, *parent_return, **children_return;

     unsigned int   *nchildren_return;

void XRaiseWindow(display, w)

     Display  *display;

     Window  w;

int XReadBitmapFile(display, d, filename, width_return, height_return, bitmap_return, x_hot_return, y_hot_return)

     Display  *display;

     Drawable  d;

     char  *filename;

     unsigned int   *width_return, *height_return;

     Pixmap  *bitmap_return;

     int  *x_hot_return, *y_hot_return;

void XRebindKeysym(display, keysym, list, mod_count, string, num_bytes)

     Display  *display;

     KeySym  keysym, *list;

     int  mod_count;

     unsigned char  *string;

     int  num_bytes;

void XRecolorCursor(display, cursor, foreground_color, background_color)

     Display  *display;

     Cursor  cursor;

     XColor  *foreground_color, *background_color;

Status XReconfigureWMWindow(display, w, screen_number, value_mask, values)

     Display  *display;

     Window  w;

     int  screen_number;

     unsigned int   value_mask;

     XWindowChanges  *values;

int XRectInRegion(r, x, y, width, height)

     Region  r;

     int  x, y;

     unsigned int   width, height;

void XRefreshKeyboardMapping(event_map)

     XMappingEvent  *event_map;

void XRemoveFromSaveSet(display, w)

     Display  *display;

     Window  w;

void XRemoveHost(display, host)

     Display  *display;

     XHostAddress  *host;

void XRemoveHosts(display, hosts, num_hosts)

     Display  *display;

     XHostAddress  *hosts;

     int  num_hosts;

void XReparentWindow(display, w, parent, x, y)

     Display  *display;

     Window  w, parent;

     int  x, y;

void XResetScreenSaver(display)

     Display  *display;

void XResizeWindow(display, w, width, height)

     Display  *display;

     Window  w;

     unsigned int   width, height;

char *XResourceManagerString(display)

     Display  *display;

void XRestackWindows(display, windows, nwindows)

     Display  *display;

     Window  *windows;

     int  nwindows;

void XrmCombineDatabase(source_db, target_db, override)

     XrmDatabase  source_db, *target_db;

     Bool  override;

void XrmCombineFileDatabase(filename, target_db, override)

     char  *filename;

     XrmDatabase  *target_db;

     Bool  override;

void XrmDestroyDatabase(database)

     XrmDatabase  database;

Bool XrmEnumerateDatabase(database, name_prefix, class_prefix, mode, proc, arg)

     XrmDatabase  database;

     XrmNameList  name_prefix;

     XrmClassList  class_prefix;

     int  mode;

     Bool  (*proc)();

     XPointer  arg;

XrmDatabase XrmGetDatabase(display)

     Display  *display;

XrmDatabase XrmGetFileDatabase(filename)

     char  *filename;

Bool XrmGetResource(database, str_name, str_class, str_type_return, value_return)

     XrmDatabase  database;

     char  *str_name, *str_class, **str_type_return;

     XrmValue  *value_return;

XrmDatabase XrmGetStringDatabase(data)

     char  *data;

void XrmInitialize();

void XrmMergeDatabases(source_db, target_db)

     XrmDatabase  source_db, *target_db;

void XrmParseCommand(database, table, table_count, name, argc_in_out, argv_in_out,)

     XrmDatabase  *database;

     XrmOptionDescList  table;

     int  table_count;

     char  *name;

     int  *argc_in_out;

     char  **argv_in_out;

XrmQuark XrmPermStringToQuark(string)

     char  *string;

void XrmPutFileDatabase(database, stored_db)

     XrmDatabase  database;

     char  *stored_db;

void XrmPutLineResource(database, line)

     XrmDatabase  *database;

     char  *line;

void XrmPutResource(database, specifier, type, value)

     XrmDatabase  *database;

     char  *specifier, *type;

     XrmValue  *value;

void XrmPutStringResource(database, specifier, value)

     XrmDatabase  *database;

     char  *specifier, *value;

Bool XrmQGetResource(database, quark_name, quark_class, quark_type_return, value_return)

     XrmDatabase  database;

     XrmNameList  quark_name;

     XrmClassList  quark_class;

     XrmRepresentation  *quark_type_return;

     XrmValue  *value_return;

Bool XrmQGetSearchList(database, names, classes, list_return, list_length)

     XrmDatabase  database;

     XrmNameList  names;

     XrmClassList  classes;

     XrmSearchList  list_return;

     int  list_length;

Bool XrmQGetSearchResource(list, name, class, type_return, value_return)

     XrmSearchList  list;

     XrmName  name;

     XrmClass  class;

     XrmRepresentation  *type_return;

     XrmValue  *value_return;

void XrmQPutResource(database, bindings, quarks, type, value)

     XrmDatabase  *database;

     XrmBindingList  bindings;

     XrmQuarkList  quarks;

     XrmRepresentation  type;

     XrmValue  *value;

void XrmQPutStringResource(database, bindings, quarks, value)

     XrmDatabase  *database;

     XrmBindingList  bindings;

     XrmQuarkList  quarks;

     char  *value;

XrmString *XrmQuarkToString(quark)

     XrmQuark  quark;

void XrmSetDatabase(display, database)

     Display  *display;

     XrmDatabase  database;

void XrmStringToBindingQuarkList(string, bindings_return, quarks_return)

     char  *string;

     XrmBindingList  bindings_return;

     XrmQuarkList  quarks_return;

XrmQuark XrmStringToQuark(string)

     char  *string;

void XrmStringToQuarkList(string, quarks_return)

     char  *string;

     XrmQuarkList  quarks_return;

XrmQuark XrmUniqueQuark()

Window XRootWindow(display, screen_number)

      Display  *display;

      int  screen_number;

Window XRootWindowOfScreen(screen)

      Screen  *screen;

void XRotateBuffers(display, rotate)

     Display  *display;

     int  rotate;

void XRotateWindowProperties(display, w, properties, num_prop, npositions)

     Display  *display;

     Window  w;

     Atom  *properties;

     int  num_prop, npositions;

int XSaveContext(display, rid, context, data)

     Display  *display;

     XID  rid;

     XContext  context;

     XPointer  data;

int XScreenCount(display)

      Display  *display;

int XScreenNumberOfScreen(screen)

     Screen  *screen;

Screen *XScreenOfDisplay(display, screen_number)

      Display  *display;

      int  screen_number;

char *XScreenResourceString(screen)

     Screen *screen;

int XSelectExtensionEvent(display, w, event_list, event_count)

     Display  *display;

     Window  w;

     XEventClass  *event_list;

     int  event_count;

void XSelectInput(display, w, event_mask)

     Display  *display;

     Window  w;

     long  event_mask;

Status XSendEvent(display, w, propagate, event_mask, event_send)

     Display  *display;

     Window  w;

     Bool  propagate;

     long  event_mask;

     XEvent  *event_send;

Status XSendExtensionEvent(display, device, destination, propagate, event_count, event_list, event_send)

     Display  *display;

     XDevice  *device;

     Window  destination;

     Bool  propagate;

     int  event_count;

     XEventClass  *event_list;

     XEvent  *event_send;

char *XServerVendor(display)

      Display  *display;

void XSetAccessControl(display, mode)

     Display  *display;

     int  mode;

int (*XSetAfterFunction(display, procedure))()

     Display  *display;

     int (*procedure)();

void XSetArcMode(display, gc, arc_mode)

     Display  *display;

     GC  gc;

     int  arc_mode;

void XSetBackground(display, gc, background)

     Display  *display;

     GC  gc;

     unsigned long   background;

void XSetClassHint(display, w, class_hints)

     Display  *display;

     Window  w;

     XClassHint  *class_hints;

void XSetClipMask(display, gc, pixmap)

     Display  *display;

     GC  gc;

     Pixmap  pixmap;

void XSetClipOrigin(display, gc, clip_x_origin, clip_y_origin)

     Display  *display;

     GC  gc;

     int  clip_x_origin, clip_y_origin;

void XSetClipRectangles(display, gc, clip_x_origin, clip_y_origin, rectangles, n, ordering)

     Display  *display;

     GC  gc;

     int  clip_x_origin, clip_y_origin;

     XRectangle  *rectangles;

     int  n, ordering;

void XSetCloseDownMode(display, close_mode)

     Display  *display;

     int  close_mode;

void XSetCommand(display, w, argv, argc)

     Display  *display;

     Window  w;

     char  **argv;

     int  argc;

void XSetDashes(display, gc, dash_offset, dash_list, n)

     Display  *display;

     GC  gc;

     int  dash_offset;

     char  *dash_list;

     int  n;

int XSetDeviceButtonMapping(display, device, map, nmap)

     Display  *display;

     XDevice  *device;

     unsigned char  map[];

     int  nmap;

int XSetDeviceFocus(display, device, focus, revert_to, time)

     Display  *display, *device;

     Window  focus;

     int  revert_to;

     Time  time;

int XSetDeviceMode(display, device, mode)

     Display  *display;

     XDevice  *device;

     int  mode;

int XSetDeviceModifierMapping(display, device, modmap)

     Display  *display;

     XDevice  *device;

     XModifierKeymap  *modmap;

int XSetDeviceValuators(display, device, valuators, first_valuator, num_valuators)

     Display  *display;

     XDevice  *device;

     int  *valuators;

     int  first_valuator;

     int  num_valuators;

int (*XSetErrorHandler(handler))()

      int(*handler)(Display *, XErrorEvent *)

void XSetFillRule(display, gc, fill_rule)

     Display  *display;

     GC  gc;

     int  fill_rule;

void XSetFillStyle(display, gc, fill_style)

     Display  *display;

     GC  gc;

     int  fill_style;

void XSetFont(display, gc, font)

     Display  *display;

     GC  gc;

     Font  font;

void XSetFontPath(display, directories, ndirs)

     Display  *display;

     char  **directories;

     int  ndirs;

void XSetForeground(display, gc, foreground)

     Display  *display;

     GC  gc;

     unsigned long   foreground;

void XSetFunction(display, gc, function)

     Display  *display;

     GC  gc;

     int  function;

void XSetGraphicsExposures(display, gc, graphics_exposures)

     Display  *display;

     GC  gc;

     Bool  graphics_exposures;

void XSetICFocus(ic)

     XIC  ic;

char * XSetICValues(ic, ...)

     XIC  ic;

void XSetIconName(display, w, icon_name)

     Display  *display;

     Window  w;

     char  *icon_name;

void XSetIconSizes(display, w, size_list, count)

     Display  *display;

     Window  w;

     XIconSize  *size_list;

     int  count;

void XSetInputFocus(display, focus, revert_to, time)

     Display  *display;

     Window  focus;

     int  revert_to;

     Time  time;

int(*XSetIOErrorHandler(handler))()

      int(*handler)

void XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style)

     Display  *display;

     GC  gc;

     unsigned int   line_width;

     int  line_style, cap_style, join_style;

char *XSetLocaleModifiers(modifier_list)

   char  *modifier_list;

int XSetModifierMapping(display, modmap)

     Display  *display;

     XModifierKeymap  *modmap;

void XSetPlaneMask(display, gc, plane_mask)

     Display  *display;

     GC  gc;

     unsigned long   plane_mask;

int XSetPointerMapping(display, map, nmap)

     Display  *display;

     unsigned char  map[];

     int  nmap;

void XSetRegion(display, gc, r)

     Display  *display;

     GC  gc;

     Region  r;

void XSetRGBColormaps(display, w, std_colormap, count, property)

     Display  *display;

     Window  w;

     XStandardColormap  *std_colormap;

     int  count;

     Atom  property;

void XSetScreenSaver(display, timeout, interval, prefer_blanking, allow_exposures)

     Display  *display;

     int  timeout, interval, prefer_blanking, allow_exposures;

void XSetSelectionOwner(display, selection, owner, time)

     Display  *display;

     Atom  selection;

     Window  owner;

     Time  time;

void XSetState(display, gc, foreground, background, function, plane_mask)

     Display  *display;

     GC  gc;

     unsigned long  foreground, background;

     int  function;

     unsigned long  plane_mask;

void XSetStipple(display, gc, stipple)

     Display  *display;

     GC  gc;

     Pixmap  stipple;

void XSetSubwindowMode(display, gc, subwindow_mode)

     Display  *display;

     GC  gc;

     int  subwindow_mode;

void XSetTextProperty(display, w, text_prop, property)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop;

     Atom  property;

void XSetTile(display, gc, tile)

     Display  *display;

     GC  gc;

     Pixmap  tile;

void XSetTransientForHint(display, w, prop_window)

     Display  *display;

     Window  w, prop_window;

void XSetTSOrigin(display, gc, ts_x_origin, ts_y_origin)

     Display  *display;

     GC  gc;

     int  ts_x_origin, ts_y_origin;

void XSetWindowBackground(display, w, background_pixel)

     Display  *display;

     Window  w;

     unsigned long   background_pixel;

void XSetWindowBackgroundPixmap(display, w, background_pixmap)

     Display  *display;

     Window  w;

     Pixmap  background_pixmap;

void XSetWindowBorder(display, w, border_pixel)

     Display  *display;

     Window  w;

     unsigned long   border_pixel;

void XSetWindowBorderPixmap(display, w, border_pixmap)

     Display  *display;

     Window  w;

     Pixmap  border_pixmap;

void XSetWindowBorderWidth(display, w, width)

     Display  *display;

     Window  w;

     unsigned int   width;

void XSetWindowColormap(display, w, colormap)

     Display  *display;

     Window  w;

     Colormap  colormap;

void XSetWMClientMachine(display, w, text_prop)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop;

Status XSetWMColormapWindows(display, w, colormap_windows, count)

     Display  *display;

     Window  w, *colormap_windows;

     int  count;

void XSetWMHints(display, w, wmhints)

     Display  *display;

     Window  w;

     XWMHints  *wmhints;

void XSetWMIconName(display, w, text_prop)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop;

void XSetWMName(display, w, text_prop)

     Display  *display;

     Window  w;

     XTextProperty  *text_prop;

void XSetWMNormalHints(display, w, hints)

     Display  *display;

     Window  w;

     XSizeHints  *hints;

void XSetWMProperties(display, w, window_name, icon_name, argv, argc, normal_hints, wm_hints, class_hints)

     Display  *display;

     Window  w;

     XTextProperty  *window_name, *icon_name;

     char  **argv;

     int  argc;

     XSize_hints  *normal_hints;

     XWMHints  *wm_hints;

     XClassHint  *class_hints;

Status XSetWMProtocols(display, w, protocols, count)

     Display  *display;

     Window  w;

     Atom  *protocols;

     int  count;

void XSetWMSizeHints(display, w, hints, property)

     Display  *display;

     Window  w;

     XSizeHints  *hints;

     Atom  property;

void XShrinkRegion(r, dx, dy)

     Region  r;

     int  dx, dy;

void XStoreBuffer(display, bytes, nbytes, buffer)

     Display  *display;

     char  *bytes;

     int  nbytes, buffer;

void XStoreBytes(display, bytes, nbytes)

     Display  *display;

     char  *bytes;

     int  nbytes;

void XStoreColor(display, colormap, color)

     Display  *display;

     Colormap  colormap;

     XColor  *color;

void XStoreColors(display, colormap, color, ncolors)

     Display  *display;

     Colormap  colormap;

     XColor  *color;

     int  ncolors;

void XStoreName(display, w, window_name)

     Display  *display;

     Window  w;

     char  *window_name;

XStoreNamedColor(display, colormap, color, pixel, flags)

     Display  *display;

     Colormap  colormap;

     char  *color;

     unsigned long   pixel;

     int  flags;

Status XStringListToTextProperty(list, count, text_prop_return)

     char  **list;

     int  count;

     XTextProperty  *text_prop_return;

KeySym XStringToKeysym(string)

     char  *string;

XImage *XSubImage(ximage, x, y, subimage_width, subimage_height)

     XImage  *ximage;

     int  x, y;

     unsigned int   subimage_width, subimage_height;

void XSubtractRegion(sra, srb, dr_return)

     Region  sra, srb, dr_return;

Bool XSupportsLocale()

void XSync(display, discard)

     Display  *display;

     Bool  discard;

int(*XSynchronize(display, onoff))()

     Display  *display;

     Bool  onoff;

void XTextExtents(font_struct, string, nchars, direction_return, font_ascent_return, font_descent_return, overall_return)

     XFontStruct  *font_struct;

     char  *string;

     int  nchars, *direction_return;

     int  *font_ascent_return, *font_descent_return;

     XCharStruct  *overall_return;

void XTextExtents16(font_struct, string, nchars, direction_return, font_ascent_return, font_descent_return, overall_return)

     XFontStruct  *font_struct;

     XChar2b  *string;

     int  nchars, *direction_return;

     int  *font_ascent_return, *font_descent_return;

     XCharStruct  *overall_return;

Status XTextPropertyToStringList(text_prop, list_return, count_return)

     XTextProperty  *text_prop;

     char  ***list_return;

     int  *count_return;

int XTextWidth(font_struct, string, count)

     XFontStruct  *font_struct;

     char  *string;

     int  count;

int XTextWidth16(font_struct, string, count)

     XFontStruct  *font_struct;

     XChar2b  *string;

     int  count;

Bool XTranslateCoordinates(display, src_w, dest_w, src_x, src_y, dest_x_return, dest_y_return, child_return)

     Display  *display;

     Window  src_w, dest_w;

     int  src_x, src_y, *dest_x_return, *dest_y_return;

     Window  *child_return;

void XUndefineCursor(display, w)

     Display  *display;

     Window  w;

void XUngrabButton(display, button, modifiers, grab_window)

     Display  *display;

     unsigned int   button, modifiers;

     Window  grab_window;

int XUngrabDevice(display, device, time)

     Display  *display;

     XDevice  *device;

     Time  time;

void XUngrabDeviceButton(display, device, button, modifiers, modfier_device, grab_window)

     Display  *display;

     XDevice  *device, *modifier_device;

     unsigned int   button, modifiers;

     Window  grab_window;

int XUngrabDeviceKey(display, device, Key, modifiers, modifier_device, grab_window)

     Display  *display;

     XDevice  *device, *modifier_device;

     unsigned int   Key, modifiers;

     Window  grab_window;

int XUngrabKey(display, keycode, modifiers, grab_window)

     Display  *display;

     int  keycode;

     unsigned int   modifiers;

     Window  grab_window;

void XUngrabKeyboard(display, time)

     Display  *display;

     Time  time;

void XUngrabPointer(display, time)

     Display  *display;

     Time  time;

void XUngrabServer(display)

     Display  *display;

void XUninstallColormap(display, colormap)

     Display  *display;

     Colormap  colormap;

void XUnionRectWithRegion(rectangle, src_region, dest_region_return)

     XRectangle  *rectangle;

     Region  src_region, dest_region_return;

void XUnionRegion(sra, srb, dr_return)

     Region  sra, srb, dr_return;

XContext XUniqueContext()

void XUnloadFont(display, font)

     Display  *display;

     Font  font;

void XUnmapSubwindows(display, w)

     Display  *display;

     Window  w;

void XUnmapWindow(display, w)

     Display  *display;

     Window  w;

void XUnsetICFocus(ic)

     XIC  ic;

XVaNestedList XVaCreateNestedList(dummy, ...)

      int  dummy;

int XVendorRelease(display)

      Display  *display;

VisualID XVisualIDFromVisual(visual)

     Visual  *visual;

void XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y)

     Display  *display;

     Window  src_w, dest_w;

     int  src_x, src_y;

     unsigned int   src_width, src_height;

     int  dest_x, dest_y;

void XwcDrawImageString(display, d, font_set, gc, x, y, string, num_wchars)

     Display  *display;

     Drawable  d;

     XFontSet  font_set;

     GC  gc;

     int  x, y, num_wchars;

     wchar_t  *string;

void XwcDrawString(display, d, font_set, gc,

x, y, string, num_wchars)

     Display  *display;

     Drawable  d;

     XFontSet  font_set;

     GC  gc;

     int  x, y, num_wchars;

     wchar_t  *string;

void XwcDrawText(display, d, gc, x, y, items, nitems)

      Display  *display;

      Drawable  d;

      GC  gc;

      int  x, y;

      XwcTextItem  *items;

      int  nitems;

void XwcFreeStringList(list)

      wchar_t  **list;

int XwcLookupString(ic, event, buffer_return, bytes_buffer, keysym_return, status_return)

      XIC  ic;

      XKeyPressedEvent  *event;

      wchar_t  *buffer_return;

      int  wchars_buffer;

      KeySym  *keysym_return;

      Status  *status_return;

wchar_t * XwcResetIC(ic)

      XIC  ic;

int XwcTextEscapement(font_set, string, num_wchars)

      XFontSet  font_set;

      wchar_t  *string;

      int  num_wchars;

int XwcTextExtents(font_set, string, num_wchars, overall_return)

      XFontSet  font_set;

      wchar_t  *string;

      int  num_wchars;

      XRectangle  *overall_ink_return;

      XRectangle  *overall_logical_return;

int XwcTextListToTextProperty(display, list, count, style, text_prop_return)

      Display  *display;

      wchar_t  **list;

      int  count;

      XICCEncodingStyle  style;

      XTextProperty  *text_prop_return;

Status XwcTextPerCharExtents(font_set, string, num_wchars, ink_array_return, logical_array_return, array_size, num_chars_return, overall_return)

      XFontSet  font_set;

      wchar_t  *string;

      int  num_wchars;

      XRectangle *ink_array_return, *logical_array_return;

      int array_size, *num_chars_return;

      XRectangle *overall_ink_return, *overall_logical_return;

int XwcTextPropertyToTextList(display, text_prop, list_return, count_return)

      Display  *display;

      XTextProperty  *text_prop;

      wchar_t  ***list_return;

      int  *count_return;

unsigned long XWhitePixel(display, screen_number)

      Display  *display;

      int  screen_number;

unsigned long XWhitePixelOfScreen(screen)

      Screen  *screen;

int XWidthOfScreen(screen)

      Screen  *screen;

int XWidthMMOfScreen(screen)

      Screen  *screen;

void XWindowEvent(display, w, event_mask, event_return)

     Display  *display;

     Window  w;

     long  event_mask;

     XEvent  *event_return;

Status XWithdrawWindow(display, w, screen_number)

     Display  *display;

     Window  w;

     int  screen_number;

int XWMGeometry(display, screen, user_geom, def_geom, bwidth, hints, x_return, y_return, width_return, height_return, gravity_return)

     Display  *display;

     int  screen;

     char  *user_geom, *def_geom;

     unsigned int   bwidth;

     XSizeHints  *hints;

     int  *x_return, *y_return, *width_return;

     int  *height_return, *gravity_return;

int XWriteBitmapFile(display, filename, bitmap, width, height, x_hot, y_hot)

     Display  *display;

     char  *filename;

     Pixmap  bitmap;

     unsigned int   width, height;

     int  x_hot, y_hot;

XXorRegion(sra, srb, dr_return)

     Region  sra, srb, dr_return;

Chapter 2 X11 R5 Xlib Functions

Technical documentation

» Table of Contents