Importing xserver from X.Org 7.2RC2

1 files changed, 1553 insertions, 0 deletions

diff --git a/xserver/Xext/saver.c b/xserver/Xext/saver.c
new file mode 100644
index 000000000..1d223ae53
--- /dev/null
+++ b/xserver/Xext/saver.c
@@ -0,0 +1,1553 @@
+/*
+ *
+Copyright (c) 1992  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "os.h"
+#include "windowstr.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "extnsionst.h"
+#include "dixstruct.h"
+#include "resource.h"
+#include "opaque.h"
+#include <X11/extensions/saverproto.h>
+#include "gcstruct.h"
+#include "cursorstr.h"
+#include "colormapst.h"
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#endif
+#ifdef DPMSExtension
+#define DPMS_SERVER
+#include <X11/extensions/dpms.h>
+#endif
+
+#include <stdio.h>
+
+#include "modinit.h"
+
+#if 0
+static unsigned char ScreenSaverReqCode = 0;
+#endif
+static int ScreenSaverEventBase = 0;
+
+extern DISPATCH_PROC(ProcScreenSaverQueryInfo);
+static DISPATCH_PROC(ProcScreenSaverDispatch);
+static DISPATCH_PROC(ProcScreenSaverQueryVersion);
+static DISPATCH_PROC(ProcScreenSaverSelectInput);
+static DISPATCH_PROC(ProcScreenSaverSetAttributes);
+static DISPATCH_PROC(ProcScreenSaverUnsetAttributes);
+static DISPATCH_PROC(ProcScreenSaverSuspend);
+static DISPATCH_PROC(SProcScreenSaverDispatch);
+static DISPATCH_PROC(SProcScreenSaverQueryInfo);
+static DISPATCH_PROC(SProcScreenSaverQueryVersion);
+static DISPATCH_PROC(SProcScreenSaverSelectInput);
+static DISPATCH_PROC(SProcScreenSaverSetAttributes);
+static DISPATCH_PROC(SProcScreenSaverUnsetAttributes);
+static DISPATCH_PROC(SProcScreenSaverSuspend);
+
+static Bool ScreenSaverHandle (
+	ScreenPtr /* pScreen */,
+	int /* xstate */,
+	Bool /* force */
+	);
+
+static Bool
+CreateSaverWindow (
+	ScreenPtr /* pScreen */
+	);
+
+static Bool
+DestroySaverWindow (
+	ScreenPtr /* pScreen */
+	);
+
+static void
+UninstallSaverColormap (
+	ScreenPtr /* pScreen */
+	);
+
+static void
+CheckScreenPrivate (
+	ScreenPtr /* pScreen */
+	);
+
+static void SScreenSaverNotifyEvent (
+	xScreenSaverNotifyEvent * /* from */,
+	xScreenSaverNotifyEvent * /* to */
+	);
+
+static void ScreenSaverResetProc (
+	ExtensionEntry * /* extEntry */
+	);
+
+static RESTYPE SuspendType;  /* resource type for suspension records */
+
+typedef struct _ScreenSaverSuspension *ScreenSaverSuspensionPtr;
+
+/* List of clients that are suspending the screensaver. */
+static ScreenSaverSuspensionPtr suspendingClients = NULL;
+
+/*
+ * clientResource is a resource ID that's added when the record is
+ * allocated, so the record is freed and the screensaver resumed when
+ * the client disconnects. count is the number of times the client has
+ * requested the screensaver be suspended.
+ */
+typedef struct _ScreenSaverSuspension
+{
+    ScreenSaverSuspensionPtr  next;
+    ClientPtr                 pClient;
+    XID                       clientResource;
+    int                       count;
+} ScreenSaverSuspensionRec;
+
+static int ScreenSaverFreeSuspend(
+    pointer /*value */,
+    XID /* id */
+);
+
+/*
+ * each screen has a list of clients requesting
+ * ScreenSaverNotify events.  Each client has a resource
+ * for each screen it selects ScreenSaverNotify input for,
+ * this resource is used to delete the ScreenSaverNotifyRec
+ * entry from the per-screen queue.
+ */
+
+static RESTYPE EventType;   /* resource type for event masks */
+
+typedef struct _ScreenSaverEvent *ScreenSaverEventPtr;
+
+typedef struct _ScreenSaverEvent {
+    ScreenSaverEventPtr	next;
+    ClientPtr		client;
+    ScreenPtr		screen;
+    XID			resource;
+    CARD32		mask;
+} ScreenSaverEventRec;
+
+static int ScreenSaverFreeEvents(
+    pointer /* value */,
+    XID /* id */
+);
+
+static Bool setEventMask (
+    ScreenPtr /* pScreen */,
+    ClientPtr /* client */,
+    unsigned long /* mask */
+);
+
+static unsigned long getEventMask (
+    ScreenPtr /* pScreen */,
+    ClientPtr /* client */
+);
+
+/*
+ * when a client sets the screen saver attributes, a resource is
+ * kept to be freed when the client exits
+ */
+
+static RESTYPE AttrType;    /* resource type for attributes */
+
+typedef struct _ScreenSaverAttr {
+    ScreenPtr	    screen;
+    ClientPtr	    client;
+    XID		    resource;
+    short	    x, y;
+    unsigned short  width, height, borderWidth;
+    unsigned char   class;
+    unsigned char   depth;
+    VisualID	    visual;
+    CursorPtr	    pCursor;
+    PixmapPtr	    pBackgroundPixmap;
+    PixmapPtr	    pBorderPixmap;
+    Colormap	    colormap;
+    unsigned long   mask;		/* no pixmaps or cursors */
+    unsigned long   *values;
+} ScreenSaverAttrRec, *ScreenSaverAttrPtr;
+
+static int ScreenSaverFreeAttr (
+    pointer /* value */,
+    XID /* id */
+);
+
+static void FreeAttrs (
+    ScreenSaverAttrPtr	/* pAttr */
+);
+
+static void FreeScreenAttr (
+    ScreenSaverAttrPtr	/* pAttr */
+);
+
+static void
+SendScreenSaverNotify (
+    ScreenPtr /* pScreen */,
+    int /* state */,
+    Bool /* forced */
+);
+
+typedef struct _ScreenSaverScreenPrivate {
+    ScreenSaverEventPtr	    events;
+    ScreenSaverAttrPtr	    attr;
+    Bool		    hasWindow;
+    Colormap		    installedMap;
+} ScreenSaverScreenPrivateRec, *ScreenSaverScreenPrivatePtr;
+
+static ScreenSaverScreenPrivatePtr
+MakeScreenPrivate (
+	ScreenPtr /* pScreen */
+	);
+
+static int ScreenPrivateIndex;
+
+#define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr)(s)->devPrivates[ScreenPrivateIndex].ptr)
+#define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (pointer) v);
+#define SetupScreen(s)	ScreenSaverScreenPrivatePtr pPriv = (s ? GetScreenPrivate(s) : NULL)
+
+#define New(t)	((t *) xalloc (sizeof (t)))
+
+/****************
+ * ScreenSaverExtensionInit
+ *
+ * Called from InitExtensions in main() or from QueryExtension() if the
+ * extension is dynamically loaded.
+ *
+ ****************/
+
+void
+ScreenSaverExtensionInit(INITARGS)
+{
+    ExtensionEntry *extEntry;
+    int		    i;
+    ScreenPtr	    pScreen;
+
+    AttrType = CreateNewResourceType(ScreenSaverFreeAttr);
+    EventType = CreateNewResourceType(ScreenSaverFreeEvents);
+    SuspendType = CreateNewResourceType(ScreenSaverFreeSuspend);
+    ScreenPrivateIndex = AllocateScreenPrivateIndex ();
+
+    for (i = 0; i < screenInfo.numScreens; i++)
+    {
+	pScreen = screenInfo.screens[i];
+	SetScreenPrivate (pScreen, NULL);
+    }
+    if (AttrType && EventType && SuspendType && ScreenPrivateIndex != -1 &&
+	(extEntry = AddExtension(ScreenSaverName, ScreenSaverNumberEvents, 0,
+				 ProcScreenSaverDispatch, SProcScreenSaverDispatch,
+				 ScreenSaverResetProc, StandardMinorOpcode)))
+    {
+#if 0
+	ScreenSaverReqCode = (unsigned char)extEntry->base;
+#endif
+	ScreenSaverEventBase = extEntry->eventBase;
+	EventSwapVector[ScreenSaverEventBase] = (EventSwapPtr) SScreenSaverNotifyEvent;
+    }
+}
+
+/*ARGSUSED*/
+static void
+ScreenSaverResetProc (extEntry)
+ExtensionEntry	*extEntry;
+{
+}
+
+static void
+CheckScreenPrivate (pScreen)
+    ScreenPtr	pScreen;
+{
+    SetupScreen (pScreen);
+
+    if (!pPriv)
+	return;
+    if (!pPriv->attr && !pPriv->events &&
+	!pPriv->hasWindow && pPriv->installedMap == None)
+    {
+	xfree (pPriv);
+	SetScreenPrivate (pScreen, NULL);
+	savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
+    }
+}
+
+static ScreenSaverScreenPrivatePtr
+MakeScreenPrivate (pScreen)
+    ScreenPtr	pScreen;
+{
+    SetupScreen (pScreen);
+
+    if (pPriv)
+	return pPriv;
+    pPriv = New (ScreenSaverScreenPrivateRec);
+    if (!pPriv)
+	return 0;
+    pPriv->events = 0;
+    pPriv->attr = 0;
+    pPriv->hasWindow = FALSE;
+    pPriv->installedMap = None;
+    SetScreenPrivate (pScreen, pPriv);
+    savedScreenInfo[pScreen->myNum].ExternalScreenSaver = ScreenSaverHandle;
+    return pPriv;
+}
+
+static unsigned long
+getEventMask (pScreen, client)
+    ScreenPtr	pScreen;
+    ClientPtr	client;
+{
+    SetupScreen(pScreen);
+    ScreenSaverEventPtr	pEv;
+
+    if (!pPriv)
+	return 0;
+    for (pEv = pPriv->events; pEv; pEv = pEv->next)
+	if (pEv->client == client)
+	    return pEv->mask;
+    return 0;
+}
+
+static Bool
+setEventMask (pScreen, client, mask)
+    ScreenPtr	pScreen;
+    ClientPtr	client;
+    unsigned long   mask;
+{
+    SetupScreen(pScreen);
+    ScreenSaverEventPtr	pEv, *pPrev;
+
+    if (getEventMask (pScreen, client) == mask)
+	return TRUE;
+    if (!pPriv)
+    {
+	pPriv = MakeScreenPrivate (pScreen);
+	if (!pPriv)
+	    return FALSE;
+    }
+    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)
+	if (pEv->client == client)
+	    break;
+    if (mask == 0)
+    {
+	FreeResource (pEv->resource, EventType);
+	*pPrev = pEv->next;
+	xfree (pEv);
+	CheckScreenPrivate (pScreen);
+    }
+    else
+    {
+    	if (!pEv) 
+    	{
+	    pEv = New (ScreenSaverEventRec);
+	    if (!pEv) 
+	    {
+		CheckScreenPrivate (pScreen);
+	    	return FALSE;
+	    }
+    	    *pPrev = pEv;
+    	    pEv->next = NULL;
+    	    pEv->client = client;
+    	    pEv->screen = pScreen;
+    	    pEv->resource = FakeClientID (client->index);
+	    if (!AddResource (pEv->resource, EventType, (pointer) pEv))
+		return FALSE;
+    	}
+	pEv->mask = mask;
+    }
+    return TRUE;
+}
+
+static void
+FreeAttrs (pAttr)
+    ScreenSaverAttrPtr	pAttr;
+{
+    PixmapPtr	    pPixmap;
+    CursorPtr	    pCursor;
+
+    if ((pPixmap = pAttr->pBackgroundPixmap) != 0)
+	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
+    if ((pPixmap = pAttr->pBorderPixmap) != 0)
+	(*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
+    if ((pCursor = pAttr->pCursor) != 0)
+	FreeCursor (pCursor, (Cursor) 0);
+}
+
+static void
+FreeScreenAttr (pAttr)
+    ScreenSaverAttrPtr	pAttr;
+{
+    FreeAttrs (pAttr);
+    xfree (pAttr->values);
+    xfree (pAttr);
+}
+
+static int
+ScreenSaverFreeEvents (value, id)
+    pointer value;
+    XID id;
+{
+    ScreenSaverEventPtr	pOld = (ScreenSaverEventPtr)value;
+    ScreenPtr pScreen = pOld->screen;
+    SetupScreen (pScreen);
+    ScreenSaverEventPtr	pEv, *pPrev;
+
+    if (!pPriv)
+	return TRUE;
+    for (pPrev = &pPriv->events; (pEv = *pPrev) != 0; pPrev = &pEv->next)
+	if (pEv == pOld)
+	    break;
+    if (!pEv)
+	return TRUE;
+    *pPrev = pEv->next;
+    xfree (pEv);
+    CheckScreenPrivate (pScreen);
+    return TRUE;
+}
+
+static int
+ScreenSaverFreeAttr (value, id)
+    pointer value;
+    XID id;
+{
+    ScreenSaverAttrPtr	pOldAttr = (ScreenSaverAttrPtr)value;
+    ScreenPtr	pScreen = pOldAttr->screen;
+    SetupScreen (pScreen);
+
+    if (!pPriv)
+	return TRUE;
+    if (pPriv->attr != pOldAttr)
+	return TRUE;
+    FreeScreenAttr (pOldAttr);
+    pPriv->attr = NULL;
+    if (pPriv->hasWindow)
+    {
+	SaveScreens (SCREEN_SAVER_FORCER, ScreenSaverReset);
+	SaveScreens (SCREEN_SAVER_FORCER, ScreenSaverActive);
+    }
+    CheckScreenPrivate (pScreen);
+    return TRUE;
+}
+
+static int
+ScreenSaverFreeSuspend (pointer value, XID id)
+{
+    ScreenSaverSuspensionPtr data = (ScreenSaverSuspensionPtr) value;
+    ScreenSaverSuspensionPtr *prev, this;
+
+    /* Unlink and free the suspension record for the client */
+    for (prev = &suspendingClients; (this = *prev); prev = &this->next)
+    {
+	if (this == data)
+	{
+	    *prev = this->next;
+	    xfree (this);
+	    break;
+	}
+    }
+
+    /* Reenable the screensaver if this was the last client suspending it. */
+    if (screenSaverSuspended && suspendingClients == NULL)
+    {
+	screenSaverSuspended = FALSE;
+
+	/* The screensaver could be active, since suspending it (by design)
+	   doesn't prevent it from being forceably activated */
+#ifdef DPMSExtension
+	if (screenIsSaved != SCREEN_SAVER_ON && DPMSPowerLevel == DPMSModeOn)
+#else
+	if (screenIsSaved != SCREEN_SAVER_ON)
+#endif
+	{
+	    UpdateCurrentTimeIf();
+	    lastDeviceEventTime = currentTime;
+	    SetScreenSaverTimer();
+	}
+    }
+
+    return Success;
+}
+
+static void
+SendScreenSaverNotify (pScreen, state, forced)
+    ScreenPtr			pScreen;
+    int	    state;
+    Bool    forced;
+{
+    ScreenSaverScreenPrivatePtr	pPriv;
+    ScreenSaverEventPtr		pEv;
+    unsigned long		mask;
+    xScreenSaverNotifyEvent	ev;
+    ClientPtr			client;
+    int				kind;
+
+    UpdateCurrentTimeIf ();
+    mask = ScreenSaverNotifyMask;
+    if (state == ScreenSaverCycle)
+	mask = ScreenSaverCycleMask;
+    pScreen = screenInfo.screens[pScreen->myNum];
+    pPriv = GetScreenPrivate(pScreen);
+    if (!pPriv)
+	return;
+    if (pPriv->attr)
+	kind = ScreenSaverExternal;
+    else if (ScreenSaverBlanking != DontPreferBlanking)
+	kind = ScreenSaverBlanked;
+    else
+	kind = ScreenSaverInternal;
+    for (pEv = pPriv->events; pEv; pEv = pEv->next)
+    {
+	client = pEv->client;
+	if (client->clientGone)
+	    continue;
+	if (!(pEv->mask & mask))
+	    continue;
+	ev.type = ScreenSaverNotify + ScreenSaverEventBase;
+	ev.state = state;
+	ev.sequenceNumber = client->sequence;
+	ev.timestamp = currentTime.milliseconds;
+	ev.root = WindowTable[pScreen->myNum]->drawable.id;
+	ev.window = savedScreenInfo[pScreen->myNum].wid;
+	ev.kind = kind;
+	ev.forced = forced;
+	WriteEventsToClient (client, 1, (xEvent *) &ev);
+    }
+}
+
+static void
+SScreenSaverNotifyEvent (from, to)
+    xScreenSaverNotifyEvent *from, *to;
+{
+    to->type = from->type;
+    to->state = from->state;
+    cpswaps (from->sequenceNumber, to->sequenceNumber);
+    cpswapl (from->timestamp, to->timestamp);    
+    cpswapl (from->root, to->root);    
+    cpswapl (from->window, to->window);    
+    to->kind = from->kind;
+    to->forced = from->forced;
+}
+
+static void
+UninstallSaverColormap (pScreen)
+    ScreenPtr	pScreen;
+{
+    SetupScreen(pScreen);
+    ColormapPtr			pCmap;
+
+    if (pPriv && pPriv->installedMap != None)
+    {
+	pCmap = (ColormapPtr) LookupIDByType (pPriv->installedMap, RT_COLORMAP);
+	if (pCmap)
+	    (*pCmap->pScreen->UninstallColormap) (pCmap);
+	pPriv->installedMap = None;
+	CheckScreenPrivate (pScreen);
+    }
+}
+
+static Bool
+CreateSaverWindow (pScreen)
+    ScreenPtr	pScreen;
+{
+    SetupScreen (pScreen);
+    ScreenSaverStuffPtr		pSaver;
+    ScreenSaverAttrPtr		pAttr;
+    WindowPtr			pWin;
+    int				result;
+    unsigned long		mask;
+    Colormap			*installedMaps;
+    int				numInstalled;
+    int				i;
+    Colormap			wantMap;
+    ColormapPtr			pCmap;
+
+    pSaver = &savedScreenInfo[pScreen->myNum];
+    if (pSaver->pWindow)
+    {
+	pSaver->pWindow = NullWindow;
+	FreeResource (pSaver->wid, RT_NONE);
+	if (pPriv)
+	{
+	    UninstallSaverColormap (pScreen);
+	    pPriv->hasWindow = FALSE;
+	    CheckScreenPrivate (pScreen);
+	}
+    }
+
+    if (!pPriv || !(pAttr = pPriv->attr))
+	return FALSE;
+
+    pPriv->installedMap = None;
+
+    if (GrabInProgress && GrabInProgress != pAttr->client->index)
+	return FALSE;
+
+    pWin = CreateWindow (pSaver->wid, WindowTable[pScreen->myNum],
+			 pAttr->x, pAttr->y, pAttr->width, pAttr->height,
+			 pAttr->borderWidth, pAttr->class, 
+			 pAttr->mask, (XID *)pAttr->values, 
+			 pAttr->depth, serverClient, pAttr->visual, 
+			 &result);
+    if (!pWin)
+	return FALSE;
+
+    if (!AddResource(pWin->drawable.id, RT_WINDOW, pWin))
+	return FALSE;
+
+    mask = 0;
+    if (pAttr->pBackgroundPixmap)
+    {
+	pWin->backgroundState = BackgroundPixmap;
+	pWin->background.pixmap = pAttr->pBackgroundPixmap;
+	pAttr->pBackgroundPixmap->refcnt++;
+	mask |= CWBackPixmap;
+    }
+    if (pAttr->pBorderPixmap)
+    {
+	pWin->borderIsPixel = FALSE;
+	pWin->border.pixmap = pAttr->pBorderPixmap;
+	pAttr->pBorderPixmap->refcnt++;
+	mask |= CWBorderPixmap;
+    }
+    if (pAttr->pCursor)
+    {
+	if (!pWin->optional)
+	    if (!MakeWindowOptional (pWin))
+	    {
+    	    	FreeResource (pWin->drawable.id, RT_NONE);
+    	    	return FALSE;
+	    }
+	if (pWin->optional->cursor)
+	    FreeCursor (pWin->optional->cursor, (Cursor)0);
+	pWin->optional->cursor = pAttr->pCursor;
+	pAttr->pCursor->refcnt++;
+	pWin->cursorIsNone = FALSE;
+	CheckWindowOptionalNeed (pWin);
+	mask |= CWCursor;
+    }
+    if (mask)
+	(*pScreen->ChangeWindowAttributes) (pWin, mask);
+
+    if (pAttr->colormap != None)
+	(void) ChangeWindowAttributes (pWin, CWColormap, &pAttr->colormap,
+				       serverClient);
+
+    MapWindow (pWin, serverClient);
+
+    pPriv->hasWindow = TRUE;
+    pSaver->pWindow = pWin;
+
+    /* check and install our own colormap if it isn't installed now */
+    wantMap = wColormap (pWin);
+    if (wantMap == None)
+	return TRUE;
+    installedMaps = (Colormap *) ALLOCATE_LOCAL (pScreen->maxInstalledCmaps *
+						 sizeof (Colormap));
+    numInstalled = (*pWin->drawable.pScreen->ListInstalledColormaps)
+						    (pScreen, installedMaps);
+    for (i = 0; i < numInstalled; i++) 
+	if (installedMaps[i] == wantMap)
+	    break;
+
+    DEALLOCATE_LOCAL ((char *) installedMaps);
+
+    if (i < numInstalled)
+	return TRUE;
+
+    pCmap = (ColormapPtr) LookupIDByType (wantMap, RT_COLORMAP);
+    if (!pCmap)
+	return TRUE;
+
+    pPriv->installedMap = wantMap;
+
+    (*pCmap->pScreen->InstallColormap) (pCmap);
+
+    return TRUE;
+}
+
+static Bool
+DestroySaverWindow (pScreen)
+    ScreenPtr	pScreen;
+{
+    SetupScreen(pScreen);
+    ScreenSaverStuffPtr		pSaver;
+
+    if (!pPriv || !pPriv->hasWindow)
+	return FALSE;
+
+    pSaver = &savedScreenInfo[pScreen->myNum];
+    if (pSaver->pWindow)
+    {
+	pSaver->pWindow = NullWindow;
+	FreeResource (pSaver->wid, RT_NONE);
+    }
+    pPriv->hasWindow = FALSE;
+    CheckScreenPrivate (pScreen);
+    UninstallSaverColormap (pScreen);
+    return TRUE;
+}
+
+static Bool
+ScreenSaverHandle (pScreen, xstate, force)
+    ScreenPtr	pScreen;
+    int		xstate;
+    Bool	force;
+{
+    int				state = 0;
+    Bool			ret = FALSE;
+    ScreenSaverScreenPrivatePtr	pPriv;
+
+    switch (xstate)
+    {
+    case SCREEN_SAVER_ON:	
+	state = ScreenSaverOn;
+	ret = CreateSaverWindow (pScreen);
+	break;
+    case SCREEN_SAVER_OFF:	
+	state = ScreenSaverOff;
+	ret = DestroySaverWindow (pScreen);
+	break;
+    case SCREEN_SAVER_CYCLE:	
+	state = ScreenSaverCycle;
+	pPriv = GetScreenPrivate (pScreen);
+	if (pPriv && pPriv->hasWindow)
+	    ret = TRUE;
+	
+    }
+#ifdef PANORAMIX
+    if(noPanoramiXExtension || !pScreen->myNum)
+#endif
+       SendScreenSaverNotify (pScreen, state, force);
+    return ret;
+}
+
+static int
+ProcScreenSaverQueryVersion (client)
+    register ClientPtr	client;
+{
+    xScreenSaverQueryVersionReply	rep;
+    register int		n;
+
+    REQUEST_SIZE_MATCH (xScreenSaverQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = ScreenSaverMajorVersion;
+    rep.minorVersion = ScreenSaverMinorVersion;
+    if (client->swapped) {
+    	swaps(&rep.sequenceNumber, n);
+    	swapl(&rep.length, n);
+    }
+    WriteToClient(client, sizeof (xScreenSaverQueryVersionReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+int
+ProcScreenSaverQueryInfo (client)
+    register ClientPtr	client;
+{
+    REQUEST(xScreenSaverQueryInfoReq);
+    xScreenSaverQueryInfoReply	rep;
+    register int		n;
+    ScreenSaverStuffPtr		pSaver;
+    DrawablePtr			pDraw;
+    CARD32			lastInput;
+    ScreenSaverScreenPrivatePtr	pPriv;
+
+    REQUEST_SIZE_MATCH (xScreenSaverQueryInfoReq);
+    pDraw = (DrawablePtr) LookupDrawable (stuff->drawable, client);
+    if (!pDraw)
+	return BadDrawable;
+
+    pSaver = &savedScreenInfo[pDraw->pScreen->myNum];
+    pPriv = GetScreenPrivate (pDraw->pScreen);
+
+    UpdateCurrentTime ();
+    lastInput = GetTimeInMillis() - lastDeviceEventTime.milliseconds;
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.window = pSaver->wid;
+    if (screenIsSaved != SCREEN_SAVER_OFF)
+    {
+	rep.state = ScreenSaverOn;
+	if (ScreenSaverTime)
+	    rep.tilOrSince = lastInput - ScreenSaverTime;
+	else
+	    rep.tilOrSince = 0;
+    }
+    else
+    {
+	if (ScreenSaverTime)
+	{
+	    rep.state = ScreenSaverOff;
+	    if (ScreenSaverTime < lastInput)
+		rep.tilOrSince = 0;
+	    else
+		rep.tilOrSince = ScreenSaverTime - lastInput;
+	}
+	else
+	{
+	    rep.state = ScreenSaverDisabled;
+	    rep.tilOrSince = 0;
+	}
+    }
+    rep.idle = lastInput;
+    rep.eventMask = getEventMask (pDraw->pScreen, client);
+    if (pPriv && pPriv->attr)
+	rep.kind = ScreenSaverExternal;
+    else if (ScreenSaverBlanking != DontPreferBlanking)
+	rep.kind = ScreenSaverBlanked;
+    else
+	rep.kind = ScreenSaverInternal;
+    if (client->swapped)
+    {
+	swaps (&rep.sequenceNumber, n);
+	swapl (&rep.length, n);
+	swapl (&rep.window, n);
+	swapl (&rep.tilOrSince, n);
+	swapl (&rep.idle, n);
+	swapl (&rep.eventMask, n);
+    }
+    WriteToClient(client, sizeof (xScreenSaverQueryInfoReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static int
+ProcScreenSaverSelectInput (client)
+    register ClientPtr	client;
+{
+    REQUEST(xScreenSaverSelectInputReq);
+    DrawablePtr			pDraw;
+
+    REQUEST_SIZE_MATCH (xScreenSaverSelectInputReq);
+    pDraw = (DrawablePtr) LookupDrawable (stuff->drawable, client);
+    if (!pDraw)
+	return BadDrawable;
+    if (!setEventMask (pDraw->pScreen, client, stuff->eventMask))
+	return BadAlloc;
+    return Success;
+}
+
+static int
+ScreenSaverSetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    DrawablePtr			pDraw;
+    WindowPtr			pParent;
+    ScreenPtr			pScreen;
+    ScreenSaverScreenPrivatePtr pPriv = 0;
+    ScreenSaverAttrPtr		pAttr = 0;
+    int				ret;
+    int				len;
+    int				class, bw, depth;
+    unsigned long		visual;
+    int				idepth, ivisual;
+    Bool			fOK;
+    DepthPtr			pDepth;
+    WindowOptPtr		ancwopt;
+    unsigned int		*pVlist;
+    unsigned long		*values = 0;
+    unsigned long		tmask, imask;
+    unsigned long		val;
+    Pixmap			pixID;
+    PixmapPtr			pPixmap;
+    Cursor			cursorID;
+    CursorPtr			pCursor;
+    Colormap			cmap;
+    ColormapPtr			pCmap;
+
+    REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
+    pDraw = (DrawablePtr) LookupDrawable (stuff->drawable, client);
+    if (!pDraw)
+	return BadDrawable;
+    pScreen = pDraw->pScreen;
+    pParent = WindowTable[pScreen->myNum];
+
+    len = stuff->length -  (sizeof(xScreenSaverSetAttributesReq) >> 2);
+    if (Ones(stuff->mask) != len)
+        return BadLength;
+    if (!stuff->width || !stuff->height)
+    {
+	client->errorValue = 0;
+        return BadValue;
+    }
+    switch (class = stuff->c_class) 
+    {
+    case CopyFromParent:
+    case InputOnly:
+    case InputOutput:
+	break;
+    default:
+	client->errorValue = class;
+	return BadValue;
+    }
+    bw = stuff->borderWidth;
+    depth = stuff->depth;
+    visual = stuff->visualID;
+
+    /* copied directly from CreateWindow */
+
+    if (class == CopyFromParent)
+	class = pParent->drawable.class;
+
+    if ((class != InputOutput) && (class != InputOnly))
+    {
+	client->errorValue = class;
+	return BadValue;
+    }
+
+    if ((class != InputOnly) && (pParent->drawable.class == InputOnly))
+        return BadMatch;
+
+    if ((class == InputOnly) && ((bw != 0) || (depth != 0)))
+        return BadMatch;
+
+    if ((class == InputOutput) && (depth == 0))
+        depth = pParent->drawable.depth;
+    ancwopt = pParent->optional;
+    if (!ancwopt)
+	ancwopt = FindWindowWithOptional(pParent)->optional;
+    if (visual == CopyFromParent)
+	visual = ancwopt->visual;
+
+    /* Find out if the depth and visual are acceptable for this Screen */
+    if ((visual != ancwopt->visual) || (depth != pParent->drawable.depth))
+    {
+	fOK = FALSE;
+	for(idepth = 0; idepth < pScreen->numDepths; idepth++)
+	{
+	    pDepth = (DepthPtr) &pScreen->allowedDepths[idepth];
+	    if ((depth == pDepth->depth) || (depth == 0))
+	    {
+		for (ivisual = 0; ivisual < pDepth->numVids; ivisual++)
+		{
+		    if (visual == pDepth->vids[ivisual])
+		    {
+			fOK = TRUE;
+			break;
+		    }
+		}
+	    }
+	}
+	if (fOK == FALSE)
+	    return BadMatch;
+    }
+
+    if (((stuff->mask & (CWBorderPixmap | CWBorderPixel)) == 0) &&
+	(class != InputOnly) &&
+	(depth != pParent->drawable.depth))
+    {
+        return BadMatch;
+    }
+
+    if (((stuff->mask & CWColormap) == 0) &&
+	(class != InputOnly) &&
+	((visual != ancwopt->visual) || (ancwopt->colormap == None)))
+    {
+	return BadMatch;
+    }
+
+    /* end of errors from CreateWindow */
+
+    pPriv = GetScreenPrivate (pScreen);
+    if (pPriv && pPriv->attr)
+    {
+	if (pPriv->attr->client != client)
+	    return BadAccess;
+    }
+    if (!pPriv)
+    {
+	pPriv = MakeScreenPrivate (pScreen);
+	if (!pPriv)
+	    return FALSE;
+    }
+    pAttr = New (ScreenSaverAttrRec);
+    if (!pAttr)
+    {
+	ret = BadAlloc;
+	goto bail;
+    }
+    /* over allocate for override redirect */
+    values = (unsigned long *) xalloc ((len + 1) * sizeof (unsigned long));
+    if (!values)
+    {
+	ret = BadAlloc;
+	goto bail;
+    }
+    pAttr->screen = pScreen;
+    pAttr->client = client;
+    pAttr->x = stuff->x;
+    pAttr->y = stuff->y;
+    pAttr->width = stuff->width;
+    pAttr->height = stuff->height;
+    pAttr->borderWidth = stuff->borderWidth;
+    pAttr->class = stuff->c_class;
+    pAttr->depth = depth;
+    pAttr->visual = visual;
+    pAttr->colormap = None;
+    pAttr->pCursor = NullCursor;
+    pAttr->pBackgroundPixmap = NullPixmap;
+    pAttr->pBorderPixmap = NullPixmap;
+    pAttr->values = values;
+    /*
+     * go through the mask, checking the values,
+     * looking up pixmaps and cursors and hold a reference
+     * to them.
+     */
+    pAttr->mask = tmask = stuff->mask | CWOverrideRedirect;
+    pVlist = (unsigned int *) (stuff + 1);
+    while (tmask) {
+	imask = lowbit (tmask);
+	tmask &= ~imask;
+	switch (imask)
+        {
+	case CWBackPixmap:
+	    pixID = (Pixmap )*pVlist;
+	    if (pixID == None)
+	    {
+		*values++ = None;
+	    }
+	    else if (pixID == ParentRelative)
+	    {
+		if (depth != pParent->drawable.depth)
+		{
+		    ret = BadMatch;
+		    goto PatchUp;
+		}
+		*values++ = ParentRelative;
+	    }
+            else
+	    {	
+                pPixmap = (PixmapPtr)LookupIDByType(pixID, RT_PIXMAP);
+                if (pPixmap != (PixmapPtr) NULL)
+		{
+                    if  ((pPixmap->drawable.depth != depth) ||
+			 (pPixmap->drawable.pScreen != pScreen))
+		    {
+                        ret = BadMatch;
+			goto PatchUp;
+		    }
+		    pAttr->pBackgroundPixmap = pPixmap;
+		    pPixmap->refcnt++;
+		    pAttr->mask &= ~CWBackPixmap;
+		}
+	        else
+		{
+		    ret = BadPixmap;
+		    client->errorValue = pixID;
+		    goto PatchUp;
+		}
+	    }
+	    break;
+	case CWBackPixel:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWBorderPixmap:
+	    pixID = (Pixmap ) *pVlist;
+	    if (pixID == CopyFromParent)
+	    {
+		if (depth != pParent->drawable.depth)
+		{
+		    ret = BadMatch;
+		    goto PatchUp;
+		}
+		*values++ = CopyFromParent;
+	    }
+	    else
+	    {	
+		pPixmap = (PixmapPtr)LookupIDByType(pixID, RT_PIXMAP);
+		if (pPixmap)
+		{
+                    if  ((pPixmap->drawable.depth != depth) ||
+			 (pPixmap->drawable.pScreen != pScreen))
+		    {
+			ret = BadMatch;
+			goto PatchUp;
+		    }
+		    pAttr->pBorderPixmap = pPixmap;
+		    pPixmap->refcnt++;
+		    pAttr->mask &= ~CWBorderPixmap;
+		}
+    	        else
+		{
+		    ret = BadPixmap;
+		    client->errorValue = pixID;
+		    goto PatchUp;
+		}
+	    }
+	    break;
+	case CWBorderPixel:
+            *values++ = (CARD32) *pVlist;
+            break;
+	case CWBitGravity:
+	    val = (CARD8 )*pVlist;
+	    if (val > StaticGravity)
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWWinGravity:
+	    val = (CARD8 )*pVlist;
+	    if (val > StaticGravity)
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWBackingStore:
+	    val = (CARD8 )*pVlist;
+	    if ((val != NotUseful) && (val != WhenMapped) && (val != Always))
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWBackingPlanes:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWBackingPixel:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWSaveUnder:
+	    val = (BOOL) *pVlist;
+	    if ((val != xTrue) && (val != xFalse))
+	    {
+		ret = BadValue;
+		client->errorValue = val;
+		goto PatchUp;
+	    }
+	    *values++ = val;
+	    break;
+	case CWEventMask:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWDontPropagate:
+	    *values++ = (CARD32) *pVlist;
+	    break;
+	case CWOverrideRedirect:
+	    if (!(stuff->mask & CWOverrideRedirect))
+		pVlist--;
+	    else
+	    {
+	    	val = (BOOL ) *pVlist;
+	    	if ((val != xTrue) && (val != xFalse))
+	    	{
+		    ret = BadValue;
+		    client->errorValue = val;
+		    goto PatchUp;
+	    	}
+	    }
+	    *values++ = xTrue;
+	    break;
+	case CWColormap:
+	    cmap = (Colormap) *pVlist;
+	    pCmap = (ColormapPtr)LookupIDByType(cmap, RT_COLORMAP);
+	    if (!pCmap)
+	    {
+		ret = BadColor;
+		client->errorValue = cmap;
+		goto PatchUp;
+	    }
+	    if (pCmap->pVisual->vid != visual || pCmap->pScreen != pScreen)
+	    {
+		ret = BadMatch;
+		goto PatchUp;
+	    }
+	    pAttr->colormap = cmap;
+	    pAttr->mask &= ~CWColormap;
+	    break;
+	case CWCursor:
+	    cursorID = (Cursor ) *pVlist;
+	    if ( cursorID == None)
+	    {
+		*values++ = None;
+	    }
+	    else
+	    {
+	    	pCursor = (CursorPtr)LookupIDByType(cursorID, RT_CURSOR);
+	    	if (!pCursor)
+	    	{
+		    ret = BadCursor;
+		    client->errorValue = cursorID;
+		    goto PatchUp;
+	    	}
+		pCursor->refcnt++;
+		pAttr->pCursor = pCursor;
+		pAttr->mask &= ~CWCursor;
+	    }
+	    break;
+     	 default:
+	    ret = BadValue;
+	    client->errorValue = stuff->mask;
+	    goto PatchUp;
+	}
+	pVlist++;
+    }
+    if (pPriv->attr)
+	FreeScreenAttr (pPriv->attr);
+    pPriv->attr = pAttr;
+    pAttr->resource = FakeClientID (client->index);
+    if (!AddResource (pAttr->resource, AttrType, (pointer) pAttr))
+	return BadAlloc;
+    return Success;
+PatchUp:
+    FreeAttrs (pAttr);
+bail:
+    CheckScreenPrivate (pScreen);
+    if (pAttr) xfree (pAttr->values);
+    xfree (pAttr);
+    return ret;
+}
+
+static int
+ScreenSaverUnsetAttributes (ClientPtr client)
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    DrawablePtr			pDraw;
+    ScreenSaverScreenPrivatePtr	pPriv;
+
+    REQUEST_SIZE_MATCH (xScreenSaverUnsetAttributesReq);
+    pDraw = (DrawablePtr) LookupDrawable (stuff->drawable, client);
+    if (!pDraw)
+	return BadDrawable;
+    pPriv = GetScreenPrivate (pDraw->pScreen);
+    if (pPriv && pPriv->attr && pPriv->attr->client == client)
+    {
+	FreeResource (pPriv->attr->resource, AttrType);
+    	FreeScreenAttr (pPriv->attr);
+	pPriv->attr = NULL;
+	CheckScreenPrivate (pDraw->pScreen);
+    }
+    return Success;
+}
+
+static int
+ProcScreenSaverSetAttributes (ClientPtr client)
+{
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension) {
+       REQUEST(xScreenSaverSetAttributesReq);
+       PanoramiXRes *draw;
+       PanoramiXRes *backPix = NULL;
+       PanoramiXRes *bordPix = NULL;
+       PanoramiXRes *cmap    = NULL;
+       int i, status = 0, len;
+       int  pback_offset = 0, pbord_offset = 0, cmap_offset = 0;
+       XID orig_visual, tmp;
+
+       REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
+
+       if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+                   client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+           return BadDrawable;
+
+       len = stuff->length -  (sizeof(xScreenSaverSetAttributesReq) >> 2);
+       if (Ones(stuff->mask) != len)
+           return BadLength;
+
+       if((Mask)stuff->mask & CWBackPixmap) {
+          pback_offset = Ones((Mask)stuff->mask & (CWBackPixmap - 1));
+          tmp = *((CARD32 *) &stuff[1] + pback_offset);
+          if ((tmp != None) && (tmp != ParentRelative)) {
+             if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
+                  client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+                return BadPixmap;
+          }
+       }
+
+       if ((Mask)stuff->mask & CWBorderPixmap) {
+          pbord_offset = Ones((Mask)stuff->mask & (CWBorderPixmap - 1));
+          tmp = *((CARD32 *) &stuff[1] + pbord_offset);
+          if (tmp != CopyFromParent) {
+             if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
+                  client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+                return BadPixmap;
+          }
+       }
+
+       if ((Mask)stuff->mask & CWColormap) {
+           cmap_offset = Ones((Mask)stuff->mask & (CWColormap - 1));
+           tmp = *((CARD32 *) &stuff[1] + cmap_offset);
+           if ((tmp != CopyFromParent) && (tmp != None)) {
+             if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
+                  client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+                 return BadColor;
+           }
+       }
+
+       orig_visual = stuff->visualID;
+
+       FOR_NSCREENS_BACKWARD(i) {
+          stuff->drawable = draw->info[i].id;  
+          if (backPix)
+             *((CARD32 *) &stuff[1] + pback_offset) = backPix->info[i].id;
+          if (bordPix)
+             *((CARD32 *) &stuff[1] + pbord_offset) = bordPix->info[i].id;
+          if (cmap)
+             *((CARD32 *) &stuff[1] + cmap_offset) = cmap->info[i].id;
+
+          if (orig_visual != CopyFromParent) 
+            stuff->visualID = 
+                     PanoramiXVisualTable[(orig_visual*MAXSCREENS) + i];
+
+          status = ScreenSaverSetAttributes(client);
+       }
+
+       return status;
+    }
+#endif
+
+    return ScreenSaverSetAttributes(client);
+}
+
+static int
+ProcScreenSaverUnsetAttributes (ClientPtr client)
+{
+#ifdef PANORAMIX
+    if(!noPanoramiXExtension) {
+       REQUEST(xScreenSaverUnsetAttributesReq);
+       PanoramiXRes *draw;
+       int i;
+
+       if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
+                   client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+           return BadDrawable;
+
+       for(i = PanoramiXNumScreens - 1; i > 0; i--) {
+            stuff->drawable = draw->info[i].id;
+            ScreenSaverUnsetAttributes(client);
+       }
+
+       stuff->drawable = draw->info[0].id;
+    }
+#endif
+
+    return ScreenSaverUnsetAttributes(client);
+}
+
+static int
+ProcScreenSaverSuspend (ClientPtr client)
+{
+    ScreenSaverSuspensionPtr *prev, this;
+
+    REQUEST(xScreenSaverSuspendReq);
+    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);
+
+    /* Check if this client is suspending the screensaver */
+    for (prev = &suspendingClients; (this = *prev); prev = &this->next)
+	if (this->pClient == client)
+	    break;
+
+    if (this)
+    {
+	if (stuff->suspend == TRUE)
+	   this->count++;
+	else if (--this->count == 0)
+	   FreeResource (this->clientResource, RT_NONE);
+
+	return Success;
+    }
+
+    /* If we get to this point, this client isn't suspending the screensaver */
+    if (stuff->suspend == FALSE)
+	return Success;
+
+    /*
+     * Allocate a suspension record for the client, and stop the screensaver
+     * if it isn't already suspended by another client. We attach a resource ID
+     * to the record, so the screensaver will be reenabled and the record freed
+     * if the client disconnects without reenabling it first.
+     */
+    this = (ScreenSaverSuspensionPtr) xalloc (sizeof (ScreenSaverSuspensionRec));
+
+    if (!this)
+	return BadAlloc;
+
+    this->next           = NULL;
+    this->pClient        = client;
+    this->count          = 1;
+    this->clientResource = FakeClientID (client->index);
+
+    if (!AddResource (this->clientResource, SuspendType, (pointer) this))
+    {
+	xfree (this);
+	return BadAlloc;
+    }
+
+    *prev = this;
+    if (!screenSaverSuspended)
+    {
+	screenSaverSuspended = TRUE;
+	FreeScreenSaverTimer();
+    }
+
+    return (client->noClientException);
+}
+
+static DISPATCH_PROC((*NormalVector[])) = {
+    ProcScreenSaverQueryVersion,
+    ProcScreenSaverQueryInfo,
+    ProcScreenSaverSelectInput,
+    ProcScreenSaverSetAttributes,
+    ProcScreenSaverUnsetAttributes,
+    ProcScreenSaverSuspend,
+};
+
+#define NUM_REQUESTS	((sizeof NormalVector) / (sizeof NormalVector[0]))
+
+static int
+ProcScreenSaverDispatch (client)
+    ClientPtr	client;
+{
+    REQUEST(xReq);
+
+    if (stuff->data < NUM_REQUESTS)
+	return (*NormalVector[stuff->data])(client);
+    return BadRequest;
+}
+
+static int
+SProcScreenSaverQueryVersion (client)
+    ClientPtr	client;
+{
+    REQUEST(xScreenSaverQueryVersionReq);
+    int	    n;
+
+    swaps (&stuff->length, n);
+    REQUEST_SIZE_MATCH(xScreenSaverQueryVersionReq);
+    return ProcScreenSaverQueryVersion (client);
+}
+
+static int
+SProcScreenSaverQueryInfo (client)
+    ClientPtr	client;
+{
+    REQUEST(xScreenSaverQueryInfoReq);
+    int	    n;
+
+    swaps (&stuff->length, n);
+    REQUEST_SIZE_MATCH(xScreenSaverQueryInfoReq);
+    swapl (&stuff->drawable, n);
+    return ProcScreenSaverQueryInfo (client);
+}
+
+static int
+SProcScreenSaverSelectInput (client)
+    ClientPtr	client;
+{
+    REQUEST(xScreenSaverSelectInputReq);
+    int	    n;
+
+    swaps (&stuff->length, n);
+    REQUEST_SIZE_MATCH(xScreenSaverSelectInputReq);
+    swapl (&stuff->drawable, n);
+    swapl (&stuff->eventMask, n);
+    return ProcScreenSaverSelectInput (client);
+}
+
+static int
+SProcScreenSaverSetAttributes (client)
+    ClientPtr	client;
+{
+    REQUEST(xScreenSaverSetAttributesReq);
+    int	    n;
+
+    swaps (&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xScreenSaverSetAttributesReq);
+    swapl (&stuff->drawable, n);
+    swaps (&stuff->x, n);
+    swaps (&stuff->y, n);
+    swaps (&stuff->width, n);
+    swaps (&stuff->height, n);
+    swaps (&stuff->borderWidth, n);
+    swapl (&stuff->visualID, n);
+    swapl (&stuff->mask, n);
+    SwapRestL(stuff);
+    return ProcScreenSaverSetAttributes (client);
+}
+
+static int
+SProcScreenSaverUnsetAttributes (client)
+    ClientPtr	client;
+{
+    REQUEST(xScreenSaverUnsetAttributesReq);
+    int	    n;
+
+    swaps (&stuff->length, n);
+    REQUEST_SIZE_MATCH(xScreenSaverUnsetAttributesReq);
+    swapl (&stuff->drawable, n);
+    return ProcScreenSaverUnsetAttributes (client);
+}
+
+static int
+SProcScreenSaverSuspend (ClientPtr client)
+{
+    int n;
+    REQUEST(xScreenSaverSuspendReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xScreenSaverSuspendReq);
+    swapl(&stuff->suspend, n);
+    return ProcScreenSaverSuspend (client);
+}
+
+static DISPATCH_PROC((*SwappedVector[])) = {
+    SProcScreenSaverQueryVersion,
+    SProcScreenSaverQueryInfo,
+    SProcScreenSaverSelectInput,
+    SProcScreenSaverSetAttributes,
+    SProcScreenSaverUnsetAttributes,
+    SProcScreenSaverSuspend,
+};
+
+static int
+SProcScreenSaverDispatch (client)
+    ClientPtr	client;
+{
+    REQUEST(xReq);
+
+    if (stuff->data < NUM_REQUESTS)
+	return (*SwappedVector[stuff->data])(client);
+    return BadRequest;
+}