/* $Id: ps_requests.c,v 1.3 90/11/30 11:49:03 altenhof Exp $ */

/*
 * Copyright (C) 1990 by Digital Equipment Corporation.
 * 
 * Author: Michael P. Altenhofen, CEC Karlsruhe e-mail:
 * Altenhofen@kampus.enet.dec.com
 * 
 * This file ist part of Shared X
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation without fee is hereby granted, but only for non-profit  use
 * and distribution,  and provided  that the copyright notice and this notice
 * is preserved on all copies.
 * 
 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

#include <X11/Xatom.h>

#define MotionMasks (PointerMotionMask|ButtonMotionMask|\
		     Button1MotionMask|Button2MotionMask|\
		     Button3MotionMask|Button4MotionMask|\
		     Button5MotionMask|PointerMotionHintMask)

#define PUBLIC extern

#define _USE_STRUCTS_		/* we need this stuff here ... */
#define _USE_PROTO_		/* ... we deal with protocol request ... */
#define NEED_EVENTS		/* ... and events ( in SendEvent ) ... */

#include "glob.h"
#include "utils.h"
#include "resources.h"
#include "build.h"
#include "map.h"

#undef PUBLIC

#include "requestnames.h"	/* mapping req type -> req string */

/* -- some frequently used macros -- */

#define GETDISPLAY( dpy , client ) \
          if( ( dpy = XDisplay( client ) ) == NULL )\
          {\
              ErrorF( "Can't find display of client %d!\n" , \
                                 ClientConnection( client ) ) ; \
              return( BadValue ) ;\
          }

#define MAPID( res , id , map , from_where ) \
         if( ( (res) = MapID( id , (map) , from_where ) ) == InvalidID )\
          {\
              ErrorF( "Can't proceed (ID map failure)!\n " ) ;\
	      return( BadIDChoice ) ;\
	  }

#define GETGC( gc , client , gid) \
          if( ( gc = GetGCFromResources( client , gid ) ) == ( GC ) NULL ) \
          {\
	       ErrorF( "Can't proceed (GC not found)!\n" ) ;\
	       return( BadGC ) ; \
	  }

static Display *dpy;
static Mask PSSpecificMask = StructureNotifyMask | ButtonPressMask;


int
_ProcBadRequest (client)
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  return (BadImplementation);
}

int
_ProcCreateWindow (client)
  ClientPtr client;
{
  register XID parent, win;
  register xCreateWindowReq *req =
  (xCreateWindowReq *) client->requestBuffer;
  XSetWindowAttributes attributes;
  Visual visual;
  register int idmap;
  Mask exclusion_mask;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (parent, req->parent, idmap, FromClient);

  PSBuildSetWindowAttributes (req->mask,
			      (xChangeWindowAttributesReq *) & req[1],
			      &attributes, idmap);
  /*
   * two cases :
   * a) req->visual == CopyFromParent --> pass CopyFromParent
   * b) req->visual == a visual id --> pass visual with
   *        visual.visualid = mapped req->visual
   */

  if (req->visual != CopyFromParent) {
    visual.visualid = MapID (req->visual, idmap, FromClient);
    win = XCreateWindow (dpy, parent, req->x, req->y,
			 req->width, req->height, req->borderWidth,
			 (int) req->depth,
			 req->class, &visual,
			 req->mask, &attributes);
  }
  else
    win = XCreateWindow (dpy, parent, req->x, req->y,
			 req->width, req->height, req->borderWidth,
			 (int) req->depth,
			 req->class, CopyFromParent,
			 req->mask, &attributes);
  if (win) {
    InsertID (req->wid, win, idmap, FromClient);
    InsertID (win, req->wid, idmap, FromServer);
  }
  return (client->noClientException);
}

int
_ProcChangeWindowAttributes (client)
  ClientPtr client;
{
  register xChangeWindowAttributesReq *req =
    (xChangeWindowAttributesReq *) client->requestBuffer;
  XSetWindowAttributes attributes;
  register XID win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);
  PSBuildSetWindowAttributes (req->valueMask, &req[1],
			      &attributes, ConnectionNumber (dpy));
  XChangeWindowAttributes (dpy, win, req->valueMask, &attributes);
  return (client->noClientException);
}

#define WINDOW 0
#define SUBWINDOWS 1

int
_ProcDestroyWindow (client)
  ClientPtr client;
{
  register xResourceReq *req =
  (xResourceReq *) client->requestBuffer;
  register XID window;
  XID *child_ids;
  register int idmap, client_fd;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  client_fd = ClientConnection (client);
  MAPID (window, req->id, idmap, FromClient);
  XDestroyWindow (dpy, window);
  RemoveEventExclusionMask (req->id, ClientConnection (client));
  RemoveID (req->id, idmap, FromClient);
  RemoveID (window, idmap, FromServer);

  return (client->noClientException);
}

int
_ProcDestroySubwindows (client)	/* 5 */
  ClientPtr client;
{
  register xResourceReq *req =
  (xResourceReq *) client->requestBuffer;
  register XID window, *child_ids;
  register int client_fd, idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (window, req->id, idmap, FromClient);
  XDestroySubwindows (dpy, window);

  client_fd = ClientConnection (client);

  RemoveEventExclusionMask (req->id, ClientConnection (client));
  RemoveID (req->id, idmap, FromClient);
  RemoveID (window, idmap, FromServer);
  return (client->noClientException);
}

#undef WINDOW
#undef SUBWINDOWS

int
_ProcChangeSaveSet (client)
  ClientPtr client;
{
  register xChangeSaveSetReq *req =
  (xChangeSaveSetReq *) client->requestBuffer;
  register XID window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->window, ConnectionNumber (dpy), FromClient);
  XChangeSaveSet (dpy, window, req->mode);
  return (client->noClientException);
}

int
_ProcReparentWindow (client)
  ClientPtr client;
{
  register xReparentWindowReq *req =
  (xReparentWindowReq *) client->requestBuffer;
  register XID window, parent;

  GETDISPLAY (dpy, client);
  MAPID (window, req->window, ConnectionNumber (dpy), FromClient);
  MAPID (parent, req->parent, ConnectionNumber (dpy), FromClient);
  XReparentWindow (dpy, window, parent, req->x, req->y);
  return (client->noClientException);
}

int
_ProcMapWindow (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register XID win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->id, ConnectionNumber (dpy), FromClient);
  XMapWindow (dpy, win);
  return (client->noClientException);
}

int
_ProcMapSubwindows (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;

  register XID win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->id, ConnectionNumber (dpy), FromClient);
  XMapSubwindows (dpy, win);
  return (client->noClientException);
}

int
_ProcUnmapWindow (client)	/* 10 */
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;

  register XID window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->id, ConnectionNumber (dpy), FromClient);
  XUnmapWindow (dpy, window);
  return (client->noClientException);
}

int
_ProcUnmapSubwindows (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register XID window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->id, ConnectionNumber (dpy), FromClient);
  XUnmapSubwindows (dpy, window);
  return (client->noClientException);
}

int
_ProcConfigureWindow (client)
  ClientPtr client;
{
  register xConfigureWindowReq *req =
  (xConfigureWindowReq *) client->requestBuffer;

  register XID win;
  XWindowChanges changes;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);
  PSBuildWindowChanges (req->mask, &req[1], &changes,
			ConnectionNumber (dpy));
  XConfigureWindow (dpy, win, req->mask, &changes);
  return (client->noClientException);
}

int
_ProcCirculateWindow (client)
  ClientPtr client;
{
  register xCirculateWindowReq *req =
  (xCirculateWindowReq *) client->requestBuffer;
  register XID window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->window, ConnectionNumber (dpy), FromClient);
  XCirculateSubwindows (dpy, window, req->direction);
  return (client->noClientException);
}

int
_ProcChangeProperty (client)
  ClientPtr client;
{
  register xChangePropertyReq *req =
  (xChangePropertyReq *) client->requestBuffer;
  register XID win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);

  /*
   * Check "long" ( format == 32 ) properties
   * they may contain resource ID's !
   */
  if (req->format == 32)
    PSBuildProperty (req->type, (char *) &req[1], req->nUnits,
		     ConnectionNumber (dpy), FromClient);

  XChangeProperty (dpy, win, req->property, req->type,
		   req->format,
		   req->mode, (unsigned char *) &req[1],
		   req->nUnits);

  return (client->noClientException);
}

int
_ProcDeleteProperty (client)
  ClientPtr client;
{
  register xDeletePropertyReq *req =
  (xDeletePropertyReq *) client->requestBuffer;
  register Window win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);
  XDeleteProperty (dpy, win, req->property);
  return (client->noClientException);
}

int
_ProcSetSelectionOwner (client)
  ClientPtr client;
{
  register xSetSelectionOwnerReq *req =
  (xSetSelectionOwnerReq *) client->requestBuffer;
  register Window win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);
  XSetSelectionOwner (dpy, req->selection, win, req->time);

  return (client->noClientException);
}

int
_ProcConvertSelection (client)
  ClientPtr client;
{
  register xConvertSelectionReq *req =
  (xConvertSelectionReq *) client->requestBuffer;
  register XID requestor;

  GETDISPLAY (dpy, client);
  MAPID (requestor, req->requestor, ConnectionNumber (dpy),
	 FromClient);
  XConvertSelection (dpy, req->selection, req->target, req->property,
		     requestor, req->time);
  return (client->noClientException);
}


int
_ProcSendEvent (client)		/* 25 */
  ClientPtr client;
{
  register xSendEventReq *req = (xSendEventReq *) client->requestBuffer;
  XEvent event;
  register XID window;

  /* there is a bug in dxcalendar we can fix here */

#ifdef FIX_EVENT_MASK
#define AllMasks ((OwnerGrabButtonMask)|(OwnerGrabButtonMask-1))
  if (req->eventMask & ~AllMasks)
    req->eventMask = AllMasks;
#undef  AllMasks
#endif

  GETDISPLAY (dpy, client);

  if (req->destination == PointerWindow)
    window = PointerWindow;
  else if (req->destination == InputFocus)
    window = InputFocus;
  else
    window = MapIDTryHard (req->destination, FromClient);

  if (!WireToEvent (dpy, &event, &req->event,
		    ConnectionNumber (dpy))) {
    ErrorF ("Event translation failed!\n");
    return (BadValue);
  }

  XSendEvent (dpy, window, req->propagate, req->eventMask, &event);
  return (client->noClientException);
}

int
_ProcUngrabPointer (client)
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);

  /* Make sure that pointer will be ungrabbed -- */
  XUngrabPointer (dpy, CurrentTime);
  return (client->noClientException);
}

int
_ProcGrabButton (client)
  ClientPtr client;
{
  register xGrabButtonReq *req =
  (xGrabButtonReq *) client->requestBuffer;
  register XID grab_window, confine_to, cursor;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (grab_window, req->grabWindow, idmap, FromClient);
  confine_to = None;
  if (req->confineTo)
    MAPID (confine_to, req->confineTo, idmap, FromClient);
  cursor = None;
  if (req->cursor)
    MAPID (cursor, req->cursor, idmap, FromClient);
  debug (_debug_requests, "(grab=0x%lx) send (# 0x%lx)...\n",
	 grab_window, client->sequence);
  XGrabButton (dpy,
	       req->button,
	       req->modifiers,
	       grab_window,
	       req->ownerEvents,
	       req->eventMask,
	       req->pointerMode,
	       req->keyboardMode,
	       confine_to,
	       cursor
    );
  return (client->noClientException);
}

int
_ProcUngrabButton (client)
  ClientPtr client;
{
  register xUngrabButtonReq *req =
  (xUngrabButtonReq *) client->requestBuffer;
  register XID grab_window;

  GETDISPLAY (dpy, client);
  MAPID (grab_window, req->grabWindow, ConnectionNumber (dpy),
	 FromClient);
  XUngrabButton (dpy, req->button, req->modifiers, grab_window);
  return (client->noClientException);
}

int
_ProcChangeActivePointerGrab (client)	/* 30 */
  ClientPtr client;
{
  register xChangeActivePointerGrabReq *req =
  (xChangeActivePointerGrabReq *) client->requestBuffer;
  register Cursor cursor;

  GETDISPLAY (dpy, client);
  MAPID (cursor, req->cursor, ConnectionNumber (dpy), FromClient);
  XChangeActivePointerGrab (dpy, req->eventMask, cursor, req->time);
  return (client->noClientException);
}

int
_ProcUngrabKeyboard (client)
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XUngrabKeyboard (dpy, req->data);
  return (client->noClientException);
}

int
_ProcGrabKey (client)
  ClientPtr client;
{
  register xGrabKeyReq *req = (xGrabKeyReq *) client->requestBuffer;
  register XID grab_window;

  GETDISPLAY (dpy, client);
  MAPID (grab_window, req->grabWindow, ConnectionNumber (dpy),
	 FromClient);
  XGrabKey (dpy, req->key, req->modifiers, grab_window,
	    req->ownerEvents, req->pointerMode, req->keyboardMode);
  return (client->noClientException);
}

int
_ProcUngrabKey (client)
  ClientPtr client;
{
  register xUngrabKeyReq *req = (xUngrabKeyReq *) client->requestBuffer;
  register XID grab_window;

  GETDISPLAY (dpy, client);
  MAPID (grab_window, req->grabWindow, ConnectionNumber (dpy),
	 FromClient);
  XUngrabKey (dpy, req->key, req->modifiers, grab_window);
  return (client->noClientException);

}

int
_ProcAllowEvents (client)	/* 35 */
  ClientPtr client;
{
  register xAllowEventsReq *req = (xAllowEventsReq *)
  client->requestBuffer;

  GETDISPLAY (dpy, client);
  XAllowEvents (dpy, req->mode, req->time);
  return (client->noClientException);
}

int
_ProcGrabServer (client)
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XGrabServer (dpy);
  return (client->noClientException);
}

int
_ProcUngrabServer (client)
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XUngrabServer (dpy);
  return (client->noClientException);
}

int
_ProcWarpPointer (client)
  ClientPtr client;
{
  register xWarpPointerReq *req = (xWarpPointerReq *)
  client->requestBuffer;
  register XID src_window, dst_window;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  src_window =
    dst_window = None;
  if (req->srcWid)
    MAPID (src_window, req->srcWid, idmap, FromClient);
  if (req->dstWid)
    MAPID (dst_window, req->dstWid, idmap, FromClient);
  XWarpPointer (dpy, src_window, dst_window, req->srcX, req->srcY,
		req->srcWidth, req->srcHeight, req->dstX, req->dstY);
  return (client->noClientException);
}

int
_ProcSetInputFocus (client)
  ClientPtr client;
{
  register xSetInputFocusReq *req =
  (xSetInputFocusReq *) client->requestBuffer;
  register XID focus;

  GETDISPLAY (dpy, client);
  MAPID (focus, req->focus, ConnectionNumber (dpy), FromClient);
  XSetInputFocus (dpy, focus, req->revertTo, req->time);
  return (client->noClientException);
}

int
_ProcOpenFont (client)		/* 45 */
  ClientPtr client;
{
  register xOpenFontReq *req = (xOpenFontReq *) client->requestBuffer;
  register int idmap;
  XFontStruct *font_info = (XFontStruct *) NULL;
  char *name = NULL;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  if ((name = (char *) Xmalloc (req->nbytes + 1)) == NULL)
    return (BadAlloc);

  bcopy ((char *) &req[1], name, req->nbytes);
  name[req->nbytes] = '\0';
  font_info = XLoadQueryFont (dpy, name);
  Xfree (name);
  if (font_info) {
    InsertID (req->fid, font_info->fid, idmap, FromClient);
    InsertID (font_info->fid, req->fid, idmap, FromServer);
    Xfree ((char *) font_info);
    return (client->noClientException);
  }
  else
    return (BadName);
}

int
_ProcCloseFont (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register XID font;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (font, req->id, idmap, FromClient);
  XUnloadFont (dpy, font);
  RemoveID (font, idmap, FromServer);
  RemoveID (req->id, idmap, FromClient);
  return (client->noClientException);
}

int
_ProcSetFontPath (client)
  ClientPtr client;
{
  register xSetFontPathReq *req =
  (xSetFontPathReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XSetFontPath (dpy, (char **) &req[1], req->nFonts);
  return (client->noClientException);

}

int
_ProcCreatePixmap (client)
  ClientPtr client;
{
  register xCreatePixmapReq *req =
  (xCreatePixmapReq *) client->requestBuffer;
  register int idmap;
  register XID drawable, pixmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (drawable, req->drawable, idmap, FromClient);
  pixmap = XCreatePixmap (dpy, drawable, req->width,
			  req->height, req->depth);
  if (pixmap) {
    InsertID (req->pid, pixmap, idmap, FromClient);
    InsertID (pixmap, req->pid, idmap, FromServer);
    return (client->noClientException);
  }
  else
    return (BadAlloc);
}

int
_ProcFreePixmap (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register XID pixmap;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (pixmap, req->id, idmap, FromClient);
  XFreePixmap (dpy, pixmap);
  RemoveID (req->id, idmap, FromClient);
  RemoveID (pixmap, idmap, FromServer);
  return (client->noClientException);
}

int
_ProcCreateGC (client)
  ClientPtr client;
{
  register xCreateGCReq *req = (xCreateGCReq *) client->requestBuffer;
  register XID drawable;
  register int idmap;
  GC gc;
  XGCValues values;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (drawable, req->drawable, idmap, FromClient);
  PSBuildGCValues (req->mask, &req[1], &values, idmap);
  gc = XCreateGC (dpy, drawable, req->mask, &values);
  if (!gc) {
    ErrorF ("No gc created by server\n");
    return (BadAlloc);
  }
  InsertID (req->gc, gc->gid, idmap, FromClient);
  InsertID (gc->gid, req->gc, idmap, FromServer);
  InsertGCInfo (client, req->gc, gc);
  return (client->noClientException);
}

int
_ProcChangeGC (client)
  ClientPtr client;
{
  register xChangeGCReq *req = (xChangeGCReq *) client->requestBuffer;
  GC gc;

  /*
   * Another trick in Xlib :
   * 
   * This request is a "prologue request" in a variety of Xlib functions (e.g.
   * XCopyPlane, XDrawText)
   * 
   * There is one problem with this: a call to XChangeGC does not generally
   * lead to a protocol request, since GCs are implemented with a write-back
   * cache; and what's the problem? you can guess it: (one more time) the
   * serial numbers! We must force Xlib here to do a protocol request:  we do
   * not call XChangeGC, but update the GC cache (turning on the dirty bits)
   * and call XFlushGC instead.
   * 
   * CRITIC:
   * wasn't it possible to program the if statement in XChGC.c as
   *	if(gc->dirty & (GCFont | GCTile | GCStipple | GCClipMask))
   * instead of
   *	if(gc->dirty & (GCFONT | GCTile |GCStipple))  ?
   * The comment there says "if any Resource ID changed, must flush" and clip
   * mask is a resource ID, isn't it?
   */

  GETDISPLAY (dpy, client);
  GETGC (gc, client, req->gc);
  /* update the GC cache (turn on the dirty bits) */
  PSUpdateGCValues (req->mask, &req[1], gc, ConnectionNumber (dpy));
  _XFlushGCCache (dpy, gc);
  return (client->noClientException);
}

int
_ProcCopyGC (client)
  ClientPtr client;
{
  register xCopyGCReq *req = (xCopyGCReq *) client->requestBuffer;
  GC src_gc, dst_gc;

  GETDISPLAY (dpy, client);
  GETGC (src_gc, client, req->srcGC);
  GETGC (dst_gc, client, req->dstGC);
  XCopyGC (dpy, src_gc, req->mask, dst_gc);
  return (client->noClientException);
}

int
_ProcSetDashes (client)
  ClientPtr client;
{
  register xSetDashesReq *req = (xSetDashesReq *) client->requestBuffer;
  GC gc;

  GETDISPLAY (dpy, client);
  GETGC (gc, client, req->gc);
  XSetDashes (dpy, gc, req->dashOffset, (char *) &req[1],
	      req->nDashes);
  return (client->noClientException);
}

int
_ProcSetClipRectangles (client)
  ClientPtr client;
{
  register xSetClipRectanglesReq *req =
  (xSetClipRectanglesReq *) client->requestBuffer;
  GC gc;
  register int num_rects;

  GETDISPLAY (dpy, client);
  GETGC (gc, client, req->gc);
  num_rects = ((req->length << 2) - sizeof (xSetClipRectanglesReq)) /
    sizeof (XRectangle);
  XSetClipRectangles (dpy, gc, req->xOrigin, req->yOrigin,
		      (XRectangle *) & req[1],
		      num_rects, req->ordering);
  return (client->noClientException);
}

int
_ProcFreeGC (client)		/* 60 */
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  GC gc;
  register XID gid;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);

  MAPID (gid, req->id, idmap, FromClient);
  if ((gc = RemoveGCFromResources (client, req->id)) == (GC) NULL) {
    ErrorF ("Can't proceed (Couldn't find gc)!\n");
    return (BadGC);
  }
  XFreeGC (dpy, gc);
  RemoveID (gid, idmap, FromServer);
  RemoveID (req->id, idmap, FromClient);
  return (client->noClientException);
}

int
_ProcClearToBackground (client)
  ClientPtr client;
{
  register xClearAreaReq *req = (xClearAreaReq *) client->requestBuffer;
  register XID window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->window, ConnectionNumber (dpy), FromClient);
  XClearArea (dpy, window, req->x, req->y,
	      req->width, req->height, req->exposures);
  return (client->noClientException);
}

int
_ProcCopyArea (client)
  ClientPtr client;
{
  register xCopyAreaReq *req = (xCopyAreaReq *) client->requestBuffer;
  register XID source, dest;
  GC gc;

  GETDISPLAY (dpy, client);
  MAPID (source, req->srcDrawable, ConnectionNumber (dpy), FromClient);
  MAPID (dest, req->dstDrawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  XCopyArea (dpy, source, dest, gc,
	     req->srcX, req->srcY, req->width, req->height,
	     req->dstX, req->dstY);
  return (client->noClientException);
}

int
_ProcCopyPlane (client)
  ClientPtr client;
{
  register xCopyPlaneReq *req = (xCopyPlaneReq *) client->requestBuffer;
  register XID source, dest;
  GC gc;

  GETDISPLAY (dpy, client);
  MAPID (source, req->srcDrawable, ConnectionNumber (dpy), FromClient);
  MAPID (dest, req->dstDrawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  XCopyPlane (dpy, source, dest, gc,
	      req->srcX, req->srcY, req->width, req->height,
	      req->dstX, req->dstY, req->bitPlane);
  return (client->noClientException);
}

int
_ProcPolyPoint (client)
  ClientPtr client;
{
  register xPolyPointReq *req = (xPolyPointReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register int num_points;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_points = ((req->length << 2) - sizeof (xPolyPointReq)) /
    sizeof (XPoint);
  XDrawPoints (dpy, drawable, gc, (XPoint *) & req[1],
	       num_points, req->coordMode);
  return (client->noClientException);
}

int
_ProcPolyLine (client)		/* 65 */
  ClientPtr client;
{
  register xPolyLineReq *req = (xPolyLineReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register num_lines;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_lines = ((req->length << 2) - sizeof (xPolyLineReq)) /
    sizeof (XPoint);
  XDrawLines (dpy, drawable, gc, (XPoint *) & req[1],
	      num_lines,
	      req->coordMode);
  return (client->noClientException);
}

int
_ProcPolySegment (client)
  ClientPtr client;
{
  register xPolySegmentReq *req =
  (xPolySegmentReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register int num_segs;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_segs = ((req->length << 2) - sizeof (xPolySegmentReq)) /
    sizeof (XSegment);
  XDrawSegments (dpy, drawable, gc, (XSegment *) & req[1], num_segs);
  return (client->noClientException);
}

int
_ProcPolyRectangle (client)
  ClientPtr client;
{
  register xPolyRectangleReq *req =
    (xPolyRectangleReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register int num_rects;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy),
	 FromClient);
  GETGC (gc, client, req->gc);
  num_rects = ((req->length << 2) - sizeof (xPolyRectangleReq)) /
    sizeof (XRectangle);
  XDrawRectangles (dpy, drawable, gc, (XRectangle *) & req[1], num_rects);
  return (client->noClientException);
}

int
_ProcPolyArc (client)
  ClientPtr client;
{
  register xPolyArcReq *req = (xPolyArcReq *) client->requestBuffer;
  GC gc;
  register XID drawable;
  register int num_arcs;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_arcs = ((req->length << 2) - sizeof (xPolyArcReq)) /
    sizeof (XArc);
  XDrawArcs (dpy, drawable, gc, (XArc *) & req[1], num_arcs);
  return (client->noClientException);
}

int
_ProcFillPoly (client)
  ClientPtr client;
{
  register xFillPolyReq *req = (xFillPolyReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register int num_points;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_points = ((req->length << 2) - sizeof (xFillPolyReq)) /
    sizeof (XPoint);
  XFillPolygon (dpy, drawable, gc,
		(XPoint *) & req[1],
		num_points,
		req->shape, req->coordMode);
  return (client->noClientException);
}

int
_ProcPolyFillRectangle (client)	/* 70 */
  ClientPtr client;
{
  register xPolyFillRectangleReq *req =
  (xPolyFillRectangleReq *) client->requestBuffer;
  register XID drawable;
  GC gc;
  register int num_rects;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  num_rects = ((req->length << 2) - sizeof (xPolyRectangleReq)) /
    sizeof (XRectangle);
  XFillRectangles (dpy, drawable, gc,
		   (XRectangle *) & req[1],
		   num_rects);
  return (client->noClientException);
}

int
_ProcPolyFillArc (client)
  ClientPtr client;
{
  register xPolyFillArcReq *req =
  (xPolyFillArcReq *) client->requestBuffer;

  register GC gc;
  register XID drawable, gid;
  register XArc *arcs;
  register int idmap, narcs;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (drawable, req->drawable, idmap, FromClient);
  GETGC (gc, client, req->gc);
  narcs = ((req->length << 2) - sizeof (xPolyFillArcReq)) /
    sizeof (XArc);
  XFillArcs (dpy, drawable, gc, (XArc *) & req[1], narcs);
  return (client->noClientException);
}

int
_ProcPutImage (client)
  ClientPtr client;
{
  register xPutImageReq *req = (xPutImageReq *) client->requestBuffer;

  XImage *image = (XImage *) NULL;
  register XID drawable, gid;
  GC gc;
  register int image_length, pad_bytes;
  int bits_per_pixel, bitmap_pad, bytes_per_line;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);

  /*
   * Images are encoded as strings, but X Protocol packets are a
   * multiple of 4 bytes!  There may have been pad bytes (to each scan
   * line!) added by Xlib which we must strip off again.  The image
   * width is measured in pixels, but we need the number of bytes per
   * image scan line to calculate the number of pad bytes that have been
   * added by Xlib.  For this we have to calculate the bitmap pad and
   * the number of bits per pixel (which depend on the image format,
   * the image depth and the appropriate pixmap format of the display).
   */

  if (!PSComputeBitmapPadAndBitsPerPixel (dpy, req->format, req->depth,
					  &bitmap_pad, &bits_per_pixel)) {
    ErrorF ("Can't compute bitmap_pad and bits_per_pixel!\n ");
    return (BadValue);
  }


  /*****************************************************************
  bytes_per_line = ComputeBytesPerLine(req->width, req->format,
					req->depth, bitmap_pad,
					bits_per_pixel);

   *****************************************************************/
  
  /*
   * The value of the request length field is:
   *	(sizeof(xPutImageReq) + n + p) / 4
   * where n gives the number of image bytes and p the
   * number of pad bytes after each scan line (which depends on n)
   * Since the image height is equal to the number of scan lines we have
   *	req->length * 4 - sizeof(xPutImageReq) == n + p(n)
   *	n + p(n) / req->height = bytes per line + pad bytes per line
   */
  image = XCreateImage (dpy,
			DefaultVisual (dpy, DefaultScreen (dpy)),
			req->depth,
			req->format,
			0,
			(char *) &req[1],
			req->width,
			req->height,
			bitmap_pad,
			 /* bytes_per_line */ 0);
  if (image == (XImage *) NULL)
    return (BadAlloc);
  if (image->format == ZPixmap)
    /* -- this is in fact pad bytes per scan line -- */
    pad_bytes = (((req->length << 2) - sizeof (xPutImageReq)) /
		 req->height) - image->bytes_per_line;
  else
    /* -- this is in fact pad_bytes_per_plane  -- */

    pad_bytes = ((image->bytes_per_line * image->height) -
		 ((image->width + 7) >> 3) * image->height) / image->depth;

  if (pad_bytes)
    PSImageStripOffPadBytes (image, pad_bytes);


  XPutImage (dpy, drawable, gc, image,
	     0, 0, req->dstX, req->dstY,
	     req->width, req->height);
  /* free all stuff: EXCEPT FOR THE DATA POINTER */
  if(image->obdata != NULL)
    Xfree ((char *) image->obdata);
  Xfree ((char *) image);
  return (client->noClientException);
}

int
_ProcPolyText (client)		/* 75 */
  ClientPtr client;
{
  register xPolyTextReq *req = (xPolyTextReq *) client->requestBuffer;
  register XID drawable;
  GC gc;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  if (req->reqType == X_PolyText8) {
    XTextItem *items;
    int num_items;

    items = PSBuildTextItems (req, ConnectionNumber (dpy), &num_items);
    XDrawText (dpy, drawable, gc, req->x, req->y,
	       items, num_items);
    /* -- free all stuff -- */
    while (--num_items >= 0)
      Xfree (items[num_items].chars);
    Xfree ((char *) items);
  }
  else {
    XTextItem16 *items16;
    int num_items16;

    items16 = PSBuildTextItems16 (req, ConnectionNumber (dpy),
				  &num_items16);
    XDrawText16 (dpy, drawable, gc, req->x, req->y,
		 items16, num_items16);
    /* -- free all stuff -- */
    while (--num_items16 >= 0)
      Xfree (items16[num_items16].chars);
    Xfree ((char *) items16);
  }
  return (client->noClientException);
}

int
_ProcImageText (client)
  ClientPtr client;
{
  register xImageTextReq *req = (xImageTextReq *) client->requestBuffer;
  register XID drawable;
  GC gc;

  GETDISPLAY (dpy, client);
  MAPID (drawable, req->drawable, ConnectionNumber (dpy), FromClient);
  GETGC (gc, client, req->gc);
  if (req->reqType == X_ImageText8)
    XDrawImageString (dpy, drawable, gc, req->x, req->y,
		      (char *) &req[1], req->nChars);
  else
    XDrawImageString16 (dpy, drawable, gc, req->x, req->y,
			(XChar2b *) & req[1], req->nChars);
  return (client->noClientException);
}

int
_ProcCreateColormap (client)
  ClientPtr client;
{
  register xCreateColormapReq *req =
  (xCreateColormapReq *) client->requestBuffer;
  register Colormap colormap;
  Visual visual;
  register Window win;

  GETDISPLAY (dpy, client);
  MAPID (win, req->window, ConnectionNumber (dpy), FromClient);

  if (req->visual != CopyFromParent) {
    MAPID (visual.visualid, req->visual, ConnectionNumber (dpy), FromClient);
    colormap = XCreateColormap (dpy, win, &visual, req->alloc);
  }
  else
    colormap = XCreateColormap (dpy, win, CopyFromParent, req->alloc);

  if (colormap) {
    InsertID (colormap, req->mid, ConnectionNumber (dpy), FromServer);
    InsertID (req->mid, colormap, ConnectionNumber (dpy), FromClient);
  }
  return (client->noClientException);
}

int
_ProcFreeColormap (client)
  ClientPtr client;
{
  register xResourceReq *req =
  (xResourceReq *) client->requestBuffer;
  register Colormap colormap;

  GETDISPLAY (dpy, client);
  MAPID (colormap, req->id, ConnectionNumber (dpy), FromClient);
  XFreeColormap (dpy, colormap);
  RemoveID (colormap, ConnectionNumber (dpy), FromServer);
  RemoveID (req->id, ConnectionNumber (dpy), FromClient);
  return (client->noClientException);

}

int
_ProcCopyColormapAndFree (client)	/* 80 */
  ClientPtr client;
{
  register xCopyColormapAndFreeReq *req =
  (xCopyColormapAndFreeReq *) client->requestBuffer;
  register Colormap old_cmap, new_cmap;

  GETDISPLAY (dpy, client);
  MAPID (old_cmap, req->srcCmap, ConnectionNumber (dpy), FromClient);
  new_cmap = XCopyColormapAndFree (dpy, old_cmap);
  if (!new_cmap)
    return (BadAlloc);
  InsertID (new_cmap, req->mid, ConnectionNumber (dpy), FromServer);
  InsertID (req->mid, new_cmap, ConnectionNumber (dpy), FromClient);
  return (client->noClientException);
}

int
_ProcInstallColormap (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register Colormap colormap;

  GETDISPLAY (dpy, client);
  MAPID (colormap, req->id, ConnectionNumber (dpy), FromClient);
  XInstallColormap (dpy, colormap);
  return (client->noClientException);
}

int
_ProcUninstallColormap (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register Colormap colormap;

  GETDISPLAY (dpy, client);
  MAPID (colormap, req->id, ConnectionNumber (dpy), FromClient);
  XUninstallColormap (dpy, colormap);
  return (client->noClientException);
}

int
_ProcFreeColors (client)
  ClientPtr client;
{
  register xFreeColorsReq *req = (xFreeColorsReq *) client->requestBuffer;
  register XID cmap;
  register int npixels;

  GETDISPLAY (dpy, client);
  MAPID (cmap, req->cmap, ConnectionNumber (dpy), FromClient);
  npixels = ((req->length << 2) - sizeof (xFreeColorsReq)) >> 2;

  XFreeColors (dpy, cmap, (unsigned long *) &req[1], npixels,
	       req->planeMask);
  return (client->noClientException);
}

int
_ProcStoreColors (client)
  ClientPtr client;
{
  register xStoreColorsReq *req =
  (xStoreColorsReq *) client->requestBuffer;
  register XID cmap;
  register int i, ncolors;
  register XColor *colors;
  register xColorItem *citems = (xColorItem *) & req[1];

  GETDISPLAY (dpy, client);
  MAPID (cmap, req->cmap, ConnectionNumber (dpy), FromClient);
  ncolors = ((req->length << 2) - sizeof (xStoreColorsReq)) /
    sizeof (xColorItem);
  if ((colors = (XColor *) Xmalloc (ncolors * sizeof (XColor))) == NULL)
    return (BadAlloc);
  for (i = 0; i < ncolors; i++, citems++) {
    colors[i].pixel = citems->pixel;
    colors[i].red = citems->red;
    colors[i].blue = citems->blue;
    colors[i].green = citems->green;
    colors[i].flags = citems->flags;
  }

  XStoreColors (dpy, cmap, colors, ncolors);
  Xfree ((char *) colors);
  return (client->noClientException);
}

int
_ProcStoreNamedColor (client)	/* 90 */
  ClientPtr client;
{
  register xStoreNamedColorReq *req =
  (xStoreNamedColorReq *) client->requestBuffer;
  register Colormap colormap;
  char *name;

  GETDISPLAY (dpy, client);
  if ((name = (char *) Xmalloc (req->nbytes + 1)) == NULL)
    return (BadAlloc);
  bcopy ((char *) &req[1], name, req->nbytes);
  name[req->nbytes] = '\0';
  MAPID (colormap, req->cmap, ConnectionNumber (dpy), FromClient);


  XStoreNamedColor (dpy, colormap, name, req->pixel, req->flags);
  Xfree (name);
  return (client->noClientException);
}

int
_ProcCreateCursor (client)
  ClientPtr client;
{
  register xCreateCursorReq *req =
  (xCreateCursorReq *) client->requestBuffer;
  register XID source_pmap, mask_pmap, cursor;
  XColor fg_color, bg_color;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);
  MAPID (source_pmap, req->source, idmap, FromClient);
  MAPID (mask_pmap, req->mask, idmap, FromClient);

  /* -- these two values do not matter here -- */
  fg_color.pixel =
    bg_color.pixel = 0L;
  fg_color.pad =
    bg_color.pad = '\0';

  fg_color.red = req->foreRed;
  fg_color.green = req->foreGreen;
  fg_color.blue = req->foreBlue;

  bg_color.red = req->backRed;
  bg_color.green = req->backGreen;
  bg_color.blue = req->backBlue;
  cursor = XCreatePixmapCursor (dpy, source_pmap, mask_pmap,
				&fg_color, &bg_color,
				req->x, req->y);
  if (cursor) {
    InsertID (req->cid, cursor, idmap, FromClient);
    InsertID (cursor, req->cid, idmap, FromServer);

    return (client->noClientException);
  }
  else
    return (BadAlloc);
}

int
_ProcCreateGlyphCursor (client)
  ClientPtr client;
{
  register xCreateGlyphCursorReq *req =
  (xCreateGlyphCursorReq *) client->requestBuffer;
  register XID source_font, mask_font, cursor;
  XColor fg_color, bg_color;
  register int idmap;

  GETDISPLAY (dpy, client);
  idmap = ConnectionNumber (dpy);

  MAPID (source_font, req->source, idmap, FromClient);
  MAPID (mask_font, req->mask, idmap, FromClient);

  /* these two values do not matter here */
  fg_color.pixel =
    bg_color.pixel = 0L;
  fg_color.pad =
    bg_color.pad = '\0';

  fg_color.red = req->foreRed;
  fg_color.green = req->foreGreen;
  fg_color.blue = req->foreBlue;

  bg_color.red = req->backRed;
  bg_color.green = req->backGreen;
  bg_color.blue = req->backBlue;


  cursor = XCreateGlyphCursor (dpy, source_font, mask_font,
			       req->sourceChar, req->maskChar,
			       &fg_color, &bg_color);
  if (cursor) {
    InsertID (req->cid, cursor, idmap, FromClient);
    InsertID (cursor, req->cid, idmap, FromServer);

    return (client->noClientException);
  }
  else
    return (BadAlloc);
}

int
_ProcFreeCursor (client)	/* 95 */
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register Cursor cursor;

  GETDISPLAY (dpy, client);
  MAPID (cursor, req->id, ConnectionNumber (dpy), FromClient);
  XFreeCursor (dpy, cursor);
  RemoveID (cursor, ConnectionNumber (dpy), FromServer);
  RemoveID (req->id, ConnectionNumber (dpy), FromClient);
  return (client->noClientException);
}

int
_ProcRecolorCursor (client)
  ClientPtr client;
{
  register xRecolorCursorReq *req =
  (xRecolorCursorReq *) client->requestBuffer;
  register XID cursor;
  XColor fg_color, bg_color;

  GETDISPLAY (dpy, client);
  MAPID (cursor, req->cursor, ConnectionNumber (dpy), FromClient);

  /* these two values do not matter here */
  fg_color.pixel =
    bg_color.pixel = 0L;
  fg_color.pad =
    bg_color.pad = '\0';

  fg_color.red = req->foreRed;
  fg_color.green = req->foreGreen;
  fg_color.blue = req->foreBlue;

  bg_color.red = req->backRed;
  bg_color.green = req->backGreen;
  bg_color.blue = req->backBlue;

  XRecolorCursor (dpy, cursor, &fg_color, &bg_color);
  return (client->noClientException);
}

int
_ProcChangeKeyboardMapping (client)	/* 100 */
  ClientPtr client;
{
  register xChangeKeyboardMappingReq *req =
  (xChangeKeyboardMappingReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XChangeKeyboardMapping (dpy, req->firstKeyCode, req->keySymsPerKeyCode,
			  (KeySym *) & req[1],
			  (req->keyCodes / req->keySymsPerKeyCode) << 1);
  return (client->noClientException);
}

int
_ProcChangeKeyboardControl (client)
  ClientPtr client;
{
  register xChangeKeyboardControlReq *req =
  (xChangeKeyboardControlReq *) client->requestBuffer;

  XKeyboardControl kb_control;

  GETDISPLAY (dpy, client);
  PSBuildKeyboardControl (req->mask, &req[1], &kb_control);

  XChangeKeyboardControl (dpy, req->mask, &kb_control);
  return (client->noClientException);
}

int
_ProcBell (client)
  ClientPtr client;
{
  register xBellReq *req = (xBellReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);

  XBell (dpy, req->percent);
  return (client->noClientException);
}

int
_ProcChangePointerControl (client)	/* 105 */
  ClientPtr client;
{
  register xChangePointerControlReq *req =
  (xChangePointerControlReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XChangePointerControl (dpy, req->doAccel, req->doThresh, req->accelNum,
			 req->accelDenum, req->threshold);
  return (client->noClientException);
}

int
_ProcSetScreenSaver (client)
  ClientPtr client;
{
  register xSetScreenSaverReq *req =
  (xSetScreenSaverReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XSetScreenSaver (dpy, req->timeout, req->interval, req->preferBlank,
		   req->allowExpose);
  return (client->noClientException);
}

int
_ProcChangeHosts (client)
  ClientPtr client;
{
  register xChangeHostsReq *req =
  (xChangeHostsReq *) client->requestBuffer;
  register int i;
  XHostAddress host;

  if ((host.address = (char *) Xmalloc (req->hostLength)) == NULL)
    return (BadAlloc);

  bcopy ((char *) &req[1], host.address, req->hostLength);
  host.length = req->hostLength;
  host.family = req->hostFamily;
  GETDISPLAY (dpy, client);
  if (req->mode == HostInsert)
    XAddHost (dpy, &host);
  else
    XRemoveHost (dpy, &host);
  Xfree (host.address);
  return (client->noClientException);
}

int
_ProcChangeAccessControl (client)
  ClientPtr client;
{
  register xSetAccessControlReq *req =
  (xSetAccessControlReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XSetAccessControl (dpy, req->mode);
  return (client->noClientException);
}

int
_ProcChangeCloseDownMode (client)
  ClientPtr client;
{
  register xSetCloseDownModeReq *req =
  (xSetCloseDownModeReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XSetCloseDownMode (dpy, req->mode);
  return (client->noClientException);
}

int
_ProcKillClient (client)
  ClientPtr client;
{
  register xResourceReq *req = (xResourceReq *) client->requestBuffer;
  register XID resource;

  GETDISPLAY (dpy, client);
  MAPID (resource, req->id, ConnectionNumber (dpy), FromClient);
  XKillClient (dpy, resource);
  return (client->noClientException);
}

int
_ProcRotateProperties (client)
  ClientPtr client;
{
  register xRotatePropertiesReq *req =
  (xRotatePropertiesReq *) client->requestBuffer;
  register Window window;

  GETDISPLAY (dpy, client);
  MAPID (window, req->window, ConnectionNumber (dpy), FromClient);
  XRotateWindowProperties (dpy, window, (Atom *) & req[1],
			   req->nAtoms, req->nPositions);
  return (client->noClientException);
}

int
_ProcForceScreenSaver (client)	/* 115 */
  ClientPtr client;
{
  register xForceScreenSaverReq *req =
  (xForceScreenSaverReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XForceScreenSaver (dpy, req->mode);
  return (client->noClientException);
}

int
_ProcNoOperation (client)	/* 127 */
  ClientPtr client;
{
  register xReq *req = (xReq *) client->requestBuffer;

  GETDISPLAY (dpy, client);
  XNoOp (dpy);
  return (client->noClientException);
}

int
_ProcNotImplemented (client)
  ClientPtr client;
{
  ErrorF (" Oops! Request %d currently not implemented!\n",
	  ((xReq *) client->requestBuffer)->reqType);
  return (BadImplementation);
}