/*

 * Screen routines for Mac OS X rootless X server

 *

 * Greg Parker     gparker@cs.stanford.edu

 *

 * February 2001  Created

 * March 3, 2001  Restructured as generic rootless mode

 */

/* Copyright (c) 2002 Apple Computer, Inc. All rights reserved.

   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 ABOVE LISTED COPYRIGHT

   HOLDER(S) 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(s) of the above

   copyright holders shall not be used in advertising or otherwise to

   promote the sale, use or other dealings in this Software without

   prior written authorization. */

/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/rootlessScreen.c,v 1.2 2002/04/03 00:06:32 torrey Exp $ */

#include "mi.h"

#include "scrnintstr.h"

#include "gcstruct.h"

#include "pixmapstr.h"

#include "windowstr.h"

#include "propertyst.h"

#include "mivalidate.h"

#include "picturestr.h"

#include "os.h"

#include "servermd.h"

#include "colormapst.h"

#include <sys types.h=""></sys>

#include <sys stat.h=""></sys>

#include <fcntl.h></fcntl.h>

#include "rootless-common.h"

#include "rootless-window.h"

/* In milcroseconds */

#define REDISPLAY_DELAY     10

#define REDISPLAY_MAX_DELAY 60

extern int RootlessMiValidateTree(WindowPtr pRoot,

				  WindowPtr pChild, VTKind kind);

extern Bool RootlessCreateGC(GCPtr pGC);

int rootlessGCPrivateIndex = -1;

int rootlessScreenPrivateIndex = -1;

int rootlessWindowPrivateIndex = -1;

void

RootlessUpdateScreenPixmap (ScreenPtr pScreen)

{

    RootlessScreenRec *s = SCREENREC(pScreen);

    PixmapPtr pPix;

    unsigned int rowbytes;

    pPix = (*pScreen->GetScreenPixmap) (pScreen);

    if (pPix == NULL)

    {

	pPix = (*pScreen->CreatePixmap) (pScreen, 0, 0, pScreen->rootDepth);

	(*pScreen->SetScreenPixmap) (pPix);

    }

    rowbytes = PixmapBytePad (pScreen->width, pScreen->rootDepth);

    if (s->pixmap_data_size < rowbytes)

    {

	if (s->pixmap_data != NULL)

	    xfree (s->pixmap_data);

	s->pixmap_data_size = rowbytes;

	s->pixmap_data = xalloc (s->pixmap_data_size);

	if (s->pixmap_data == NULL)

	    return;

	xp_fill_bytes (s->pixmap_data_size, 1, ~0,

		       s->pixmap_data, s->pixmap_data_size);

	pScreen->ModifyPixmapHeader (pPix, pScreen->width, pScreen->height,

				     pScreen->rootDepth,

				     BitsPerPixel (pScreen->rootDepth),

				     0, s->pixmap_data);

	/* ModifyPixmapHeader ignores zero arguments, so install rowbytes

	   by hand. */

	pPix->devKind = 0;

    }

}

static Bool

RootlessCreateScreenResources (ScreenPtr pScreen)

{

    Bool ret = TRUE;

    SCREEN_UNWRAP (pScreen, CreateScreenResources);

    if (pScreen->CreateScreenResources != NULL)

	ret = (*pScreen->CreateScreenResources) (pScreen);

    SCREEN_WRAP(pScreen, CreateScreenResources);

    if (!ret)

	return ret;

    /* miCreateScreenResources doesn't like our null framebuffer pointer,

       it leaves the screen pixmap with an uninitialized data pointer. So

       we gave it depth=0,bits=0, which says, leave it the fsck alone.

       So we have some work to do since we need the screen pixmap to be

       valid (e.g. CopyArea from the root window) */

    RootlessUpdateScreenPixmap (pScreen);

    return ret;

}

static Bool

RootlessCloseScreen(int i, ScreenPtr pScreen)

{

    RootlessScreenRec *s;

    s = SCREENREC(pScreen);

    /* FIXME: unwrap everything that was wrapped? */

    pScreen->CloseScreen = s->CloseScreen;

    if (s->pixmap_data != NULL)

    {

	xfree (s->pixmap_data);

	s->pixmap_data = NULL;

	s->pixmap_data_size = 0;

    }

    xfree(s);

    return pScreen->CloseScreen(i, pScreen);

}

static void

RootlessGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,

                 unsigned int format, unsigned long planeMask, char *pdstLine)

{

    ScreenPtr pScreen = pDrawable->pScreen;

    SCREEN_UNWRAP(pScreen, GetImage);

    if (pDrawable->type == DRAWABLE_WINDOW)

    {

	int x0, y0, x1, y1;

	RootlessWindowRec *winRec;

        /* Many apps use GetImage to sync with the visible frame buffer

           FIXME: entire screen or just window or all screens? */

        RootlessRedisplayScreen (pScreen);

        /* RedisplayScreen stops drawing, so we need to start it again */

        RootlessStartDrawing ((WindowPtr) pDrawable);

	/* Check that we have some place to read from. */

	winRec = WINREC (TopLevelParent ((WindowPtr) pDrawable));

	if (winRec == NULL)

	    goto out;

	/* Clip to top-level window bounds. */

	x0 = pDrawable->x + sx;

	y0 = pDrawable->y + sy;

	x1 = x0 + w;

	y1 = y0 + h;

	x0 = MAX (x0, winRec->x);

	y0 = MAX (y0, winRec->y);

	x1 = MIN (x1, winRec->x + (int) winRec->width);

	y1 = MIN (y1, winRec->y + (int) winRec->height);

	/* FIXME: if clipped we need to adjust the data returned from

	   fbGetImage (), since it calculates the destination stride

	   from the passed in width.. */

	sx = x0 - pDrawable->x;

	sy = y0 - pDrawable->y;

	w = x1 - x0;

	h = y1 - y0;

	if (w <= 0 || h <= 0)

	    goto out;

    }

    pScreen->GetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);

out:

    SCREEN_WRAP(pScreen, GetImage);

}

/*

 * RootlessSourceValidate

 *  CopyArea and CopyPlane use a GC tied to the destination drawable.

 *  StartDrawing/StopDrawing wrappers won't be called if source is

 *  a visible window but the destination isn't. So, we call StartDrawing

 *  here and leave StopDrawing for the block handler.

 */

static void

RootlessSourceValidate(DrawablePtr pDrawable, int x, int y, int w, int h)

{

    SCREEN_UNWRAP(pDrawable->pScreen, SourceValidate);

    if (pDrawable->type == DRAWABLE_WINDOW) {

        WindowPtr pWin = (WindowPtr)pDrawable;

        RootlessStartDrawing(pWin);

    }

    if (pDrawable->pScreen->SourceValidate) {

        pDrawable->pScreen->SourceValidate(pDrawable, x, y, w, h);

    }

    SCREEN_WRAP(pDrawable->pScreen, SourceValidate);

}

#ifdef RENDER

static void

rootlessComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,

                  INT16 xSrc, INT16 ySrc, INT16  xMask, INT16  yMask,

                  INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)

{

    ScreenPtr pScreen = pDst->pDrawable->pScreen;

    PictureScreenPtr ps = GetPictureScreen(pScreen);

    WindowPtr srcWin, dstWin, maskWin = NULL;

    if (pMask) {

        maskWin = (pMask->pDrawable->type == DRAWABLE_WINDOW) ?

                  (WindowPtr)pMask->pDrawable :  NULL;

    }

    srcWin  = (pSrc->pDrawable->type  == DRAWABLE_WINDOW) ?

              (WindowPtr)pSrc->pDrawable  :  NULL;

    dstWin  = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?

              (WindowPtr)pDst->pDrawable  :  NULL;

    ps->Composite = SCREENREC(pScreen)->Composite;

    if (srcWin  && IsFramedWindow(srcWin))  RootlessStartDrawing(srcWin);

    if (maskWin && IsFramedWindow(maskWin)) RootlessStartDrawing(maskWin);

    if (dstWin  && IsFramedWindow(dstWin))  RootlessStartDrawing(dstWin);

    ps->Composite(op, pSrc, pMask, pDst,

                  xSrc, ySrc, xMask, yMask,

                  xDst, yDst, width, height);

    if (dstWin  && IsFramedWindow(dstWin)) {

        RootlessDamageRect(dstWin, xDst, yDst, width, height);

    }

    ps->Composite = RootlessComposite;

}

static void

RootlessGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,

               PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,

               int nlist, GlyphListPtr list, GlyphPtr *glyphs)

{

    ScreenPtr pScreen = pDst->pDrawable->pScreen;

    PictureScreenPtr ps = GetPictureScreen(pScreen);

    int x, y;

    int n;

    GlyphPtr glyph;

    WindowPtr srcWin, dstWin;

    srcWin = (pSrc->pDrawable->type == DRAWABLE_WINDOW) ?

             (WindowPtr)pSrc->pDrawable  :  NULL;

    dstWin = (pDst->pDrawable->type == DRAWABLE_WINDOW) ?

             (WindowPtr)pDst->pDrawable  :  NULL;

    if (srcWin && IsFramedWindow(srcWin)) RootlessStartDrawing(srcWin);

    if (dstWin && IsFramedWindow(dstWin)) RootlessStartDrawing(dstWin);

    ps->Glyphs = SCREENREC(pScreen)->Glyphs;

    ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);

    ps->Glyphs = RootlessGlyphs;

    if (dstWin && IsFramedWindow(dstWin))

    {

        x = xSrc;

        y = ySrc;

	while (nlist--)

	{

	    /* Originally this code called DamageRect for the bounding

	       box of each glyph. But that was causing way too much

	       time to be spent in CGSBoundingRegionAddRect. So compute

	       the union of all glyphs in a list and damage that. It

	       shouldn't be very different. */

            x += list->xOff;

            y += list->yOff;

            n = list->len;

	    if (n > 0)

	    {

		BoxRec box;

                glyph = *glyphs++;

		box.x1 = x - glyph->info.x;

		box.y1 = y - glyph->info.y;

		box.x2 = box.x1 + glyph->info.width;

		box.y2 = box.y2 + glyph->info.height;

		x += glyph->info.xOff;

		y += glyph->info.yOff;

		while (--n > 0)

		{

		    short x1, y1, x2, y2;

		    glyph = *glyphs++;

		    x1 = x - glyph->info.x;

		    y1 = y - glyph->info.y;

		    x2 = x1 + glyph->info.width;

		    y2 = y1 + glyph->info.height;

		    box.x1 = MAX (box.x1, x1);

		    box.y1 = MAX (box.y1, y1);

		    box.x2 = MAX (box.x2, x2);

		    box.y2 = MAX (box.y2, y2);

		    x += glyph->info.xOff;

		    y += glyph->info.yOff;

		}

		RootlessDamageBox (dstWin, &box);

	    }

            list++;

        }

    }

}

#endif /* RENDER */

/* ValidateTree is modified in two ways:

    - top-level windows don't clip each other

    - windows aren't clipped against root.

   These only matter when validating from the root. */

static int

RootlessValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind)

{

    int result;

    RegionRec saveRoot;

    ScreenPtr pScreen = pParent->drawable.pScreen;

    SCREEN_UNWRAP(pScreen, ValidateTree);

    RL_DEBUG_MSG("VALIDATETREE start ");

    /* Use our custom version to validate from root */

    if (IsRoot(pParent)) {

        RL_DEBUG_MSG("custom ");

        result = RootlessMiValidateTree(pParent, pChild, kind);

    } else {

        HUGE_ROOT(pParent);

        result = pScreen->ValidateTree(pParent, pChild, kind);

        NORMAL_ROOT(pParent);

    }

    SCREEN_WRAP(pScreen, ValidateTree);

    RL_DEBUG_MSG("VALIDATETREE end\n");

    return result;

}

/* MarkOverlappedWindows is modified to ignore overlapping top-level

   windows. */

static Bool

RootlessMarkOverlappedWindows(WindowPtr pWin, WindowPtr pFirst,

                              WindowPtr *ppLayerWin)

{

    RegionRec saveRoot;

    Bool result;

    ScreenPtr pScreen = pWin->drawable.pScreen;

    SCREEN_UNWRAP(pScreen, MarkOverlappedWindows);

    RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS start ");

    HUGE_ROOT(pWin);

    if (IsRoot(pWin)) {

        /* root - mark nothing */

        RL_DEBUG_MSG("is root not marking ");

        result = FALSE;

    }

    else if (! IsTopLevel(pWin)) {

        /* not top-level window - mark normally */

        result = pScreen->MarkOverlappedWindows(pWin, pFirst, ppLayerWin);

    }

    else {

        /* top-level window - mark children ONLY - NO overlaps with sibs (?)

	   This code copied from miMarkOverlappedWindows() */

        register WindowPtr pChild;

        Bool anyMarked = FALSE;

        void (* MarkWindow)() = pScreen->MarkWindow;

        RL_DEBUG_MSG("is top level! ");

        /* single layered systems are easy */

        if (ppLayerWin) *ppLayerWin = pWin;

        if (pWin == pFirst) {

            /* Blindly mark pWin and all of its inferiors.   This is a slight

            * overkill if there are mapped windows that outside pWin's border,

            * but it's better than wasting time on RectIn checks.

            */

            pChild = pWin;

            while (1) {

                if (pChild->viewable) {

                    if (REGION_BROKEN (pScreen, &pChild->winSize))

                        SetWinSize (pChild);

                    if (REGION_BROKEN (pScreen, &pChild->borderSize))

                        SetBorderSize (pChild);

                    (* MarkWindow)(pChild);

                    if (pChild->firstChild) {

                        pChild = pChild->firstChild;

                        continue;

                    }

                }

                while (!pChild->nextSib && (pChild != pWin))

                    pChild = pChild->parent;

                if (pChild == pWin)

                    break;

                pChild = pChild->nextSib;

            }

            anyMarked = TRUE;

            pFirst = pFirst->nextSib;

        }

        if (anyMarked)

            (* MarkWindow)(pWin->parent);

        result = anyMarked;

    }

    NORMAL_ROOT(pWin);

    SCREEN_WRAP(pScreen, MarkOverlappedWindows);

    RL_DEBUG_MSG("MARKOVERLAPPEDWINDOWS end\n");

    return result;

}

static void

expose_1 (WindowPtr pWin)

{

    WindowPtr pChild;

    if (!pWin->realized)

	return;

    (*pWin->drawable.pScreen->PaintWindowBackground) (pWin, &pWin->borderClip,

						      PW_BACKGROUND);

    /* FIXME: comments in windowstr.h indicate that borderClip doesn't

       include subwindow visibility. But I'm not so sure.. so we may

       be exposing too much.. */

    miSendExposures (pWin, &pWin->borderClip,

		     pWin->drawable.x, pWin->drawable.y);

    for (pChild = pWin->firstChild; pChild != NULL; pChild = pChild->nextSib)

	expose_1 (pChild);

}

void

RootlessScreenExpose (ScreenPtr pScreen)

{

    expose_1 (WindowTable[pScreen->myNum]);

}

ColormapPtr

RootlessGetColormap (ScreenPtr pScreen)

{

    RootlessScreenRec *s = SCREENREC (pScreen);

    return s->colormap;

}

static void

RootlessInstallColormap (ColormapPtr pMap)

{

    ScreenPtr pScreen = pMap->pScreen;

    RootlessScreenRec *s = SCREENREC (pScreen);

    SCREEN_UNWRAP(pScreen, InstallColormap);

    if (s->colormap != pMap)

    {

	s->colormap = pMap;

	s->colormap_changed = TRUE;

	RootlessQueueRedisplay (pScreen);

    }

    pScreen->InstallColormap (pMap);

    SCREEN_WRAP (pScreen, InstallColormap);

}

static void

RootlessUninstallColormap (ColormapPtr pMap)

{

    ScreenPtr pScreen = pMap->pScreen;

    RootlessScreenRec *s = SCREENREC (pScreen);

    SCREEN_UNWRAP(pScreen, UninstallColormap);

    if (s->colormap == pMap)

	s->colormap = NULL;

    pScreen->UninstallColormap (pMap);

    SCREEN_WRAP(pScreen, UninstallColormap);

}

static void

RootlessStoreColors (ColormapPtr pMap, int ndef, xColorItem *pdef)

{

    ScreenPtr pScreen = pMap->pScreen;

    RootlessScreenRec *s = SCREENREC (pScreen);

    SCREEN_UNWRAP(pScreen, StoreColors);

    if (s->colormap == pMap && ndef > 0)

    {

	s->colormap_changed = TRUE;

	RootlessQueueRedisplay (pScreen);

    }

    pScreen->StoreColors (pMap, ndef, pdef);

    SCREEN_WRAP(pScreen, StoreColors);

}

static CARD32

redisplay_callback (OsTimerPtr timer, CARD32 time, void *arg)

{

    RootlessScreenRec *screenRec = arg;

    if (!screenRec->redisplay_queued)

    {

	/* No update needed. Stop the timer. */

	screenRec->redisplay_timer_set = FALSE;

	return 0;

    }

    screenRec->redisplay_queued = FALSE;

    /* Mark that we should redisplay before waiting for I/O next time */

    screenRec->redisplay_expired = TRUE;

    /* Reinstall the timer immediately, so we get as close to our

       redisplay interval as possible. */

    return REDISPLAY_DELAY;

}

void

RootlessQueueRedisplay (ScreenPtr pScreen)

{

    RootlessScreenRec *screenRec = SCREENREC (pScreen);

    screenRec->redisplay_queued = TRUE;

    if (screenRec->redisplay_timer_set)

	return;

    screenRec->redisplay_timer = TimerSet (screenRec->redisplay_timer,

					   0, REDISPLAY_DELAY,

					   redisplay_callback, screenRec);

    screenRec->redisplay_timer_set = TRUE;

}

/* Call this function when it might be a good idea to flush updates.

   Note that it will unlock window buffers! */

Bool

RootlessMayRedisplay (ScreenPtr pScreen)

{

    RootlessScreenRec *screenRec = SCREENREC (pScreen);

    if (!screenRec->redisplay_queued)

	return FALSE;

    /* If the timer has fired, or it's been long enough since the last

       update, redisplay everything now. */

    if (!screenRec->redisplay_expired)

    {

	CARD32 now = GetTimeInMillis ();

	if (screenRec->last_redisplay + REDISPLAY_MAX_DELAY >= now)

	    return FALSE;

    }

    if (screenRec->redisplay_timer_set)

    {

	TimerCancel (screenRec->redisplay_timer);

	screenRec->redisplay_timer_set = FALSE;

    }

    RootlessRedisplayScreen (screenRec->pScreen);

    screenRec->redisplay_expired = FALSE;

    return TRUE;

}

/* Flush drawing before blocking on select(). */

static void

RootlessBlockHandler(pointer pbdata, OSTimePtr pTimeout, pointer pReadmask)

{

    ScreenPtr pScreen = pbdata;

    RootlessScreenRec *screenRec = SCREENREC (pScreen);

    if (screenRec->redisplay_expired)

    {

	screenRec->redisplay_expired = FALSE;

	if (screenRec->colormap_changed)

	{

	    RootlessFlushScreenColormaps (screenRec->pScreen);

	    screenRec->colormap_changed = FALSE;

	}

	RootlessRedisplayScreen (screenRec->pScreen);

    }

}

static void

RootlessWakeupHandler(pointer data, int i, pointer LastSelectMask)

{

}

static Bool

RootlessAllocatePrivates(ScreenPtr pScreen)

{

    RootlessScreenRec *s;

    static unsigned int rootlessGeneration = -1;

    if (rootlessGeneration != serverGeneration) {

        rootlessScreenPrivateIndex = AllocateScreenPrivateIndex();

        if (rootlessScreenPrivateIndex == -1) return FALSE;

        rootlessGCPrivateIndex = AllocateGCPrivateIndex();

        if (rootlessGCPrivateIndex == -1) return FALSE;

        rootlessWindowPrivateIndex = AllocateWindowPrivateIndex();

        if (rootlessWindowPrivateIndex == -1) return FALSE;

        rootlessGeneration = serverGeneration;

    }

    /* no allocation needed for screen privates */

    if (!AllocateGCPrivate(pScreen, rootlessGCPrivateIndex,

                           sizeof(RootlessGCRec)))

        return FALSE;

    if (!AllocateWindowPrivate(pScreen, rootlessWindowPrivateIndex, 0))

        return FALSE;

    s = xalloc(sizeof(RootlessScreenRec));

    if (! s) return FALSE;

    SCREENREC(pScreen) = s;

    s->pixmap_data = NULL;

    s->pixmap_data_size = 0;

    s->redisplay_timer = NULL;

    s->redisplay_timer_set = FALSE;

    return TRUE;

}

static void

RootlessWrap(ScreenPtr pScreen)

{

    RootlessScreenRec *s = (RootlessScreenRec*)

            pScreen->devPrivates[rootlessScreenPrivateIndex].ptr;

#define WRAP(a) \

    if (pScreen->a) { \

        s->a = pScreen->a; \

    } else { \

        RL_DEBUG_MSG("null screen fn " #a "\n"); \

        s->a = NULL; \

    } \

    pScreen->a = Rootless##a

    WRAP(CreateScreenResources);

    WRAP(CloseScreen);

    WRAP(CreateGC);

    WRAP(PaintWindowBackground);

    WRAP(PaintWindowBorder);

    WRAP(CopyWindow);

    WRAP(GetImage);

    WRAP(SourceValidate);

    WRAP(CreateWindow);

    WRAP(DestroyWindow);

    WRAP(RealizeWindow);

    WRAP(UnrealizeWindow);

    WRAP(ReparentWindow);

    WRAP(MoveWindow);

    WRAP(PositionWindow);

    WRAP(ResizeWindow);

    WRAP(RestackWindow);

    WRAP(ChangeBorderWidth);

    WRAP(MarkOverlappedWindows);

    WRAP(ValidateTree);

    WRAP(ChangeWindowAttributes);

    WRAP(InstallColormap);

    WRAP(UninstallColormap);

    WRAP(StoreColors);

#ifdef SHAPE

    WRAP(SetShape);

#endif

#ifdef RENDER

    {

        /* Composite and Glyphs don't use normal screen wrapping */

        PictureScreenPtr ps = GetPictureScreen(pScreen);

        s->Composite = ps->Composite;

        ps->Composite = rootlessComposite;

        s->Glyphs = ps->Glyphs;

        ps->Glyphs = RootlessGlyphs;

    }

#endif

    // WRAP(ClearToBackground); fixme put this back? useful for shaped wins?

    // WRAP(RestoreAreas); fixme put this back?

#undef WRAP

}

Bool

RootlessSetupScreen(int index, ScreenPtr pScreen)

{

    RootlessScreenRec *s;

    /* Add replacements for fb screen functions */

    pScreen->PaintWindowBackground = RootlessPaintWindow;

    pScreen->PaintWindowBorder = RootlessPaintWindow;

#ifdef RENDER

    {

        PictureScreenPtr ps = GetPictureScreen(pScreen);

        ps->Composite = RootlessComposite;

    }

#endif

    if (!RootlessAllocatePrivates(pScreen))

	return FALSE;

    s = ((RootlessScreenRec*)

	 pScreen->devPrivates[rootlessScreenPrivateIndex].ptr);

    s->pScreen = pScreen;

    RootlessWrap(pScreen);

    if (!RegisterBlockAndWakeupHandlers (RootlessBlockHandler,

                                         RootlessWakeupHandler,

                                         (pointer) pScreen))

    {

        return FALSE;

    }

    return TRUE;

}

void

RootlessUpdateRooted (Bool state)

{

    int i;

    if (!state)

    {

	for (i = 0; i < screenInfo.numScreens; i++)

	    RootlessDisableRoot (screenInfo.screens[i]);

    }

    else

    {

	for (i = 0; i < screenInfo.numScreens; i++)

	    RootlessEnableRoot (screenInfo.screens[i]);

    }

}