Initial revisionXORG-STABLE

61 files changed, 16286 insertions, 0 deletions

diff --git a/hw/darwin/darwinKeyboard.h b/hw/darwin/darwinKeyboard.h
new file mode 100644
index 000000000..c71888990
--- /dev/null
+++ b/hw/darwin/darwinKeyboard.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. 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/darwinKeyboard.h,v 1.1 2003/11/01 08:13:08 torrey Exp $ */
+
+#ifndef DARWIN_KEYBOARD_H
+#define DARWIN_KEYBOARD_H 1
+
+#define XK_TECHNICAL		// needed to get XK_Escape
+#define XK_PUBLISHING
+#include "keysym.h"
+#include "inputstr.h"
+
+// Each key can generate 4 glyphs. They are, in order:
+// unshifted, shifted, modeswitch unshifted, modeswitch shifted
+#define GLYPHS_PER_KEY  4
+#define NUM_KEYCODES    248	// NX_NUMKEYCODES might be better
+#define MAX_KEYCODE     NUM_KEYCODES + MIN_KEYCODE - 1
+
+typedef struct darwinKeyboardInfo_struct {
+    CARD8 modMap[MAP_LENGTH];
+    KeySym keyMap[MAP_LENGTH * GLYPHS_PER_KEY];
+    unsigned char modifierKeycodes[32][2];
+} darwinKeyboardInfo;
+
+Bool DarwinModeReadSystemKeymap(darwinKeyboardInfo *info);
+
+#endif /* DARWIN_KEYBOARD_H */
diff --git a/hw/darwin/iokit/xfIOKit.c b/hw/darwin/iokit/xfIOKit.c
new file mode 100644
index 000000000..6b4bd75c2
--- /dev/null
+++ b/hw/darwin/iokit/xfIOKit.c
@@ -0,0 +1,770 @@
+/**************************************************************
+ *
+ * IOKit support for the Darwin X Server
+ *
+ * HISTORY:
+ * Original port to Mac OS X Server by John Carmack
+ * Port to Darwin 1.0 by Dave Zarzycki
+ * Significantly rewritten for XFree86 4.0.1 by Torrey Lyons
+ *
+ **************************************************************/
+/*
+ * Copyright (c) 2001-2002 Torrey T. Lyons. 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/iokit/xfIOKit.c,v 1.2 2003/10/16 23:50:09 torrey Exp $ */
+
+#include "X.h"
+#include "Xproto.h"
+#include "os.h"
+#include "servermd.h"
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "mi.h"
+#include "mibstore.h"
+#include "mipointer.h"
+#include "micmap.h"
+#include "shadow.h"
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <pthread.h>
+
+#include <mach/mach_interface.h>
+
+#define NO_CFPLUGIN
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hidsystem/IOHIDShared.h>
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <drivers/event_status_driver.h>
+
+// Define this to work around bugs in the display drivers for
+// older PowerBook G3's. If the X server starts without this
+// #define, you don't need it.
+#undef OLD_POWERBOOK_G3
+
+#include "darwin.h"
+#include "xfIOKit.h"
+
+// Globals
+int             xfIOKitScreenIndex = 0;
+io_connect_t    xfIOKitInputConnect = 0;
+
+static pthread_t                inputThread;
+static EvGlobals *              evg;
+static mach_port_t              masterPort;
+static mach_port_t              notificationPort;
+static IONotificationPortRef    NotificationPortRef;
+static mach_port_t              pmNotificationPort;
+static io_iterator_t            fbIter;
+
+
+/*
+ * XFIOKitStoreColors
+ * This is a callback from X to change the hardware colormap
+ * when using PsuedoColor.
+ */
+static void XFIOKitStoreColors(
+    ColormapPtr     pmap,
+    int             numEntries,
+    xColorItem      *pdefs)
+{
+    kern_return_t   kr;
+    int             i;
+    IOColorEntry    *newColors;
+    ScreenPtr       pScreen = pmap->pScreen;
+    XFIOKitScreenPtr iokitScreen = XFIOKIT_SCREEN_PRIV(pScreen);
+
+    assert( newColors = (IOColorEntry *)
+                xalloc( numEntries*sizeof(IOColorEntry) ));
+
+    // Convert xColorItem values to IOColorEntry
+    // assume the colormap is PsuedoColor
+    // as we do not support DirectColor
+    for (i = 0; i < numEntries; i++) {
+        newColors[i].index = pdefs[i].pixel;
+        newColors[i].red =   pdefs[i].red;
+        newColors[i].green = pdefs[i].green;
+        newColors[i].blue =  pdefs[i].blue;
+    }
+
+    kr = IOFBSetCLUT( iokitScreen->fbService, 0, numEntries,
+                      kSetCLUTByValue, newColors );
+    kern_assert( kr );
+
+    xfree( newColors );
+}
+
+
+/*
+ * DarwinModeBell
+ *  FIXME
+ */
+void DarwinModeBell(
+    int             loud,
+    DeviceIntPtr    pDevice,
+    pointer         ctrl,
+    int             fbclass)
+{
+}
+
+
+/*
+ * DarwinModeGiveUp
+ *  Closes the connections to IOKit services
+ */
+void DarwinModeGiveUp( void )
+{
+    int i;
+
+    // we must close the HID System first
+    // because it is a client of the framebuffer
+    NXCloseEventStatus( darwinParamConnect );
+    IOServiceClose( xfIOKitInputConnect );
+    for (i = 0; i < screenInfo.numScreens; i++) {
+        XFIOKitScreenPtr iokitScreen =
+                            XFIOKIT_SCREEN_PRIV(screenInfo.screens[i]);
+        IOServiceClose( iokitScreen->fbService );
+    }
+}
+
+
+/*
+ * ClearEvent
+ *  Clear an event from the HID System event queue
+ */
+static void ClearEvent(NXEvent * ep)
+{
+    static NXEvent nullEvent = {NX_NULLEVENT, {0, 0 }, 0, -1, 0 };
+
+    *ep = nullEvent;
+    ep->data.compound.subType = ep->data.compound.misc.L[0] =
+                                ep->data.compound.misc.L[1] = 0;
+}
+
+
+/*
+ * XFIOKitHIDThread
+ *  Read the HID System event queue, translate it to an X event,
+ *  and queue it for processing.
+ */
+static void *XFIOKitHIDThread(void *unused)
+{
+    for (;;) {
+        NXEQElement             *oldHead;
+        mach_msg_return_t       kr;
+        mach_msg_empty_rcv_t    msg;
+
+        kr = mach_msg((mach_msg_header_t*) &msg, MACH_RCV_MSG, 0,
+                      sizeof(msg), notificationPort, 0, MACH_PORT_NULL);
+        kern_assert(kr);
+
+        while (evg->LLEHead != evg->LLETail) {
+            NXEvent ev;
+            xEvent xe;
+
+            // Extract the next event from the kernel queue
+            oldHead = (NXEQElement*)&evg->lleq[evg->LLEHead];
+            ev_lock(&oldHead->sema);
+            ev = oldHead->event;
+            ClearEvent(&oldHead->event);
+            evg->LLEHead = oldHead->next;
+            ev_unlock(&oldHead->sema);
+
+            memset(&xe, 0, sizeof(xe));
+
+            // These fields should be filled in for every event
+            xe.u.keyButtonPointer.rootX = ev.location.x;
+            xe.u.keyButtonPointer.rootY = ev.location.y;
+            xe.u.keyButtonPointer.time = GetTimeInMillis();
+
+            switch( ev.type ) {
+                case NX_MOUSEMOVED:
+                    xe.u.u.type = MotionNotify;
+                    break;
+
+                case NX_LMOUSEDOWN:
+                    xe.u.u.type = ButtonPress;
+                    xe.u.u.detail = 1;
+                    break;
+
+                case NX_LMOUSEUP:
+                    xe.u.u.type = ButtonRelease;
+                    xe.u.u.detail = 1;
+                    break;
+
+                // A newer kernel generates multi-button events with
+                // NX_SYSDEFINED. Button 2 isn't handled correctly by
+                // older kernels anyway. Just let NX_SYSDEFINED events
+                // handle these.
+#if 0
+                case NX_RMOUSEDOWN:
+                    xe.u.u.type = ButtonPress;
+                    xe.u.u.detail = 2;
+                    break;
+
+                case NX_RMOUSEUP:
+                    xe.u.u.type = ButtonRelease;
+                    xe.u.u.detail = 2;
+                    break;
+#endif
+
+                case NX_KEYDOWN:
+                    xe.u.u.type = KeyPress;
+                    xe.u.u.detail = ev.data.key.keyCode;
+                    break;
+
+                case NX_KEYUP:
+                    xe.u.u.type = KeyRelease;
+                    xe.u.u.detail = ev.data.key.keyCode;
+                    break;
+
+                case NX_FLAGSCHANGED:
+                    xe.u.u.type = kXDarwinUpdateModifiers;
+                    xe.u.clientMessage.u.l.longs0 = ev.flags;
+                    break;
+
+                case NX_SYSDEFINED:
+                    if (ev.data.compound.subType == 7) {
+                        xe.u.u.type = kXDarwinUpdateButtons;
+                        xe.u.clientMessage.u.l.longs0 =
+                                        ev.data.compound.misc.L[0];
+                        xe.u.clientMessage.u.l.longs1 =
+                                        ev.data.compound.misc.L[1];
+                    } else {
+                        continue;
+                    }
+                    break;
+
+                case NX_SCROLLWHEELMOVED:
+                    xe.u.u.type = kXDarwinScrollWheel;
+                    xe.u.clientMessage.u.s.shorts0 =
+                                    ev.data.scrollWheel.deltaAxis1;
+                    break;
+
+                default:
+                    continue;
+            }
+ 
+            DarwinEQEnqueue(&xe);
+        }
+    }
+
+    return NULL;
+}
+
+
+/*
+ * XFIOKitPMThread
+ *  Handle power state notifications
+ */
+static void *XFIOKitPMThread(void *arg)
+{
+    ScreenPtr pScreen = (ScreenPtr)arg;
+    XFIOKitScreenPtr iokitScreen = XFIOKIT_SCREEN_PRIV(pScreen);
+
+    for (;;) {
+        mach_msg_return_t       kr;
+        mach_msg_empty_rcv_t    msg;
+
+        kr = mach_msg((mach_msg_header_t*) &msg, MACH_RCV_MSG, 0,
+                      sizeof(msg), pmNotificationPort, 0, MACH_PORT_NULL);
+        kern_assert(kr);
+
+        // display is powering down
+        if (msg.header.msgh_id == 0) {
+            IOFBAcknowledgePM( iokitScreen->fbService );
+            xf86SetRootClip(pScreen, FALSE);
+        }
+        // display just woke up
+        else if (msg.header.msgh_id == 1) {
+            xf86SetRootClip(pScreen, TRUE);
+        }
+    }
+    return NULL;
+}
+
+
+/*
+ * SetupFBandHID
+ *  Setup an IOFramebuffer service and connect the HID system to it.
+ */
+static Bool SetupFBandHID(
+    int                    index,
+    DarwinFramebufferPtr   dfb,
+    XFIOKitScreenPtr       iokitScreen)
+{
+    kern_return_t           kr;
+    io_service_t            service;
+    io_connect_t            fbService;
+    vm_address_t            vram;
+    vm_size_t               shmemSize;
+    int                     i;
+    UInt32                  numModes;
+    IODisplayModeInformation modeInfo;
+    IODisplayModeID         displayMode, *allModes;
+    IOIndex                 displayDepth;
+    IOFramebufferInformation fbInfo;
+    IOPixelInformation      pixelInfo;
+    StdFBShmem_t            *cshmem;
+
+    // find and open the IOFrameBuffer service
+    service = IOIteratorNext(fbIter);
+    if (service == 0)
+        return FALSE;
+
+    kr = IOServiceOpen( service, mach_task_self(),
+                        kIOFBServerConnectType, &iokitScreen->fbService );
+    IOObjectRelease( service );
+    if (kr != KERN_SUCCESS) {
+        ErrorF("Failed to connect as window server to screen %i.\n", index);
+        return FALSE;
+    }
+    fbService = iokitScreen->fbService;
+
+    // create the slice of shared memory containing cursor state data
+    kr = IOFBCreateSharedCursor( fbService,
+                                 kIOFBCurrentShmemVersion,
+                                 32, 32 );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+
+    // Register for power management events for the framebuffer's device
+    kr = IOCreateReceivePort(kOSNotificationMessageID, &pmNotificationPort);
+    kern_assert(kr);
+    kr = IOConnectSetNotificationPort( fbService, 0,
+                                       pmNotificationPort, 0 );
+    if (kr != KERN_SUCCESS) {
+        ErrorF("Power management registration failed.\n");
+    }
+
+    // SET THE SCREEN PARAMETERS
+    // get the current screen resolution, refresh rate and depth
+    kr = IOFBGetCurrentDisplayModeAndDepth( fbService,
+                                            &displayMode,
+                                            &displayDepth );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+
+    // use the current screen resolution if the user
+    // only wants to change the refresh rate
+    if (darwinDesiredRefresh != -1 && darwinDesiredWidth == 0) {
+        kr = IOFBGetDisplayModeInformation( fbService,
+                                            displayMode,
+                                            &modeInfo );
+        if (kr != KERN_SUCCESS)
+            return FALSE;
+        darwinDesiredWidth = modeInfo.nominalWidth;
+        darwinDesiredHeight = modeInfo.nominalHeight;
+    }
+
+    // use the current resolution and refresh rate
+    // if the user doesn't have a preference
+    if (darwinDesiredWidth == 0) {
+
+        // change the pixel depth if desired
+        if (darwinDesiredDepth != -1) {
+            kr = IOFBGetDisplayModeInformation( fbService,
+                                                displayMode,
+                                                &modeInfo );
+            if (kr != KERN_SUCCESS)
+                return FALSE;
+            if (modeInfo.maxDepthIndex < darwinDesiredDepth) {
+                ErrorF("Discarding screen %i:\n", index);
+                ErrorF("Current screen resolution does not support desired pixel depth.\n");
+                return FALSE;
+            }
+
+            displayDepth = darwinDesiredDepth;
+            kr = IOFBSetDisplayModeAndDepth( fbService, displayMode,
+                                             displayDepth );
+            if (kr != KERN_SUCCESS)
+                return FALSE;
+        }
+
+    // look for display mode with correct resolution and refresh rate
+    } else {
+
+        // get an array of all supported display modes
+        kr = IOFBGetDisplayModeCount( fbService, &numModes );
+        if (kr != KERN_SUCCESS)
+            return FALSE;
+        assert(allModes = (IODisplayModeID *)
+                xalloc( numModes * sizeof(IODisplayModeID) ));
+        kr = IOFBGetDisplayModes( fbService, numModes, allModes );
+        if (kr != KERN_SUCCESS)
+            return FALSE;
+
+        for (i = 0; i < numModes; i++) {
+            kr = IOFBGetDisplayModeInformation( fbService, allModes[i],
+                                                &modeInfo );
+            if (kr != KERN_SUCCESS)
+                return FALSE;
+
+            if (modeInfo.flags & kDisplayModeValidFlag &&
+                modeInfo.nominalWidth == darwinDesiredWidth &&
+                modeInfo.nominalHeight == darwinDesiredHeight) {
+
+                if (darwinDesiredDepth == -1)
+                    darwinDesiredDepth = modeInfo.maxDepthIndex;
+                if (modeInfo.maxDepthIndex < darwinDesiredDepth) {
+                    ErrorF("Discarding screen %i:\n", index);
+                    ErrorF("Desired screen resolution does not support desired pixel depth.\n");
+                    return FALSE;
+                }
+
+                if ((darwinDesiredRefresh == -1 ||
+                    (darwinDesiredRefresh << 16) == modeInfo.refreshRate)) {
+                    displayMode = allModes[i];
+                    displayDepth = darwinDesiredDepth;
+                    kr = IOFBSetDisplayModeAndDepth(fbService,
+                                                    displayMode,
+                                                    displayDepth);
+                    if (kr != KERN_SUCCESS)
+                        return FALSE;
+                    break;
+                }
+            }
+        }
+
+        xfree( allModes );
+        if (i >= numModes) {
+            ErrorF("Discarding screen %i:\n", index);
+            ErrorF("Desired screen resolution or refresh rate is not supported.\n");
+            return FALSE;
+        }
+    }
+
+    kr = IOFBGetPixelInformation( fbService, displayMode, displayDepth,
+                                  kIOFBSystemAperture, &pixelInfo );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+
+#ifdef __i386__
+    /* x86 in 8bit mode currently needs fixed color map... */
+    if( pixelInfo.bitsPerComponent == 8 ) {
+        pixelInfo.pixelType = kIOFixedCLUTPixels;
+    }
+#endif
+
+#ifdef OLD_POWERBOOK_G3
+    if (pixelInfo.pixelType == kIOCLUTPixels)
+        pixelInfo.pixelType = kIOFixedCLUTPixels;
+#endif
+
+    kr = IOFBGetFramebufferInformationForAperture( fbService,
+                                                   kIOFBSystemAperture,
+                                                   &fbInfo );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+
+    // FIXME: 1x1 IOFramebuffers are sometimes used to indicate video
+    // outputs without a monitor connected to them. Since IOKit Xinerama
+    // does not really work, this often causes problems on PowerBooks.
+    // For now we explicitly check and ignore these screens.
+    if (fbInfo.activeWidth <= 1 || fbInfo.activeHeight <= 1) {
+        ErrorF("Discarding screen %i:\n", index);
+        ErrorF("Invalid width or height.\n");
+        return FALSE;
+    }
+
+    kr = IOConnectMapMemory( fbService, kIOFBCursorMemory,
+                             mach_task_self(), (vm_address_t *) &cshmem,
+                             &shmemSize, kIOMapAnywhere );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+    iokitScreen->cursorShmem = cshmem;
+
+    kr = IOConnectMapMemory( fbService, kIOFBSystemAperture,
+                             mach_task_self(), &vram, &shmemSize,
+                             kIOMapAnywhere );
+    if (kr != KERN_SUCCESS)
+        return FALSE;
+
+    iokitScreen->framebuffer = (void*)vram;
+    dfb->x = cshmem->screenBounds.minx;
+    dfb->y = cshmem->screenBounds.miny;
+    dfb->width = fbInfo.activeWidth;
+    dfb->height = fbInfo.activeHeight;
+    dfb->pitch = fbInfo.bytesPerRow;
+    dfb->bitsPerPixel = fbInfo.bitsPerPixel;
+    dfb->colorBitsPerPixel = pixelInfo.componentCount *
+                             pixelInfo.bitsPerComponent;
+    dfb->bitsPerComponent = pixelInfo.bitsPerComponent;
+
+    // allocate shadow framebuffer
+    iokitScreen->shadowPtr = shadowAlloc(dfb->width, dfb->height,
+                                         dfb->bitsPerPixel);
+    dfb->framebuffer = iokitScreen->shadowPtr;
+
+    // Note: Darwin kIORGBDirectPixels = X TrueColor, not DirectColor
+    if (pixelInfo.pixelType == kIORGBDirectPixels) {
+        dfb->colorType = TrueColor;
+    } else if (pixelInfo.pixelType == kIOCLUTPixels) {
+        dfb->colorType = PseudoColor;
+    } else if (pixelInfo.pixelType == kIOFixedCLUTPixels) {
+        dfb->colorType = StaticColor;
+    }
+
+    // Inform the HID system that the framebuffer is also connected to it.
+    kr = IOConnectAddClient( xfIOKitInputConnect, fbService );
+    kern_assert( kr );
+
+    // We have to have added at least one screen
+    // before we can enable the cursor.
+    kr = IOHIDSetCursorEnable(xfIOKitInputConnect, TRUE);
+    kern_assert( kr );
+
+    return TRUE;
+}
+
+
+/*
+ * DarwinModeAddScreen
+ *  IOKit specific initialization for each screen.
+ */
+Bool DarwinModeAddScreen(
+    int index,
+    ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    XFIOKitScreenPtr iokitScreen;
+
+    // allocate space for private per screen storage
+    iokitScreen = xalloc(sizeof(XFIOKitScreenRec));
+    XFIOKIT_SCREEN_PRIV(pScreen) = iokitScreen;
+
+    // setup hardware framebuffer
+    iokitScreen->fbService = 0;
+    if (! SetupFBandHID(index, dfb, iokitScreen)) {
+        if (iokitScreen->fbService) {
+            IOServiceClose(iokitScreen->fbService);
+        }
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+
+/*
+ * XFIOKitShadowUpdate
+ *  Update the damaged regions of the shadow framebuffer on the screen.
+ */
+static void XFIOKitShadowUpdate(ScreenPtr pScreen, 
+                                shadowBufPtr pBuf)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    XFIOKitScreenPtr iokitScreen = XFIOKIT_SCREEN_PRIV(pScreen);
+    RegionPtr damage = &pBuf->damage;
+    int numBox = REGION_NUM_RECTS(damage);
+    BoxPtr pBox = REGION_RECTS(damage);
+    int pitch = dfb->pitch;
+    int bpp = dfb->bitsPerPixel/8;
+
+    // Loop through all the damaged boxes
+    while (numBox--) {
+        int width, height, offset;
+        unsigned char *src, *dst;
+
+        width = (pBox->x2 - pBox->x1) * bpp;
+        height = pBox->y2 - pBox->y1;
+        offset = (pBox->y1 * pitch) + (pBox->x1 * bpp);
+        src = iokitScreen->shadowPtr + offset;
+        dst = iokitScreen->framebuffer + offset;
+
+        while (height--) {
+            memcpy(dst, src, width);
+            dst += pitch;
+            src += pitch;
+        }
+
+        // Get the next box
+        pBox++;
+    }
+}
+
+
+/*
+ * DarwinModeSetupScreen
+ *  Finalize IOKit specific initialization of each screen.
+ */
+Bool DarwinModeSetupScreen(
+    int index,
+    ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    pthread_t pmThread;
+
+    // initalize cursor support
+    if (! XFIOKitInitCursor(pScreen)) {
+        return FALSE;
+    }
+
+    // initialize shadow framebuffer support
+    if (! shadowInit(pScreen, XFIOKitShadowUpdate, NULL)) {
+        ErrorF("Failed to initalize shadow framebuffer for screen %i.\n",
+               index);
+        return FALSE;
+    }
+
+    // initialize colormap handling as needed
+    if (dfb->colorType == PseudoColor) {
+        pScreen->StoreColors = XFIOKitStoreColors;
+    }
+
+    // initialize power manager handling
+    pthread_create( &pmThread, NULL, XFIOKitPMThread,
+                    (void *) pScreen );
+
+    return TRUE;
+}
+
+
+/*
+ * DarwinModeInitOutput
+ *  One-time initialization of IOKit output support.
+ */
+void DarwinModeInitOutput(
+    int argc,
+    char **argv)
+{
+    static unsigned long    generation = 0;
+    kern_return_t           kr;
+    io_iterator_t           iter;
+    io_service_t            service;
+    vm_address_t            shmem;
+    vm_size_t               shmemSize;
+
+    ErrorF("Display mode: IOKit\n");
+
+    // Allocate private storage for each screen's IOKit specific info
+    if (generation != serverGeneration) {
+        xfIOKitScreenIndex = AllocateScreenPrivateIndex();
+        generation = serverGeneration;
+    }
+
+    kr = IOMasterPort(bootstrap_port, &masterPort);
+    kern_assert( kr );
+
+    // Find and open the HID System Service
+    // Do this now to be sure the Mac OS X window server is not running.
+    kr = IOServiceGetMatchingServices( masterPort,
+                                       IOServiceMatching( kIOHIDSystemClass ),
+                                       &iter );
+    kern_assert( kr );
+
+    assert( service = IOIteratorNext( iter ) );
+
+    kr = IOServiceOpen( service, mach_task_self(), kIOHIDServerConnectType,
+                        &xfIOKitInputConnect );
+    if (kr != KERN_SUCCESS) {
+        ErrorF("Failed to connect to the HID System as the window server!\n");
+#ifdef DARWIN_WITH_QUARTZ
+        FatalError("Quit the Mac OS X window server or use the -quartz option.\n");
+#else
+        FatalError("Make sure you have quit the Mac OS X window server.\n");
+#endif
+    }
+
+    IOObjectRelease( service );
+    IOObjectRelease( iter );
+
+    // Setup the event queue in memory shared by the kernel and X server
+    kr = IOHIDCreateSharedMemory( xfIOKitInputConnect,
+                                  kIOHIDCurrentShmemVersion );
+    kern_assert( kr );
+
+    kr = IOConnectMapMemory( xfIOKitInputConnect, kIOHIDGlobalMemory,
+                             mach_task_self(), &shmem, &shmemSize,
+                             kIOMapAnywhere );
+    kern_assert( kr );
+
+    evg = (EvGlobals *)(shmem + ((EvOffsets *)shmem)->evGlobalsOffset);
+
+    assert(sizeof(EvGlobals) == evg->structSize);
+
+    NotificationPortRef = IONotificationPortCreate( masterPort );
+
+    notificationPort = IONotificationPortGetMachPort(NotificationPortRef);
+
+    kr = IOConnectSetNotificationPort( xfIOKitInputConnect,
+                                       kIOHIDEventNotification,
+                                       notificationPort, 0 );
+    kern_assert( kr );
+
+    evg->movedMask |= NX_MOUSEMOVEDMASK;
+
+    // find number of framebuffers
+    kr = IOServiceGetMatchingServices( masterPort,
+                        IOServiceMatching( IOFRAMEBUFFER_CONFORMSTO ),
+                        &fbIter );
+    kern_assert( kr );
+
+    darwinScreensFound = 0;
+    while ((service = IOIteratorNext(fbIter))) {
+        IOObjectRelease( service );
+        darwinScreensFound++;
+    }
+    IOIteratorReset(fbIter);
+}
+
+
+/*
+ * DarwinModeInitInput
+ *  One-time initialization of IOKit input support.
+ */
+void DarwinModeInitInput(
+    int argc,
+    char **argv)
+{
+    kern_return_t           kr;
+    int                     fd[2];
+
+    kr = IOHIDSetEventsEnable(xfIOKitInputConnect, TRUE);
+    kern_assert( kr );
+
+    // Start event passing thread
+    assert( pipe(fd) == 0 );
+    darwinEventReadFD = fd[0];
+    darwinEventWriteFD = fd[1];
+    fcntl(darwinEventReadFD, F_SETFL, O_NONBLOCK);
+    pthread_create(&inputThread, NULL,
+                   XFIOKitHIDThread, NULL);
+
+}
+
+
+/*
+ * DarwinModeProcessEvent
+ *  Process IOKit specific events.
+ */
+void DarwinModeProcessEvent(
+    xEvent *xe)
+{
+    // No mode specific events
+    ErrorF("Unknown X event caught: %d\n", xe->u.u.type);
+}
diff --git a/hw/darwin/iokit/xfIOKit.h b/hw/darwin/iokit/xfIOKit.h
new file mode 100644
index 000000000..413dfd7e8
--- /dev/null
+++ b/hw/darwin/iokit/xfIOKit.h
@@ -0,0 +1,57 @@
+/*
+  xfIOKit.h
+
+  IOKit specific functions and definitions
+*/
+/*
+ * Copyright (c) 2001-2002 Torrey T. Lyons. 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/iokit/xfIOKit.h,v 1.1 2003/05/14 05:27:56 torrey Exp $ */
+
+#ifndef _XFIOKIT_H
+#define _XFIOKIT_H
+
+#include <pthread.h>
+#include <IOKit/graphics/IOFramebufferShared.h>
+#include "X11/Xproto.h"
+#include "screenint.h"
+#include "darwin.h"
+
+typedef struct {
+    io_connect_t        fbService;
+    StdFBShmem_t       *cursorShmem;
+    unsigned char      *framebuffer;
+    unsigned char      *shadowPtr;
+} XFIOKitScreenRec, *XFIOKitScreenPtr;
+
+#define XFIOKIT_SCREEN_PRIV(pScreen) \
+    ((XFIOKitScreenPtr)pScreen->devPrivates[xfIOKitScreenIndex].ptr)
+
+extern int xfIOKitScreenIndex; // index into pScreen.devPrivates
+extern io_connect_t xfIOKitInputConnect;
+
+Bool XFIOKitInitCursor(ScreenPtr pScreen);
+
+#endif	/* _XFIOKIT_H */
diff --git a/hw/darwin/iokit/xfIOKitCursor.c b/hw/darwin/iokit/xfIOKitCursor.c
new file mode 100644
index 000000000..f3c80145f
--- /dev/null
+++ b/hw/darwin/iokit/xfIOKitCursor.c
@@ -0,0 +1,735 @@
+/**************************************************************
+ *
+ * Cursor support for Darwin X Server
+ *
+ * Three different cursor modes are possible:
+ *  X (0)         - tracking via Darwin kernel,
+ *                  display via X machine independent
+ *  Kernel (1)    - tracking and display via Darwin kernel
+ *                  (not currently supported)
+ *  Hardware (2)  - tracking and display via hardware
+ *
+ * The X software cursor uses the Darwin software cursor
+ * routines in IOFramebuffer.cpp to track the cursor, but
+ * displays the cursor image using the X machine
+ * independent display cursor routines in midispcur.c.
+ *
+ * The kernel cursor uses IOFramebuffer.cpp routines to
+ * track and display the cursor. This gives better
+ * performance as the display calls don't have to cross
+ * the kernel boundary. Unfortunately, this mode has
+ * synchronization issues with the user land X server
+ * and isn't currently used.
+ *
+ * Hardware cursor support lets the hardware handle these
+ * details.
+ *
+ * Kernel and hardware cursor mode only work for cursors
+ * up to a certain size, currently 16x16 pixels. If a
+ * bigger cursor is set, we fallback to X cursor mode.
+ *
+ * HISTORY:
+ * 1.0 by Torrey T. Lyons, October 30, 2000
+ *
+ **************************************************************/
+/*
+ * Copyright (c) 2001-2002 Torrey T. Lyons. 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/iokit/xfIOKitCursor.c,v 1.1 2003/05/14 05:27:56 torrey Exp $ */
+
+#include "scrnintstr.h"
+#include "cursorstr.h"
+#include "mipointrst.h"
+#include "micmap.h"
+#define NO_CFPLUGIN
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <IOKit/hidsystem/IOHIDLib.h>
+#include "darwin.h"
+#include "xfIOKit.h"
+
+#define DUMP_DARWIN_CURSOR FALSE
+
+#define CURSOR_PRIV(pScreen) \
+    ((XFIOKitCursorScreenPtr)pScreen->devPrivates[darwinCursorScreenIndex].ptr)
+
+// The cursors format are documented in IOFramebufferShared.h.
+#define RGBto34WithGamma(red, green, blue)  \
+    (  0x000F                               \
+     | (((red) & 0xF) << 12)                \
+     | (((green) & 0xF) << 8)               \
+     | (((blue) & 0xF) << 4) )
+#define RGBto38WithGamma(red, green, blue)  \
+    (  0xFF << 24                           \
+     | (((red) & 0xFF) << 16)               \
+     | (((green) & 0xFF) << 8)              \
+     | (((blue) & 0xFF)) )
+#define HighBitOf32 0x80000000
+
+typedef struct {
+    Bool                    canHWCursor;
+    short                   cursorMode;
+    RecolorCursorProcPtr    RecolorCursor;
+    InstallColormapProcPtr  InstallColormap;
+    QueryBestSizeProcPtr    QueryBestSize;
+    miPointerSpriteFuncPtr  spriteFuncs;
+    ColormapPtr             pInstalledMap;
+} XFIOKitCursorScreenRec, *XFIOKitCursorScreenPtr;
+
+static int darwinCursorScreenIndex = -1;
+static unsigned long darwinCursorGeneration = 0;
+
+/*
+===========================================================================
+
+ Pointer sprite functions
+
+===========================================================================
+*/
+
+/*
+    Realizing the Darwin hardware cursor (ie. converting from the
+    X representation to the IOKit representation) is complicated
+    by the fact that we have three different potential cursor
+    formats to go to, one for each bit depth (8, 15, or 24).
+    The IOKit formats are documented in IOFramebufferShared.h.
+    X cursors are represented as two pieces, a source and a mask.
+    The mask is a bitmap indicating which parts of the cursor are 
+    transparent and which parts are drawn.  The source is a bitmap
+    indicating which parts of the non-transparent portion of the the
+    cursor should be painted in the foreground color and which should
+    be painted in the background color. The bitmaps are given in
+    32-bit format with least significant byte and bit first.
+    (This is opposite PowerPC Darwin.)
+*/
+
+typedef struct {
+    unsigned char image[CURSORWIDTH*CURSORHEIGHT];
+    unsigned char mask[CURSORWIDTH*CURSORHEIGHT];
+} cursorPrivRec, *cursorPrivPtr;
+
+/*
+ * XFIOKitRealizeCursor8
+ * Convert the X cursor representation to an 8-bit depth
+ * format for Darwin. This function assumes the maximum cursor
+ * width is a multiple of 8.
+ */
+static Bool
+XFIOKitRealizeCursor8(
+    ScreenPtr pScreen,
+    CursorPtr pCursor)
+{
+    cursorPrivPtr   newCursor;
+    unsigned char   *newSourceP, *newMaskP;
+    CARD32          *oldSourceP, *oldMaskP;
+    xColorItem      fgColor, bgColor;
+    int             index, x, y, rowPad;
+    int             cursorWidth, cursorHeight;
+    ColormapPtr     pmap;
+
+    // check cursor size just to be sure
+    cursorWidth = pCursor->bits->width;
+    cursorHeight = pCursor->bits->height;
+    if (cursorHeight > CURSORHEIGHT || cursorWidth > CURSORWIDTH)
+        return FALSE;
+
+    // get cursor colors in colormap
+    index = pScreen->myNum;
+    pmap = miInstalledMaps[index];
+    if (!pmap) return FALSE;
+
+    fgColor.red = pCursor->foreRed;
+    fgColor.green = pCursor->foreGreen;
+    fgColor.blue = pCursor->foreBlue;
+    FakeAllocColor(pmap, &fgColor);
+    bgColor.red = pCursor->backRed;
+    bgColor.green = pCursor->backGreen;
+    bgColor.blue = pCursor->backBlue;
+    FakeAllocColor(pmap, &bgColor);
+    FakeFreeColor(pmap, fgColor.pixel);
+    FakeFreeColor(pmap, bgColor.pixel);
+
+    // allocate memory for new cursor image
+    newCursor = xalloc( sizeof(cursorPrivRec) );
+    if (!newCursor)
+        return FALSE;
+    memset( newCursor->image, pScreen->blackPixel, CURSORWIDTH*CURSORHEIGHT );
+    memset( newCursor->mask, 0, CURSORWIDTH*CURSORHEIGHT );
+
+    // convert to 8-bit Darwin cursor format
+    oldSourceP = (CARD32 *) pCursor->bits->source;
+    oldMaskP = (CARD32 *) pCursor->bits->mask;
+    newSourceP = newCursor->image;
+    newMaskP = newCursor->mask;
+    rowPad = CURSORWIDTH - cursorWidth;
+
+    for (y = 0; y < cursorHeight; y++) {
+        for (x = 0; x < cursorWidth; x++) {
+            if (*oldSourceP & (HighBitOf32 >> x))
+                *newSourceP = fgColor.pixel;
+            else
+                *newSourceP = bgColor.pixel;
+            if (*oldMaskP & (HighBitOf32 >> x))
+                *newMaskP = 255;
+            else
+                *newSourceP = pScreen->blackPixel;
+            newSourceP++; newMaskP++;
+        }
+        oldSourceP++; oldMaskP++;
+        newSourceP += rowPad; newMaskP += rowPad;
+    }
+
+    // save the result
+    pCursor->devPriv[pScreen->myNum] = (pointer) newCursor;
+    return TRUE;
+}
+
+
+/*
+ * XFIOKitRealizeCursor15
+ * Convert the X cursor representation to an 15-bit depth
+ * format for Darwin.
+ */
+static Bool
+XFIOKitRealizeCursor15(
+    ScreenPtr       pScreen,
+    CursorPtr       pCursor)
+{
+    unsigned short  *newCursor;
+    unsigned short  fgPixel, bgPixel;
+    unsigned short  *newSourceP;
+    CARD32          *oldSourceP, *oldMaskP;
+    int             x, y, rowPad;
+    int             cursorWidth, cursorHeight;
+
+    // check cursor size just to be sure
+    cursorWidth = pCursor->bits->width;
+    cursorHeight = pCursor->bits->height;
+    if (cursorHeight > CURSORHEIGHT || cursorWidth > CURSORWIDTH)
+       return FALSE;
+
+    // allocate memory for new cursor image
+    newCursor = xalloc( CURSORWIDTH*CURSORHEIGHT*sizeof(short) );
+    if (!newCursor)
+        return FALSE;
+    memset( newCursor, 0, CURSORWIDTH*CURSORHEIGHT*sizeof(short) );
+
+    // calculate pixel values
+    fgPixel = RGBto34WithGamma( pCursor->foreRed, pCursor->foreGreen,
+                                pCursor->foreBlue );
+    bgPixel = RGBto34WithGamma( pCursor->backRed, pCursor->backGreen,
+                                pCursor->backBlue );
+
+    // convert to 15-bit Darwin cursor format
+    oldSourceP = (CARD32 *) pCursor->bits->source;
+    oldMaskP = (CARD32 *) pCursor->bits->mask;
+    newSourceP = newCursor;
+    rowPad = CURSORWIDTH - cursorWidth;
+
+    for (y = 0; y < cursorHeight; y++) {
+        for (x = 0; x < cursorWidth; x++) {
+            if (*oldMaskP & (HighBitOf32 >> x)) {
+                if (*oldSourceP & (HighBitOf32 >> x))
+                    *newSourceP = fgPixel;
+                else
+                    *newSourceP = bgPixel;
+            } else {
+                *newSourceP = 0;
+            }
+            newSourceP++;
+        }
+        oldSourceP++; oldMaskP++;
+        newSourceP += rowPad;
+    }
+
+#if DUMP_DARWIN_CURSOR
+    // Write out the cursor
+    ErrorF("Cursor: 0x%x\n", pCursor);
+    ErrorF("Width = %i, Height = %i, RowPad = %i\n", cursorWidth,
+            cursorHeight, rowPad);
+    for (y = 0; y < cursorHeight; y++) {
+        newSourceP = newCursor + y*CURSORWIDTH;
+        for (x = 0; x < cursorWidth; x++) {
+            if (*newSourceP == fgPixel)
+                ErrorF("x");
+            else if (*newSourceP == bgPixel)
+                ErrorF("o");
+            else
+                ErrorF(" ");
+            newSourceP++;
+        }
+        ErrorF("\n");
+    }
+#endif
+
+    // save the result
+    pCursor->devPriv[pScreen->myNum] = (pointer) newCursor;
+    return TRUE;
+}
+
+
+/*
+ * XFIOKitRealizeCursor24
+ * Convert the X cursor representation to an 24-bit depth
+ * format for Darwin. This function assumes the maximum cursor
+ * width is a multiple of 8.
+ */
+static Bool
+XFIOKitRealizeCursor24(
+    ScreenPtr       pScreen,
+    CursorPtr       pCursor)
+{
+    unsigned int    *newCursor;
+    unsigned int    fgPixel, bgPixel;
+    unsigned int    *newSourceP;
+    CARD32          *oldSourceP, *oldMaskP;
+    int             x, y, rowPad;
+    int             cursorWidth, cursorHeight;
+
+    // check cursor size just to be sure
+    cursorWidth = pCursor->bits->width;
+    cursorHeight = pCursor->bits->height;
+    if (cursorHeight > CURSORHEIGHT || cursorWidth > CURSORWIDTH)
+       return FALSE;
+
+    // allocate memory for new cursor image
+    newCursor = xalloc( CURSORWIDTH*CURSORHEIGHT*sizeof(int) );
+    if (!newCursor)
+        return FALSE;
+    memset( newCursor, 0, CURSORWIDTH*CURSORHEIGHT*sizeof(int) );
+
+    // calculate pixel values
+    fgPixel = RGBto38WithGamma( pCursor->foreRed, pCursor->foreGreen,
+                                pCursor->foreBlue );
+    bgPixel = RGBto38WithGamma( pCursor->backRed, pCursor->backGreen,
+                                pCursor->backBlue );
+
+    // convert to 24-bit Darwin cursor format
+    oldSourceP = (CARD32 *) pCursor->bits->source;
+    oldMaskP = (CARD32 *) pCursor->bits->mask;
+    newSourceP = newCursor;
+    rowPad = CURSORWIDTH - cursorWidth;
+
+    for (y = 0; y < cursorHeight; y++) {
+        for (x = 0; x < cursorWidth; x++) {
+            if (*oldMaskP & (HighBitOf32 >> x)) {
+                if (*oldSourceP & (HighBitOf32 >> x))
+                    *newSourceP = fgPixel;
+                else
+                    *newSourceP = bgPixel;
+            } else {
+                *newSourceP = 0;
+            }
+            newSourceP++;
+        }
+        oldSourceP++; oldMaskP++;
+        newSourceP += rowPad;
+    }
+
+#if DUMP_DARWIN_CURSOR
+    // Write out the cursor
+    ErrorF("Cursor: 0x%x\n", pCursor);
+    ErrorF("Width = %i, Height = %i, RowPad = %i\n", cursorWidth,
+            cursorHeight, rowPad);
+    for (y = 0; y < cursorHeight; y++) {
+        newSourceP = newCursor + y*CURSORWIDTH;
+        for (x = 0; x < cursorWidth; x++) {
+            if (*newSourceP == fgPixel)
+                ErrorF("x");
+            else if (*newSourceP == bgPixel)
+                ErrorF("o");
+            else
+                ErrorF(" ");
+            newSourceP++;
+        }
+        ErrorF("\n");
+    }
+#endif
+
+    // save the result
+    pCursor->devPriv[pScreen->myNum] = (pointer) newCursor;
+    return TRUE;
+}
+
+
+/*
+ * XFIOKitRealizeCursor
+ * 
+ */
+static Bool
+XFIOKitRealizeCursor(
+    ScreenPtr       pScreen,
+    CursorPtr       pCursor)
+{
+    Bool                        result;
+    XFIOKitCursorScreenPtr      ScreenPriv = CURSOR_PRIV(pScreen);
+    DarwinFramebufferPtr        dfb = SCREEN_PRIV(pScreen);
+
+    if ((pCursor->bits->height > CURSORHEIGHT) ||
+        (pCursor->bits->width > CURSORWIDTH) ||
+        // FIXME: this condition is not needed after kernel cursor works
+        !ScreenPriv->canHWCursor) {
+        result = (*ScreenPriv->spriteFuncs->RealizeCursor)(pScreen, pCursor);
+    } else if (dfb->bitsPerPixel == 8) {
+        result = XFIOKitRealizeCursor8(pScreen, pCursor);
+    } else if (dfb->bitsPerPixel == 16) {
+        result = XFIOKitRealizeCursor15(pScreen, pCursor);
+    } else {
+        result = XFIOKitRealizeCursor24(pScreen, pCursor);
+    }
+
+    return result;
+}
+
+
+/*
+ * XFIOKitUnrealizeCursor
+ * 
+ */
+static Bool
+XFIOKitUnrealizeCursor(
+    ScreenPtr pScreen,
+    CursorPtr pCursor)
+{
+    Bool                        result;
+    XFIOKitCursorScreenPtr      ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if ((pCursor->bits->height > CURSORHEIGHT) ||
+        (pCursor->bits->width > CURSORWIDTH) ||
+        // FIXME: this condition is not needed after kernel cursor works
+        !ScreenPriv->canHWCursor) {
+        result = (*ScreenPriv->spriteFuncs->UnrealizeCursor)(pScreen, pCursor);
+    } else {
+        xfree( pCursor->devPriv[pScreen->myNum] );
+        result = TRUE;
+    }
+
+    return result;
+}
+
+
+/*
+ * XFIOKitSetCursor
+ * Set the cursor sprite and position
+ * Use hardware cursor if possible
+ */
+static void
+XFIOKitSetCursor(
+    ScreenPtr       pScreen,
+    CursorPtr       pCursor,
+    int             x,
+    int             y)
+{
+    kern_return_t               kr;
+    DarwinFramebufferPtr        dfb = SCREEN_PRIV(pScreen);
+    XFIOKitScreenPtr            iokitScreen = XFIOKIT_SCREEN_PRIV(pScreen);
+    StdFBShmem_t                *cshmem = iokitScreen->cursorShmem;
+    XFIOKitCursorScreenPtr      ScreenPriv = CURSOR_PRIV(pScreen);
+
+    // are we supposed to remove the cursor?
+    if (!pCursor) {
+        if (ScreenPriv->cursorMode == 0)
+            (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, 0, x, y);
+        else {
+            if (!cshmem->cursorShow) {
+                cshmem->cursorShow++;
+                if (cshmem->hardwareCursorActive) {
+                    kr = IOFBSetCursorVisible(iokitScreen->fbService, FALSE);
+                    kern_assert( kr );
+                }
+            }
+        }
+        return;
+    } 
+ 
+    // can we use the kernel or hardware cursor?
+    if ((pCursor->bits->height <= CURSORHEIGHT) &&
+        (pCursor->bits->width <= CURSORWIDTH) &&
+        // FIXME: condition not needed when kernel cursor works
+        ScreenPriv->canHWCursor) {
+
+        if (ScreenPriv->cursorMode == 0)    // remove the X cursor
+            (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, 0, x, y);
+        ScreenPriv->cursorMode = 1;         // kernel cursor
+
+        // change the cursor image in shared memory
+        if (dfb->bitsPerPixel == 8) {
+            cursorPrivPtr newCursor =
+                    (cursorPrivPtr) pCursor->devPriv[pScreen->myNum];
+            memcpy(cshmem->cursor.bw8.image[0], newCursor->image,
+                        CURSORWIDTH*CURSORHEIGHT);
+            memcpy(cshmem->cursor.bw8.mask[0], newCursor->mask,
+                        CURSORWIDTH*CURSORHEIGHT);
+        } else if (dfb->bitsPerPixel == 16) {
+            unsigned short *newCursor =
+                    (unsigned short *) pCursor->devPriv[pScreen->myNum];
+            memcpy(cshmem->cursor.rgb.image[0], newCursor,
+                        2*CURSORWIDTH*CURSORHEIGHT);
+        } else {
+            unsigned int *newCursor =
+                    (unsigned int *) pCursor->devPriv[pScreen->myNum];
+            memcpy(cshmem->cursor.rgb24.image[0], newCursor,
+                        4*CURSORWIDTH*CURSORHEIGHT);
+        }
+
+        // FIXME: We always use a full size cursor, even if the image
+        // is smaller because I couldn't get the padding to come out
+        // right otherwise.
+        cshmem->cursorSize[0].width = CURSORWIDTH;
+        cshmem->cursorSize[0].height = CURSORHEIGHT;
+        cshmem->hotSpot[0].x = pCursor->bits->xhot;
+        cshmem->hotSpot[0].y = pCursor->bits->yhot;
+
+        // try to use a hardware cursor
+        if (ScreenPriv->canHWCursor) {
+            kr = IOFBSetNewCursor(iokitScreen->fbService, 0, 0, 0);
+            // FIXME: this is a fatal error without the kernel cursor
+            kern_assert( kr );
+#if 0
+            if (kr != KERN_SUCCESS) {
+                ErrorF("Could not set new cursor with kernel return 0x%x.\n", kr);
+                ScreenPriv->canHWCursor = FALSE;
+            }
+#endif
+        }
+
+        // make the new cursor visible
+        if (cshmem->cursorShow)
+            cshmem->cursorShow--;
+
+        if (!cshmem->cursorShow && ScreenPriv->canHWCursor) {
+            kr = IOFBSetCursorVisible(iokitScreen->fbService, TRUE);
+            // FIXME: this is a fatal error without the kernel cursor
+            kern_assert( kr );
+#if 0
+            if (kr != KERN_SUCCESS) {
+                ErrorF("Couldn't set hardware cursor visible with kernel return 0x%x.\n", kr);
+                ScreenPriv->canHWCursor = FALSE;
+            } else
+#endif
+                ScreenPriv->cursorMode = 2;     // hardware cursor
+        }
+
+	return; 
+    }
+
+    // otherwise we use a software cursor
+    if (ScreenPriv->cursorMode) {
+        /* remove the kernel or hardware cursor */
+        XFIOKitSetCursor(pScreen, 0, x, y);
+    }
+
+    ScreenPriv->cursorMode = 0;
+    (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, pCursor, x, y);
+}
+
+
+/*
+ * XFIOKitMoveCursor
+ * Move the cursor. This is a noop for a kernel or hardware cursor.
+ */
+static void
+XFIOKitMoveCursor(
+    ScreenPtr   pScreen,
+    int         x,
+    int         y)
+{
+    XFIOKitCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    // only the X cursor needs to be explicitly moved
+    if (!ScreenPriv->cursorMode)
+        (*ScreenPriv->spriteFuncs->MoveCursor)(pScreen, x, y);
+}
+
+static miPointerSpriteFuncRec darwinSpriteFuncsRec = {
+    XFIOKitRealizeCursor,
+    XFIOKitUnrealizeCursor,
+    XFIOKitSetCursor,
+    XFIOKitMoveCursor
+};
+
+
+/*
+===========================================================================
+
+ Pointer screen functions
+
+===========================================================================
+*/
+
+/*
+ * XFIOKitCursorOffScreen
+ */
+static Bool XFIOKitCursorOffScreen(ScreenPtr *pScreen, int *x, int *y)
+{	return FALSE;
+}
+
+
+/*
+ * XFIOKitCrossScreen
+ */
+static void XFIOKitCrossScreen(ScreenPtr pScreen, Bool entering)
+{	return;
+}
+
+
+/*
+ * XFIOKitWarpCursor
+ * Change the cursor position without generating an event or motion history
+ */
+static void
+XFIOKitWarpCursor(
+    ScreenPtr               pScreen,
+    int                     x,
+    int                     y)
+{
+    kern_return_t           kr;
+
+    kr = IOHIDSetMouseLocation( xfIOKitInputConnect, x, y );
+    if (kr != KERN_SUCCESS) {
+        ErrorF("Could not set cursor position with kernel return 0x%x.\n", kr);
+    }
+    miPointerWarpCursor(pScreen, x, y);
+}
+
+static miPointerScreenFuncRec darwinScreenFuncsRec = {
+  XFIOKitCursorOffScreen,
+  XFIOKitCrossScreen,
+  XFIOKitWarpCursor,
+  DarwinEQPointerPost,
+  DarwinEQSwitchScreen
+};
+
+
+/*
+===========================================================================
+
+ Other screen functions
+
+===========================================================================
+*/
+
+/*
+ * XFIOKitCursorQueryBestSize
+ * Handle queries for best cursor size
+ */
+static void
+XFIOKitCursorQueryBestSize(
+   int              class, 
+   unsigned short   *width,
+   unsigned short   *height,
+   ScreenPtr        pScreen)
+{
+    XFIOKitCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if (class == CursorShape) {
+        *width = CURSORWIDTH;
+        *height = CURSORHEIGHT;
+    } else
+        (*ScreenPriv->QueryBestSize)(class, width, height, pScreen);
+}
+
+
+/*
+ * XFIOKitInitCursor
+ * Initialize cursor support
+ */
+Bool 
+XFIOKitInitCursor(
+    ScreenPtr	pScreen)
+{
+    XFIOKitScreenPtr        iokitScreen = XFIOKIT_SCREEN_PRIV(pScreen);
+    XFIOKitCursorScreenPtr  ScreenPriv;
+    miPointerScreenPtr	    PointPriv;
+    kern_return_t           kr;
+
+    // start with no cursor displayed
+    if (!iokitScreen->cursorShmem->cursorShow++) {
+        if (iokitScreen->cursorShmem->hardwareCursorActive) {
+            kr = IOFBSetCursorVisible(iokitScreen->fbService, FALSE);
+            kern_assert( kr );
+        }
+    }
+
+    // initialize software cursor handling (always needed as backup)
+    if (!miDCInitialize(pScreen, &darwinScreenFuncsRec)) {
+        return FALSE;
+    }
+
+    // allocate private storage for this screen's hardware cursor info
+    if (darwinCursorGeneration != serverGeneration) {
+        if ((darwinCursorScreenIndex = AllocateScreenPrivateIndex()) < 0)
+            return FALSE;
+        darwinCursorGeneration = serverGeneration; 	
+    }
+
+    ScreenPriv = xcalloc( 1, sizeof(XFIOKitCursorScreenRec) );
+    if (!ScreenPriv) return FALSE;
+
+    pScreen->devPrivates[darwinCursorScreenIndex].ptr = (pointer) ScreenPriv;
+
+    // check if a hardware cursor is supported
+    if (!iokitScreen->cursorShmem->hardwareCursorCapable) {
+        ScreenPriv->canHWCursor = FALSE;
+        ErrorF("Hardware cursor not supported.\n");
+    } else {
+        // we need to make sure that the hardware cursor really works
+        ScreenPriv->canHWCursor = TRUE;
+        kr = IOFBSetNewCursor(iokitScreen->fbService, 0, 0, 0);
+        if (kr != KERN_SUCCESS) {
+            ErrorF("Could not set hardware cursor with kernel return 0x%x.\n", kr);
+            ScreenPriv->canHWCursor = FALSE;
+        }
+        kr = IOFBSetCursorVisible(iokitScreen->fbService, TRUE);
+        if (kr != KERN_SUCCESS) {
+            ErrorF("Couldn't set hardware cursor visible with kernel return 0x%x.\n", kr);
+            ScreenPriv->canHWCursor = FALSE;
+        }
+        IOFBSetCursorVisible(iokitScreen->fbService, FALSE);
+    }
+
+    ScreenPriv->cursorMode = 0;
+    ScreenPriv->pInstalledMap = NULL;
+
+    // override some screen procedures
+    ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
+    pScreen->QueryBestSize = XFIOKitCursorQueryBestSize;
+//    ScreenPriv->ConstrainCursor = pScreen->ConstrainCursor;
+//    pScreen->ConstrainCursor = XFIOKitConstrainCursor;
+
+    // initialize hardware cursor handling
+    PointPriv = (miPointerScreenPtr)
+                    pScreen->devPrivates[miPointerScreenIndex].ptr;
+
+    ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
+    PointPriv->spriteFuncs = &darwinSpriteFuncsRec; 
+
+    /* Other routines that might be overridden */
+/*
+    CursorLimitsProcPtr		CursorLimits;
+    RecolorCursorProcPtr	RecolorCursor;
+*/
+
+    return TRUE;
+}
diff --git a/hw/darwin/iokit/xfIOKitStartup.c b/hw/darwin/iokit/xfIOKitStartup.c
new file mode 100644
index 000000000..9d25c69fe
--- /dev/null
+++ b/hw/darwin/iokit/xfIOKitStartup.c
@@ -0,0 +1,115 @@
+/**************************************************************
+ *
+ * Startup code for the IOKit Darwin X Server
+ *
+ **************************************************************/
+/*
+ * Copyright (c) 2001-2003 Torrey T. Lyons. 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/iokit/xfIOKitStartup.c,v 1.2 2003/11/01 08:13:08 torrey Exp $ */
+
+#include "darwin.h"
+#include "darwinKeyboard.h"
+#include "micmap.h"
+
+void GlxExtensionInit(void);
+void GlxWrapInitVisuals(miInitVisualsProcPtr *procPtr);
+
+
+/*
+ * DarwinHandleGUI
+ *  This function is called first from main().
+ *  It does nothing for the IOKit X server.
+ */
+void DarwinHandleGUI(
+    int         argc,
+    char        *argv[],
+    char        *envp[] )
+{
+}
+
+
+/*
+ * DarwinGlxExtensionInit
+ *  Initialize the GLX extension.
+ *  Mesa is linked into the IOKit mode X server so we just call directly.
+ */
+void DarwinGlxExtensionInit(void)
+{
+    GlxExtensionInit();
+}
+
+
+/*
+ * DarwinGlxWrapInitVisuals
+ */
+void DarwinGlxWrapInitVisuals(
+    miInitVisualsProcPtr *procPtr)
+{
+    GlxWrapInitVisuals(procPtr);
+}
+
+
+/*
+ * DarwinModeProcessArgument
+ *  Process IOKit specific command line arguments.
+ */
+int DarwinModeProcessArgument(
+    int argc,
+    char *argv[],
+    int i)
+{
+#ifdef DARWIN_WITH_QUARTZ
+    // XDarwinStartup uses these arguments to indicate which X server
+    // should be started. Ignore them here.
+    if (!strcmp( argv[i], "-fullscreen" ) ||
+        !strcmp( argv[i], "-rootless" ) ||
+        !strcmp( argv[i], "-quartz" ))
+    {
+        return 1;
+    }
+#else
+    if (!strcmp( argv[i], "-fullscreen" ) ||
+        !strcmp( argv[i], "-rootless" ) ||
+        !strcmp( argv[i], "-quartz" ))
+    {
+        FatalError("Command line option %s is not available without Quartz "
+                   "support.\n", argv[i]);
+    }
+#endif
+
+    return 0;
+}
+
+
+/*
+ * DarwinModeReadSystemKeymap
+ *  IOKit has no alternative to NXKeyMapping API.
+ */
+Bool DarwinModeReadSystemKeymap(
+    darwinKeyboardInfo *info)
+{
+    return FALSE;
+}
diff --git a/hw/darwin/quartz/applewm.c b/hw/darwin/quartz/applewm.c
new file mode 100644
index 000000000..d3e302727
--- /dev/null
+++ b/hw/darwin/quartz/applewm.c
@@ -0,0 +1,697 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/applewm.c,v 1.3 2003/11/11 23:48:41 torrey Exp $ */
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
+Copyright (c) 2003 Torrey T. Lyons. 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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+
+#include "quartzCommon.h"
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include "misc.h"
+#include "dixstruct.h"
+#include "globals.h"
+#include "extnsionst.h"
+#include "colormapst.h"
+#include "cursorstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "servermd.h"
+#include "swaprep.h"
+#include "Xatom.h"
+#include "darwin.h"
+#define _APPLEWM_SERVER_
+#include "applewmstr.h"
+#include "applewmExt.h"
+
+#define DEFINE_ATOM_HELPER(func,atom_name)			\
+static Atom func (void) {					\
+    static int generation;					\
+    static Atom atom;						\
+    if (generation != serverGeneration) {			\
+	generation = serverGeneration;				\
+	atom = MakeAtom (atom_name, strlen (atom_name), TRUE);	\
+    }								\
+    return atom;						\
+}
+
+DEFINE_ATOM_HELPER(xa_native_screen_origin, "_NATIVE_SCREEN_ORIGIN")
+
+static AppleWMProcsPtr appleWMProcs;
+
+static int WMErrorBase;
+
+static DISPATCH_PROC(ProcAppleWMDispatch);
+static DISPATCH_PROC(SProcAppleWMDispatch);
+
+static void AppleWMResetProc(ExtensionEntry* extEntry);
+
+static unsigned char WMReqCode = 0;
+static int WMEventBase = 0;
+
+static RESTYPE ClientType, EventType; /* resource types for event masks */
+static XID eventResource;
+
+/* Currently selected events */
+static unsigned int eventMask = 0;
+
+static int WMFreeClient (pointer data, XID id);
+static int WMFreeEvents (pointer data, XID id);
+static void SNotifyEvent(xAppleWMNotifyEvent *from, xAppleWMNotifyEvent *to);
+
+typedef struct _WMEvent *WMEventPtr;
+typedef struct _WMEvent {
+    WMEventPtr      next;
+    ClientPtr	    client;
+    XID		    clientResource;
+    unsigned int    mask;
+} WMEventRec;
+
+static inline BoxRec
+make_box (int x, int y, int w, int h)
+{
+    BoxRec r;
+    r.x1 = x;
+    r.y1 = y;
+    r.x2 = x + w;
+    r.y2 = y + h;
+    return r;
+}
+
+void
+AppleWMExtensionInit(
+    AppleWMProcsPtr procsPtr)
+{
+    ExtensionEntry* extEntry;
+
+    ClientType = CreateNewResourceType(WMFreeClient);
+    EventType = CreateNewResourceType(WMFreeEvents);
+    eventResource = FakeClientID(0);
+
+    if (ClientType && EventType &&
+        (extEntry = AddExtension(APPLEWMNAME,
+                                 AppleWMNumberEvents,
+                                 AppleWMNumberErrors,
+                                 ProcAppleWMDispatch,
+                                 SProcAppleWMDispatch,
+                                 AppleWMResetProc,
+                                 StandardMinorOpcode)))
+    {
+        WMReqCode = (unsigned char)extEntry->base;
+        WMErrorBase = extEntry->errorBase;
+        WMEventBase = extEntry->eventBase;
+        EventSwapVector[WMEventBase] = (EventSwapPtr) SNotifyEvent;
+        appleWMProcs = procsPtr;
+    }
+}
+
+/*ARGSUSED*/
+static void
+AppleWMResetProc (
+    ExtensionEntry* extEntry
+)
+{
+}
+
+/* Updates the _NATIVE_SCREEN_ORIGIN property on the given root window. */
+void
+AppleWMSetScreenOrigin(
+    WindowPtr pWin
+)
+{
+    long data[2];
+
+    data[0] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].x
+                + darwinMainScreenX);
+    data[1] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].y
+                + darwinMainScreenY);
+
+    ChangeWindowProperty(pWin, xa_native_screen_origin(), XA_INTEGER,
+                         32, PropModeReplace, 2, data, TRUE);
+}
+
+static int
+ProcAppleWMQueryVersion(
+    register ClientPtr client
+)
+{
+    xAppleWMQueryVersionReply rep;
+    register int n;
+
+    REQUEST_SIZE_MATCH(xAppleWMQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = APPLE_WM_MAJOR_VERSION;
+    rep.minorVersion = APPLE_WM_MINOR_VERSION;
+    rep.patchVersion = APPLE_WM_PATCH_VERSION;
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber, n);
+        swapl(&rep.length, n);
+    }
+    WriteToClient(client, sizeof(xAppleWMQueryVersionReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+
+/* events */
+
+static inline void
+updateEventMask (WMEventPtr *pHead)
+{
+    WMEventPtr pCur;
+
+    eventMask = 0;
+    for (pCur = *pHead; pCur != NULL; pCur = pCur->next)
+        eventMask |= pCur->mask;
+}
+
+/*ARGSUSED*/
+static int
+WMFreeClient (data, id)
+    pointer	    data;
+    XID		    id;
+{
+    WMEventPtr   pEvent;
+    WMEventPtr   *pHead, pCur, pPrev;
+
+    pEvent = (WMEventPtr) data;
+    pHead = (WMEventPtr *) LookupIDByType(eventResource, EventType);
+    if (pHead) {
+        pPrev = 0;
+        for (pCur = *pHead; pCur && pCur != pEvent; pCur=pCur->next)
+            pPrev = pCur;
+        if (pCur) {
+            if (pPrev)
+                pPrev->next = pEvent->next;
+            else
+                *pHead = pEvent->next;
+        }
+        updateEventMask (pHead);
+    }
+    xfree ((pointer) pEvent);
+    return 1;
+}
+
+/*ARGSUSED*/
+static int
+WMFreeEvents (data, id)
+    pointer	    data;
+    XID		    id;
+{
+    WMEventPtr   *pHead, pCur, pNext;
+
+    pHead = (WMEventPtr *) data;
+    for (pCur = *pHead; pCur; pCur = pNext) {
+        pNext = pCur->next;
+        FreeResource (pCur->clientResource, ClientType);
+        xfree ((pointer) pCur);
+    }
+    xfree ((pointer) pHead);
+    eventMask = 0;
+    return 1;
+}
+
+static int
+ProcAppleWMSelectInput (client)
+    register ClientPtr	client;
+{
+    REQUEST(xAppleWMSelectInputReq);
+    WMEventPtr		pEvent, pNewEvent, *pHead;
+    XID			clientResource;
+
+    REQUEST_SIZE_MATCH (xAppleWMSelectInputReq);
+    pHead = (WMEventPtr *)SecurityLookupIDByType(client,
+                        eventResource, EventType, SecurityWriteAccess);
+    if (stuff->mask != 0) {
+        if (pHead) {
+            /* check for existing entry. */
+            for (pEvent = *pHead; pEvent; pEvent = pEvent->next)
+            {
+                if (pEvent->client == client)
+                {
+                    pEvent->mask = stuff->mask;
+                    updateEventMask (pHead);
+                    return Success;
+                }
+            }
+        }
+
+        /* build the entry */
+        pNewEvent = (WMEventPtr) xalloc (sizeof (WMEventRec));
+        if (!pNewEvent)
+            return BadAlloc;
+        pNewEvent->next = 0;
+        pNewEvent->client = client;
+        pNewEvent->mask = stuff->mask;
+        /*
+         * add a resource that will be deleted when
+         * the client goes away
+         */
+        clientResource = FakeClientID (client->index);
+        pNewEvent->clientResource = clientResource;
+        if (!AddResource (clientResource, ClientType, (pointer)pNewEvent))
+            return BadAlloc;
+        /*
+         * create a resource to contain a pointer to the list
+         * of clients selecting input.  This must be indirect as
+         * the list may be arbitrarily rearranged which cannot be
+         * done through the resource database.
+         */
+        if (!pHead)
+        {
+            pHead = (WMEventPtr *) xalloc (sizeof (WMEventPtr));
+            if (!pHead ||
+                !AddResource (eventResource, EventType, (pointer)pHead))
+            {
+                FreeResource (clientResource, RT_NONE);
+                return BadAlloc;
+            }
+            *pHead = 0;
+        }
+        pNewEvent->next = *pHead;
+        *pHead = pNewEvent;
+        updateEventMask (pHead);
+    } else if (stuff->mask == 0) {
+        /* delete the interest */
+        if (pHead) {
+            pNewEvent = 0;
+            for (pEvent = *pHead; pEvent; pEvent = pEvent->next) {
+                if (pEvent->client == client)
+                    break;
+                pNewEvent = pEvent;
+            }
+            if (pEvent) {
+                FreeResource (pEvent->clientResource, ClientType);
+                if (pNewEvent)
+                    pNewEvent->next = pEvent->next;
+                else
+                    *pHead = pEvent->next;
+                xfree (pEvent);
+                updateEventMask (pHead);
+            }
+        }
+    } else {
+        client->errorValue = stuff->mask;
+        return BadValue;
+    }
+    return Success;
+}
+
+/*
+ * deliver the event
+ */
+
+void
+AppleWMSendEvent (type, mask, which, arg)
+    int type, which, arg;
+    unsigned int mask;
+{
+    WMEventPtr		*pHead, pEvent;
+    ClientPtr		client;
+    xAppleWMNotifyEvent se;
+
+    pHead = (WMEventPtr *) LookupIDByType(eventResource, EventType);
+    if (!pHead)
+        return;
+    for (pEvent = *pHead; pEvent; pEvent = pEvent->next) {
+        client = pEvent->client;
+        if ((pEvent->mask & mask) == 0
+            || client == serverClient || client->clientGone)
+        {
+            continue;
+        }
+        se.type = type + WMEventBase;
+        se.kind = which;
+        se.arg = arg;
+        se.sequenceNumber = client->sequence;
+        se.time = currentTime.milliseconds;
+        WriteEventsToClient (client, 1, (xEvent *) &se);
+    }
+}
+
+/* Safe to call from any thread. */
+unsigned int
+AppleWMSelectedEvents (void)
+{
+    return eventMask;
+}
+
+
+/* general utility functions */
+
+static int
+ProcAppleWMDisableUpdate(
+    register ClientPtr client
+)
+{
+    REQUEST_SIZE_MATCH(xAppleWMDisableUpdateReq);
+
+    appleWMProcs->DisableUpdate();
+
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMReenableUpdate(
+    register ClientPtr client
+)
+{
+    REQUEST_SIZE_MATCH(xAppleWMReenableUpdateReq);
+
+    appleWMProcs->EnableUpdate();
+
+    return (client->noClientException);
+}
+
+
+/* window functions */
+
+static int
+ProcAppleWMSetWindowMenu(
+    register ClientPtr client
+)
+{
+    const char *bytes, **items;
+    char *shortcuts;
+    int max_len, nitems, i, j;
+    REQUEST(xAppleWMSetWindowMenuReq);
+
+    REQUEST_AT_LEAST_SIZE(xAppleWMSetWindowMenuReq);
+
+    nitems = stuff->nitems;
+    items = xalloc (sizeof (char *) * nitems);
+    shortcuts = xalloc (sizeof (char) * nitems);
+
+    max_len = (stuff->length << 2) - sizeof(xAppleWMSetWindowMenuReq);
+    bytes = (char *) &stuff[1];
+
+    for (i = j = 0; i < max_len && j < nitems;)
+    {
+        shortcuts[j] = bytes[i++];
+        items[j++] = bytes + i;
+
+        while (i < max_len)
+        {
+            if (bytes[i++] == 0)
+                break;
+        }
+    }
+
+    QuartzSetWindowMenu (nitems, items, shortcuts);
+
+    free(items);
+    free(shortcuts);
+
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMSetWindowMenuCheck(
+    register ClientPtr client
+)
+{
+    REQUEST(xAppleWMSetWindowMenuCheckReq);
+
+    REQUEST_SIZE_MATCH(xAppleWMSetWindowMenuCheckReq);
+
+    QuartzMessageMainThread(kQuartzSetWindowMenuCheck, &stuff->index,
+                            sizeof(stuff->index));
+
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMSetFrontProcess(
+    register ClientPtr client
+)
+{
+    REQUEST_SIZE_MATCH(xAppleWMSetFrontProcessReq);
+
+    QuartzMessageMainThread(kQuartzSetFrontProcess, NULL, 0);
+
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMSetWindowLevel(
+    register ClientPtr client
+)
+{
+    REQUEST(xAppleWMSetWindowLevelReq);
+    WindowPtr pWin;
+    int errno;
+
+    REQUEST_SIZE_MATCH(xAppleWMSetWindowLevelReq);
+
+    if (!(pWin = SecurityLookupWindow((Drawable)stuff->window,
+                                      client, SecurityReadAccess)))
+    {
+        return BadValue;
+    }
+
+    if (stuff->level < 0 || stuff->level >= AppleWMNumWindowLevels) {
+        return BadValue;
+    }
+
+     errno = appleWMProcs->SetWindowLevel(pWin, stuff->level);
+     if (errno != Success) {
+        return errno;
+    }
+
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMSetCanQuit(
+    register ClientPtr client
+)
+{
+    REQUEST(xAppleWMSetCanQuitReq);
+
+    REQUEST_SIZE_MATCH(xAppleWMSetCanQuitReq);
+
+    QuartzMessageMainThread(kQuartzSetCanQuit, &stuff->state,
+                            sizeof(stuff->state));
+
+    return (client->noClientException);
+}
+
+
+/* frame functions */
+
+static int
+ProcAppleWMFrameGetRect(
+    register ClientPtr client
+)
+{
+    xAppleWMFrameGetRectReply rep;
+    BoxRec ir, or, rr;
+    REQUEST(xAppleWMFrameGetRectReq);
+
+    REQUEST_SIZE_MATCH(xAppleWMFrameGetRectReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    ir = make_box (stuff->ix, stuff->iy, stuff->iw, stuff->ih);
+    or = make_box (stuff->ox, stuff->oy, stuff->ow, stuff->oh);
+
+    if (appleWMProcs->FrameGetRect(stuff->frame_rect,
+                                   stuff->frame_class,
+                                   &or, &ir, &rr) != Success)
+    {
+        return BadValue;
+    }
+
+    rep.x = rr.x1;
+    rep.y = rr.y1;
+    rep.w = rr.x2 - rr.x1;
+    rep.h = rr.y2 - rr.y1;
+
+    WriteToClient(client, sizeof(xAppleWMFrameGetRectReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMFrameHitTest(
+    register ClientPtr client
+)
+{
+    xAppleWMFrameHitTestReply rep;
+    BoxRec ir, or;
+    int ret;
+    REQUEST(xAppleWMFrameHitTestReq);
+
+    REQUEST_SIZE_MATCH(xAppleWMFrameHitTestReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    ir = make_box (stuff->ix, stuff->iy, stuff->iw, stuff->ih);
+    or = make_box (stuff->ox, stuff->oy, stuff->ow, stuff->oh);
+
+    if (appleWMProcs->FrameHitTest(stuff->frame_class, stuff->px,
+                                   stuff->py, &or, &ir, &ret) != Success)
+    {
+        return BadValue;
+    }
+
+    rep.ret = ret;
+
+    WriteToClient(client, sizeof(xAppleWMFrameHitTestReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static int
+ProcAppleWMFrameDraw(
+    register ClientPtr client
+)
+{
+    BoxRec ir, or;
+    unsigned int title_length, title_max;
+    unsigned char *title_bytes;
+    REQUEST(xAppleWMFrameDrawReq);
+    WindowPtr pWin;
+
+    REQUEST_AT_LEAST_SIZE(xAppleWMFrameDrawReq);
+
+    if (!(pWin = SecurityLookupWindow((Drawable)stuff->window,
+                                      client, SecurityReadAccess)))
+    {
+        return BadValue;
+    }
+
+    ir = make_box (stuff->ix, stuff->iy, stuff->iw, stuff->ih);
+    or = make_box (stuff->ox, stuff->oy, stuff->ow, stuff->oh);
+
+    title_length = stuff->title_length;
+    title_max = (stuff->length << 2) - sizeof(xAppleWMFrameDrawReq);
+
+    if (title_max < title_length)
+        return BadValue;
+
+    title_bytes = (unsigned char *) &stuff[1];
+
+    errno = appleWMProcs->FrameDraw(pWin, stuff->frame_class,
+                                    stuff->frame_attr, &or, &ir,
+                                    title_length, title_bytes);
+    if (errno != Success) {
+        return errno;
+    }
+
+    return (client->noClientException);
+}
+
+
+/* dispatch */
+
+static int
+ProcAppleWMDispatch (
+    register ClientPtr	client
+)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+    case X_AppleWMQueryVersion:
+        return ProcAppleWMQueryVersion(client);
+    }
+
+    if (!LocalClient(client))
+        return WMErrorBase + AppleWMClientNotLocal;
+
+    switch (stuff->data)
+    {
+    case X_AppleWMSelectInput:
+        return ProcAppleWMSelectInput(client);
+    case X_AppleWMDisableUpdate:
+        return ProcAppleWMDisableUpdate(client);
+    case X_AppleWMReenableUpdate:
+        return ProcAppleWMReenableUpdate(client);
+    case X_AppleWMSetWindowMenu:
+        return ProcAppleWMSetWindowMenu(client);
+    case X_AppleWMSetWindowMenuCheck:
+        return ProcAppleWMSetWindowMenuCheck(client);
+    case X_AppleWMSetFrontProcess:
+        return ProcAppleWMSetFrontProcess(client);
+    case X_AppleWMSetWindowLevel:
+        return ProcAppleWMSetWindowLevel(client);
+    case X_AppleWMSetCanQuit:
+        return ProcAppleWMSetCanQuit(client);
+    case X_AppleWMFrameGetRect:
+        return ProcAppleWMFrameGetRect(client);
+    case X_AppleWMFrameHitTest:
+        return ProcAppleWMFrameHitTest(client);
+    case X_AppleWMFrameDraw:
+        return ProcAppleWMFrameDraw(client);
+    default:
+        return BadRequest;
+    }
+}
+
+static void
+SNotifyEvent(from, to)
+    xAppleWMNotifyEvent *from, *to;
+{
+    to->type = from->type;
+    to->kind = from->kind;
+    cpswaps (from->sequenceNumber, to->sequenceNumber);
+    cpswapl (from->time, to->time);
+    cpswapl (from->arg, to->arg);
+}
+
+static int
+SProcAppleWMQueryVersion(
+    register ClientPtr	client
+)
+{
+    register int n;
+    REQUEST(xAppleWMQueryVersionReq);
+    swaps(&stuff->length, n);
+    return ProcAppleWMQueryVersion(client);
+}
+
+static int
+SProcAppleWMDispatch (
+    register ClientPtr	client
+)
+{
+    REQUEST(xReq);
+
+    /* It is bound to be non-local when there is byte swapping */
+    if (!LocalClient(client))
+        return WMErrorBase + AppleWMClientNotLocal;
+
+    /* only local clients are allowed WM access */
+    switch (stuff->data)
+    {
+    case X_AppleWMQueryVersion:
+        return SProcAppleWMQueryVersion(client);
+    default:
+        return BadRequest;
+    }
+}
diff --git a/hw/darwin/quartz/applewmExt.h b/hw/darwin/quartz/applewmExt.h
new file mode 100644
index 000000000..650173941
--- /dev/null
+++ b/hw/darwin/quartz/applewmExt.h
@@ -0,0 +1,83 @@
+/*
+ * External interface for the server's AppleWM support
+ */
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
+Copyright (c) 2003 Torrey T. Lyons. 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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/applewmExt.h,v 1.3 2003/11/17 22:20:35 dawes Exp $ */
+
+#ifndef _APPLEWMEXT_H_
+#define _APPLEWMEXT_H_
+
+#include "window.h"
+
+typedef int (*DisableUpdateProc)(void);
+typedef int (*EnableUpdateProc)(void);
+typedef int (*SetWindowLevelProc)(WindowPtr pWin, int level);
+typedef int (*FrameGetRectProc)(int type, int class, const BoxRec *outer,
+                                const BoxRec *inner, BoxRec *ret);
+typedef int (*FrameHitTestProc)(int class, int x, int y,
+                                const BoxRec *outer,
+                                const BoxRec *inner, int *ret);
+typedef int (*FrameDrawProc)(WindowPtr pWin, int class, unsigned int attr,
+                             const BoxRec *outer, const BoxRec *inner,
+                             unsigned int title_len,
+                             const unsigned char *title_bytes);
+
+/*
+ * AppleWM implementation function list
+ */
+typedef struct _AppleWMProcs {
+    DisableUpdateProc DisableUpdate;
+    EnableUpdateProc EnableUpdate;
+    SetWindowLevelProc SetWindowLevel;
+    FrameGetRectProc FrameGetRect;
+    FrameHitTestProc FrameHitTest;
+    FrameDrawProc FrameDraw;
+} AppleWMProcsRec, *AppleWMProcsPtr;
+
+extern AppleWMProcsPtr appleWMProcs;
+
+void AppleWMExtensionInit(
+    AppleWMProcsPtr procsPtr
+);
+
+void AppleWMSetScreenOrigin(
+    WindowPtr pWin
+);
+
+void AppleWMSendEvent(
+    int			/* type */,
+    unsigned int	/* mask */,
+    int			/* which */,
+    int			/* arg */
+);
+
+unsigned int AppleWMSelectedEvents(
+    void
+);
+
+#endif /* _APPLEWMEXT_H_ */
diff --git a/hw/darwin/quartz/cr/XView.h b/hw/darwin/quartz/cr/XView.h
new file mode 100644
index 000000000..666061dc1
--- /dev/null
+++ b/hw/darwin/quartz/cr/XView.h
@@ -0,0 +1,42 @@
+/*
+ * NSView subclass for Mac OS X rootless X server
+ *
+ * Copyright (c) 2001 Greg Parker. 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/cr/XView.h,v 1.1 2003/06/07 05:49:07 torrey Exp $ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface XView : NSQuickDrawView
+
+- (BOOL)isFlipped;
+- (BOOL)isOpaque;
+- (BOOL)acceptsFirstResponder;
+- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent;
+- (BOOL)shouldDelayWindowOrderingForEvent:(NSEvent *)theEvent;
+
+- (void)mouseDown:(NSEvent *)anEvent;
+
+@end
diff --git a/hw/darwin/quartz/cr/XView.m b/hw/darwin/quartz/cr/XView.m
new file mode 100644
index 000000000..2bf689ede
--- /dev/null
+++ b/hw/darwin/quartz/cr/XView.m
@@ -0,0 +1,74 @@
+/*
+ * NSView subclass for Mac OS X rootless X server
+ *
+ * Each rootless window contains an instance of this class.
+ * This class handles events while drawing is handled by Carbon
+ * code in the rootless Aqua implementation.
+ *
+ * Copyright (c) 2001 Greg Parker. 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/cr/XView.m,v 1.2 2003/10/16 23:50:16 torrey Exp $ */
+
+#import "XView.h"
+
+
+@implementation XView
+
+- (BOOL)isFlipped
+{
+    return NO;
+}
+
+- (BOOL)isOpaque
+{
+    return YES;
+}
+
+- (BOOL)acceptsFirstResponder
+{
+    return YES;
+}
+
+- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
+{
+    return YES;
+}
+
+- (BOOL)shouldDelayWindowOrderingForEvent:(NSEvent *)theEvent
+{
+    return YES;
+}
+
+- (void)mouseDown:(NSEvent *)anEvent
+{
+    // Only X is allowed to restack windows.
+    [NSApp preventWindowOrdering];
+    if (! [NSApp isActive]) {
+        [NSApp activateIgnoringOtherApps:YES];
+    }
+    [[self nextResponder] mouseDown:anEvent];
+}
+
+@end
diff --git a/hw/darwin/quartz/cr/cr.h b/hw/darwin/quartz/cr/cr.h
new file mode 100644
index 000000000..74752f768
--- /dev/null
+++ b/hw/darwin/quartz/cr/cr.h
@@ -0,0 +1,62 @@
+/*
+ * Internal definitions of the Cocoa rootless implementation
+ */
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. 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/cr/cr.h,v 1.3 2003/11/03 05:36:31 tsi Exp $ */
+
+#ifndef _CR_H
+#define _CR_H
+
+#ifdef __OBJC__
+#import <Cocoa/Cocoa.h>
+#import "XView.h"
+#else
+typedef struct OpaqueNSWindow NSWindow;
+typedef struct OpaqueXView XView;
+#endif
+
+#undef BOOL
+#define BOOL xBOOL
+#include "screenint.h"
+#include "window.h"
+#undef BOOL
+
+// Predefined style for the window which is about to be framed
+extern WindowPtr nextWindowToFrame;
+extern unsigned int nextWindowStyle;
+
+typedef struct {
+    NSWindow *window;
+    XView *view;
+    GrafPtr port;
+    CGContextRef context;
+} CRWindowRec, *CRWindowPtr;
+
+Bool CRInit(ScreenPtr pScreen);
+void CRAppleWMInit(void);
+
+#endif /* _CR_H */
diff --git a/hw/darwin/quartz/cr/crAppleWM.m b/hw/darwin/quartz/cr/crAppleWM.m
new file mode 100644
index 000000000..66e832b66
--- /dev/null
+++ b/hw/darwin/quartz/cr/crAppleWM.m
@@ -0,0 +1,157 @@
+/*
+ * Cocoa rootless implementation functions for AppleWM extension
+ */
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. 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/cr/crAppleWM.m,v 1.1 2003/09/16 00:36:14 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "cr.h"
+
+#undef BOOL
+#define BOOL xBOOL
+#include "rootless.h"
+#include "X.h"
+#define _APPLEWM_SERVER_
+#include "applewm.h"
+#include "applewmExt.h"
+#undef BOOL
+
+#define StdDocumentStyleMask (NSTitledWindowMask | \
+                              NSClosableWindowMask | \
+                              NSMiniaturizableWindowMask | \
+                              NSResizableWindowMask)
+
+static int
+CRDisableUpdate(void)
+{
+    return Success;
+}
+
+
+static int
+CREnableUpdate(void)
+{
+    return Success;
+}
+
+
+static int CRSetWindowLevel(
+    WindowPtr pWin,
+    int level)
+{
+    CRWindowPtr crWinPtr;
+
+    crWinPtr = (CRWindowPtr) RootlessFrameForWindow(pWin, TRUE);
+    if (crWinPtr == 0)
+        return BadWindow;
+
+    RootlessStopDrawing(pWin, FALSE);
+
+    [crWinPtr->window setLevel:level];
+
+    return Success;
+}
+
+
+static int CRFrameGetRect(
+    int type,
+    int class,
+    const BoxRec *outer,
+    const BoxRec *inner,
+    BoxRec *ret)
+{
+    return Success;
+}
+
+
+static int CRFrameHitTest(
+    int class,
+    int x,
+    int y,
+    const BoxRec *outer,
+    const BoxRec *inner,
+    int *ret)
+{
+    return 0;
+}
+
+
+static int CRFrameDraw(
+    WindowPtr pWin,
+    int class,
+    unsigned int attr,
+    const BoxRec *outer,
+    const BoxRec *inner,
+    unsigned int title_len,
+    const unsigned char *title_bytes)
+{
+    CRWindowPtr crWinPtr;
+    NSWindow *window;
+    Bool hasResizeIndicator;
+
+    /* We assume the window has not yet been framed so
+       RootlessFrameForWindow() will cause it to be. Record the window
+       style so that the appropriate one will be used when it is framed.
+       If the window is already framed, we can't change the window
+       style and the following will have no effect. */
+
+    nextWindowToFrame = pWin;
+    if (class == AppleWMFrameClassDocument)
+        nextWindowStyle = StdDocumentStyleMask;
+    else
+        nextWindowStyle = NSBorderlessWindowMask;
+
+    crWinPtr = (CRWindowPtr) RootlessFrameForWindow(pWin, TRUE);
+    if (crWinPtr == 0)
+        return BadWindow;
+
+    window = crWinPtr->window;
+
+    [window setTitle:[NSString stringWithCString:title_bytes
+                               length:title_len]];
+
+    hasResizeIndicator = (attr & AppleWMFrameGrowBox) ? YES : NO;
+    [window setShowsResizeIndicator:hasResizeIndicator];
+
+    return Success;
+}
+
+
+static AppleWMProcsRec crAppleWMProcs = {
+    CRDisableUpdate,
+    CREnableUpdate,
+    CRSetWindowLevel,
+    CRFrameGetRect,
+    CRFrameHitTest,
+    CRFrameDraw
+};
+
+
+void CRAppleWMInit(void)
+{
+    AppleWMExtensionInit(&crAppleWMProcs);
+}
diff --git a/hw/darwin/quartz/cr/crFrame.m b/hw/darwin/quartz/cr/crFrame.m
new file mode 100644
index 000000000..e3e83ebc4
--- /dev/null
+++ b/hw/darwin/quartz/cr/crFrame.m
@@ -0,0 +1,403 @@
+/*
+ * Cocoa rootless implementation frame functions
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. 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/cr/crFrame.m,v 1.5 2003/11/13 20:26:31 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "cr.h"
+
+#undef BOOL
+#define BOOL xBOOL
+#include "rootless.h"
+#undef BOOL
+
+WindowPtr nextWindowToFrame = NULL;
+unsigned int nextWindowStyle = 0;
+
+static void CRReshapeFrame(RootlessFrameID wid, RegionPtr pShape);
+
+
+/*
+ * CRCreateFrame
+ *  Create a new physical window.
+ *  Rootless windows must not autodisplay! Autodisplay can cause a deadlock.
+ *    Event thread - autodisplay: locks view hierarchy, then window
+ *    X Server thread - window resize: locks window, then view hierarchy
+ *  Deadlock occurs if each thread gets one lock and waits for the other.
+ */
+static Bool
+CRCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,
+              int newX, int newY, RegionPtr pShape)
+{
+    CRWindowPtr crWinPtr;
+    NSRect bounds;
+    NSWindow *theWindow;
+    XView *theView;
+    unsigned int theStyleMask = NSBorderlessWindowMask;
+
+    crWinPtr = (CRWindowPtr) xalloc(sizeof(CRWindowRec));
+
+    bounds = NSMakeRect(newX,
+                        NSHeight([[NSScreen mainScreen] frame]) -
+                        newY - pFrame->height,
+                        pFrame->width, pFrame->height);
+
+    // Check if AppleWM has specified a style for this window
+    if (pFrame->win == nextWindowToFrame) {
+        theStyleMask = nextWindowStyle;
+    }
+    nextWindowToFrame = NULL;
+
+    // Create an NSWindow for the new X11 window
+    theWindow = [[NSWindow alloc] initWithContentRect:bounds
+                                  styleMask:theStyleMask
+                                  backing:NSBackingStoreBuffered
+                                  defer:NO];
+    if (!theWindow) return FALSE;
+
+    [theWindow setBackgroundColor:[NSColor clearColor]];  // erase transparent
+    [theWindow setAlphaValue:1.0];       // draw opaque
+    [theWindow setOpaque:YES];           // changed when window is shaped
+
+    [theWindow useOptimizedDrawing:YES]; // Has no overlapping sub-views
+    [theWindow setAutodisplay:NO];       // See comment above
+    [theWindow disableFlushWindow];      // We do all the flushing manually
+    [theWindow setHasShadow:YES];        // All windows have shadows
+    [theWindow setReleasedWhenClosed:YES]; // Default, but we want to be sure
+
+    theView = [[XView alloc] initWithFrame:bounds];
+    [theWindow setContentView:theView];
+    [theWindow setInitialFirstResponder:theView];
+
+    [theWindow setAcceptsMouseMovedEvents:YES];
+
+    crWinPtr->window = theWindow;
+    crWinPtr->view = theView;
+
+    [theView lockFocus];
+    // Fill the window with white to make sure alpha channel is set
+    NSEraseRect(bounds);
+    crWinPtr->port = [theView qdPort];
+    crWinPtr->context = [[NSGraphicsContext currentContext] graphicsPort];
+    // CreateCGContextForPort(crWinPtr->port, &crWinPtr->context);
+    [theView unlockFocus];
+
+    // Store the implementation private frame ID
+    pFrame->wid = (RootlessFrameID) crWinPtr;
+
+    // Reshape the frame if it was created shaped.
+    if (pShape != NULL)
+        CRReshapeFrame(pFrame->wid, pShape);
+
+    return TRUE;
+}
+
+
+/*
+ * CRDestroyFrame
+ *  Destroy a frame.
+ */
+static void
+CRDestroyFrame(RootlessFrameID wid)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+
+    [crWinPtr->window orderOut:nil];
+    [crWinPtr->window close];
+    [crWinPtr->view release];
+    free(crWinPtr);
+}
+
+
+/*
+ * CRMoveFrame
+ *  Move a frame on screen.
+ */
+static void
+CRMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    NSPoint topLeft;
+
+    topLeft = NSMakePoint(newX,
+                          NSHeight([[NSScreen mainScreen] frame]) - newY);
+
+    [crWinPtr->window setFrameTopLeftPoint:topLeft];
+}
+
+
+/*
+ * CRResizeFrame
+ *  Move and resize a frame.
+ */
+static void
+CRResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,
+              int newX, int newY, unsigned int newW, unsigned int newH,
+              unsigned int gravity)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    NSRect bounds = NSMakeRect(newX, NSHeight([[NSScreen mainScreen] frame]) -
+                              newY - newH, newW, newH);
+
+    [crWinPtr->window setFrame:bounds display:NO];
+}
+
+
+/*
+ * CRRestackFrame
+ *  Change the frame order. Put the frame behind nextWid or on top if
+ *  it is NULL. Unmapped frames are mapped by restacking them.
+ */
+static void
+CRRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    CRWindowPtr crNextWinPtr = (CRWindowPtr) nextWid;
+
+    if (crNextWinPtr) {
+        int upperNum = [crNextWinPtr->window windowNumber];
+
+        [crWinPtr->window orderWindow:NSWindowBelow relativeTo:upperNum];
+    } else {
+        [crWinPtr->window makeKeyAndOrderFront:nil];
+    }
+}
+
+
+/*
+ * CRReshapeFrame
+ *  Set the shape of a frame.
+ */
+static void
+CRReshapeFrame(RootlessFrameID wid, RegionPtr pShape)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    NSRect bounds = [crWinPtr->view frame];
+    int winHeight = NSHeight(bounds);
+    BoxRec localBox = {0, 0, NSWidth(bounds), winHeight};
+
+    [crWinPtr->view lockFocus];
+
+    if (pShape != NULL) {
+        // Calculate the region outside the new shape.
+        REGION_INVERSE(NULL, pShape, pShape, &localBox);
+    }
+
+    // If window is currently shaped we need to undo the previous shape.
+    if (![crWinPtr->window isOpaque]) {
+        [[NSColor whiteColor] set];
+        NSRectFillUsingOperation(bounds, NSCompositeDestinationAtop);
+    }
+
+    if (pShape != NULL) {
+        int count = REGION_NUM_RECTS(pShape);
+        BoxRec *extRects = REGION_RECTS(pShape);
+        BoxRec *rects, *end;
+
+        // Make transparent if window is now shaped.
+        [crWinPtr->window setOpaque:NO];
+
+        // Clear the areas outside the window shape
+        [[NSColor clearColor] set];
+        for (rects = extRects, end = extRects+count; rects < end; rects++) {
+            int rectHeight = rects->y2 - rects->y1;
+            NSRectFill( NSMakeRect(rects->x1,
+                                   winHeight - rects->y1 - rectHeight,
+                                   rects->x2 - rects->x1, rectHeight) );
+        }
+        [[NSGraphicsContext currentContext] flushGraphics];
+
+        // force update of window shadow
+        [crWinPtr->window setHasShadow:NO];
+        [crWinPtr->window setHasShadow:YES];
+
+    } else {
+        [crWinPtr->window setOpaque:YES];
+        [[NSGraphicsContext currentContext] flushGraphics];
+    }
+
+    [crWinPtr->view unlockFocus];
+}
+
+
+/*
+ * CRUnmapFrame
+ *  Unmap a frame.
+ */
+static void
+CRUnmapFrame(RootlessFrameID wid)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+
+    [crWinPtr->window orderOut:nil];
+}
+
+
+/*
+ * CRStartDrawing
+ *  When a window's buffer is not being drawn to, the CoreGraphics
+ *  window server may compress or move it. Call this routine
+ *  to lock down the buffer during direct drawing. It returns
+ *  a pointer to the backing buffer.
+ */
+static void
+CRStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    PixMapHandle pix;
+
+    [crWinPtr->view lockFocus];
+    crWinPtr->port = [crWinPtr->view qdPort];
+    LockPortBits(crWinPtr->port);
+    [crWinPtr->view unlockFocus];
+    pix = GetPortPixMap(crWinPtr->port);
+
+    *pixelData = GetPixBaseAddr(pix);
+    *bytesPerRow = GetPixRowBytes(pix) & 0x3fff; // fixme is mask needed?
+}
+
+
+/*
+ * CRStopDrawing
+ *  When direct access to a window's buffer is no longer needed, this
+ *  routine should be called to allow CoreGraphics to compress or
+ *  move it.
+ */
+static void
+CRStopDrawing(RootlessFrameID wid, Bool flush)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+
+    UnlockPortBits(crWinPtr->port);
+
+    if (flush) {
+        QDFlushPortBuffer(crWinPtr->port, NULL);
+    }
+}
+
+
+/*
+ * CRUpdateRegion
+ *  Flush a region from a window's backing buffer to the screen.
+ */
+static void
+CRUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+
+#ifdef ROOTLESS_TRACK_DAMAGE
+    int count = REGION_NUM_RECTS(pDamage);
+    BoxRec *rects = REGION_RECTS(pDamage);
+    BoxRec *end;
+
+    static RgnHandle rgn = NULL;
+    static RgnHandle box = NULL;
+
+    if (!rgn) rgn = NewRgn();
+    if (!box) box = NewRgn();
+
+    for (end = rects+count; rects < end; rects++) {
+        Rect qdRect;
+        qdRect.left = rects->x1;
+        qdRect.top = rects->y1;
+        qdRect.right = rects->x2;
+        qdRect.bottom = rects->y2;
+
+        RectRgn(box, &qdRect);
+        UnionRgn(rgn, box, rgn);
+    }
+
+    QDFlushPortBuffer(crWinPtr->port, rgn);
+
+    SetEmptyRgn(rgn);
+    SetEmptyRgn(box);
+
+#else	/* !ROOTLESS_TRACK_DAMAGE */
+    QDFlushPortBuffer(crWinPtr->port, NULL);
+#endif
+}
+
+
+/*
+ * CRDamageRects
+ *  Mark damaged rectangles as requiring redisplay to screen.
+ */
+static void
+CRDamageRects(RootlessFrameID wid, int count, const BoxRec *rects,
+               int shift_x, int shift_y)
+{
+    CRWindowPtr crWinPtr = (CRWindowPtr) wid;
+    const BoxRec *end;
+
+    for (end = rects + count; rects < end; rects++) {
+        Rect qdRect;
+        qdRect.left = rects->x1 + shift_x;
+        qdRect.top = rects->y1 + shift_y;
+        qdRect.right = rects->x2 + shift_x;
+        qdRect.bottom = rects->y2 + shift_y;
+
+        QDAddRectToDirtyRegion(crWinPtr->port, &qdRect);
+    }
+}
+
+
+static RootlessFrameProcsRec CRRootlessProcs = {
+    CRCreateFrame,
+    CRDestroyFrame,
+    CRMoveFrame,
+    CRResizeFrame,
+    CRRestackFrame,
+    CRReshapeFrame,
+    CRUnmapFrame,
+    CRStartDrawing,
+    CRStopDrawing,
+    CRUpdateRegion,
+    CRDamageRects,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+
+/*
+ * Initialize CR implementation
+ */
+Bool
+CRInit(ScreenPtr pScreen)
+{
+    RootlessInit(pScreen, &CRRootlessProcs);
+
+    rootless_CopyBytes_threshold = 0;
+    rootless_FillBytes_threshold = 0;
+    rootless_CompositePixels_threshold = 0;
+    rootless_CopyWindow_threshold = 0;
+
+    return TRUE;
+}
diff --git a/hw/darwin/quartz/cr/crScreen.m b/hw/darwin/quartz/cr/crScreen.m
new file mode 100644
index 000000000..d259d0bac
--- /dev/null
+++ b/hw/darwin/quartz/cr/crScreen.m
@@ -0,0 +1,321 @@
+/*
+ * Cocoa rootless implementation initialization
+ */
+/*
+ * Copyright (c) 2001 Greg Parker. All Rights Reserved.
+ * Copyright (c) 2002-2003 Torrey T. Lyons. 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/cr/crScreen.m,v 1.5 2003/11/12 20:21:52 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "cr.h"
+
+#undef BOOL
+#define BOOL xBOOL
+#include "darwin.h"
+#include "quartz.h"
+#include "quartzCursor.h"
+#include "rootless.h"
+#include "safeAlpha.h"
+#include "pseudoramiX.h"
+#include "applewmExt.h"
+
+#include "regionstr.h"
+#include "scrnintstr.h"
+#include "picturestr.h"
+#include "globals.h"
+#undef BOOL
+
+// Name of GLX bundle using AGL framework
+static const char *crOpenGLBundle = "glxAGL.bundle";
+
+static Class classXView = nil;
+
+
+/*
+ * CRDisplayInit
+ *  Find all screens.
+ *
+ *  Multihead note: When rootless mode uses PseudoramiX, the
+ *  X server only sees one screen; only PseudoramiX itself knows
+ *  about all of the screens.
+ */
+static void
+CRDisplayInit(void)
+{
+    ErrorF("Display mode: Rootless Quartz -- Cocoa implementation\n");
+
+    if (noPseudoramiXExtension) {
+        darwinScreensFound = [[NSScreen screens] count];
+    } else {
+        darwinScreensFound = 1; // only PseudoramiX knows about the rest
+    }
+
+    CRAppleWMInit();
+}
+
+
+/*
+ * CRScreenParams
+ *  Set the basic screen parameters.
+ */
+static void
+CRScreenParams(int index, DarwinFramebufferPtr dfb)
+{
+    dfb->bitsPerComponent = CGDisplayBitsPerSample(kCGDirectMainDisplay);
+    dfb->bitsPerPixel = CGDisplayBitsPerPixel(kCGDirectMainDisplay);
+    dfb->colorBitsPerPixel = 3 * dfb->bitsPerComponent;
+
+    if (noPseudoramiXExtension) {
+        NSScreen *screen = [[NSScreen screens] objectAtIndex:index];
+        NSRect frame = [screen frame];
+
+        // set x, y so (0,0) is top left of main screen
+        dfb->x = NSMinX(frame);
+        dfb->y = NSHeight([[NSScreen mainScreen] frame]) -
+                 NSHeight(frame) - NSMinY(frame);
+
+        dfb->width =  NSWidth(frame);
+        dfb->height = NSHeight(frame);
+        dfb->pitch = (dfb->width) * (dfb->bitsPerPixel) / 8;
+
+        // Shift the usable part of main screen down to avoid the menu bar.
+        if (NSEqualRects(frame, [[NSScreen mainScreen] frame])) {
+            dfb->y      += aquaMenuBarHeight;
+            dfb->height -= aquaMenuBarHeight;
+        }
+
+    } else {
+        int i;
+        NSRect unionRect = NSMakeRect(0, 0, 0, 0);
+        NSArray *screens = [NSScreen screens];
+
+        // Get the union of all screens (minus the menu bar on main screen)
+        for (i = 0; i < [screens count]; i++) {
+            NSScreen *screen = [screens objectAtIndex:i];
+            NSRect frame = [screen frame];
+            frame.origin.y = [[NSScreen mainScreen] frame].size.height -
+                             frame.size.height - frame.origin.y;
+            if (NSEqualRects([screen frame], [[NSScreen mainScreen] frame])) {
+                frame.origin.y    += aquaMenuBarHeight;
+                frame.size.height -= aquaMenuBarHeight;
+            }
+            unionRect = NSUnionRect(unionRect, frame);
+        }
+
+        // Use unionRect as the screen size for the X server.
+        dfb->x = unionRect.origin.x;
+        dfb->y = unionRect.origin.y;
+        dfb->width = unionRect.size.width;
+        dfb->height = unionRect.size.height;
+        dfb->pitch = (dfb->width) * (dfb->bitsPerPixel) / 8;
+
+        // Tell PseudoramiX about the real screens.
+        // InitOutput() will move the big screen to (0,0),
+        // so compensate for that here.
+        for (i = 0; i < [screens count]; i++) {
+            NSScreen *screen = [screens objectAtIndex:i];
+            NSRect frame = [screen frame];
+            int j;
+
+            // Skip this screen if it's a mirrored copy of an earlier screen.
+            for (j = 0; j < i; j++) {
+                if (NSEqualRects(frame, [[screens objectAtIndex:j] frame])) {
+                    ErrorF("PseudoramiX screen %d is a mirror of screen %d.\n",
+                           i, j);
+                    break;
+                }
+            }
+            if (j < i) continue; // this screen is a mirrored copy
+
+            frame.origin.y = [[NSScreen mainScreen] frame].size.height -
+                             frame.size.height - frame.origin.y;
+
+            if (NSEqualRects([screen frame], [[NSScreen mainScreen] frame])) {
+                frame.origin.y    += aquaMenuBarHeight;
+                frame.size.height -= aquaMenuBarHeight;
+            }
+
+            ErrorF("PseudoramiX screen %d added: %dx%d @ (%d,%d).\n", i,
+                   (int)frame.size.width, (int)frame.size.height,
+                   (int)frame.origin.x, (int)frame.origin.y);
+
+            frame.origin.x -= unionRect.origin.x;
+            frame.origin.y -= unionRect.origin.y;
+
+            ErrorF("PseudoramiX screen %d placed at X11 coordinate (%d,%d).\n",
+                   i, (int)frame.origin.x, (int)frame.origin.y);
+
+            PseudoramiXAddScreen(frame.origin.x, frame.origin.y,
+                                 frame.size.width, frame.size.height);
+        }
+    }
+}
+
+
+/*
+ * CRAddScreen
+ *  Init the framebuffer and record pixmap parameters for the screen.
+ */
+static Bool
+CRAddScreen(int index, ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    QuartzScreenPtr displayInfo = QUARTZ_PRIV(pScreen);
+    CGRect cgRect;
+    CGDisplayCount numDisplays;
+    CGDisplayCount allocatedDisplays = 0;
+    CGDirectDisplayID *displays = NULL;
+    CGDisplayErr cgErr;
+
+    CRScreenParams(index, dfb);
+
+    dfb->colorType = TrueColor;
+
+    // No frame buffer - it's all in window pixmaps.
+    dfb->framebuffer = NULL; // malloc(dfb.pitch * dfb.height);
+
+    // Get all CoreGraphics displays covered by this X11 display.
+    cgRect = CGRectMake(dfb->x, dfb->y, dfb->width, dfb->height);
+    do {
+        cgErr = CGGetDisplaysWithRect(cgRect, 0, NULL, &numDisplays);
+        if (cgErr) break;
+        allocatedDisplays = numDisplays;
+        displays = xrealloc(displays,
+                            numDisplays * sizeof(CGDirectDisplayID));
+        cgErr = CGGetDisplaysWithRect(cgRect, allocatedDisplays, displays,
+                                      &numDisplays);
+        if (cgErr != CGDisplayNoErr) break;
+    } while (numDisplays > allocatedDisplays);
+
+    if (cgErr != CGDisplayNoErr || numDisplays == 0) {
+        ErrorF("Could not find CGDirectDisplayID(s) for X11 screen %d: %dx%d @ %d,%d.\n",
+               index, dfb->width, dfb->height, dfb->x, dfb->y);
+        return FALSE;
+    }
+
+    // This X11 screen covers all CoreGraphics displays we just found.
+    // If there's more than one CG display, then video mirroring is on
+    // or PseudoramiX is on.
+    displayInfo->displayCount = allocatedDisplays;
+    displayInfo->displayIDs = displays;
+
+    return TRUE;
+}
+
+
+/*
+ * CRSetupScreen
+ *  Setup the screen for rootless access.
+ */
+static Bool
+CRSetupScreen(int index, ScreenPtr pScreen)
+{
+    // Add alpha protecting replacements for fb screen functions
+    pScreen->PaintWindowBackground = SafeAlphaPaintWindow;
+    pScreen->PaintWindowBorder = SafeAlphaPaintWindow;
+
+#ifdef RENDER
+    {
+        PictureScreenPtr ps = GetPictureScreen(pScreen);
+        ps->Composite = SafeAlphaComposite;
+    }
+#endif /* RENDER */
+
+    // Initialize generic rootless code
+    return CRInit(pScreen);
+}
+
+
+/*
+ * CRInitInput
+ *  Finalize CR specific setup.
+ */
+static void
+CRInitInput(int argc, char **argv)
+{
+    int i;
+
+    rootlessGlobalOffsetX = darwinMainScreenX;
+    rootlessGlobalOffsetY = darwinMainScreenY;
+
+    for (i = 0; i < screenInfo.numScreens; i++)
+        AppleWMSetScreenOrigin(WindowTable[i]);
+}
+
+
+/*
+ * CRIsX11Window
+ *  Returns TRUE if cr is displaying this window.
+ */
+static Bool
+CRIsX11Window(void *nsWindow, int windowNumber)
+{
+    NSWindow *theWindow = nsWindow;
+
+    if (!theWindow)
+        return FALSE;
+
+    if ([[theWindow contentView] isKindOfClass:classXView])
+        return TRUE;
+    else
+        return FALSE;
+}
+
+
+/*
+ * Quartz display mode function list.
+ */
+static QuartzModeProcsRec crModeProcs = {
+    CRDisplayInit,
+    CRAddScreen,
+    CRSetupScreen,
+    CRInitInput,
+    QuartzInitCursor,
+    QuartzReallySetCursor,
+    QuartzSuspendXCursor,
+    QuartzResumeXCursor,
+    NULL,               // No capture or release in rootless mode
+    NULL,
+    CRIsX11Window,
+    RootlessFrameForWindow,
+    TopLevelParent,
+    NULL,		// No support for DRI surfaces
+    NULL
+};
+
+
+/*
+ * QuartzModeBundleInit
+ *  Initialize the display mode bundle after loading.
+ */
+Bool
+QuartzModeBundleInit(void)
+{
+    quartzProcs = &crModeProcs;
+    quartzOpenGLBundle = crOpenGLBundle;
+    classXView = [XView class];
+    return TRUE;
+}
diff --git a/hw/darwin/quartz/fullscreen/fullscreen.c b/hw/darwin/quartz/fullscreen/fullscreen.c
new file mode 100644
index 000000000..fc390e87f
--- /dev/null
+++ b/hw/darwin/quartz/fullscreen/fullscreen.c
@@ -0,0 +1,567 @@
+/*
+ * Screen routines for full screen Quartz mode
+ *
+ * Copyright (c) 2002-2003 Torrey T. Lyons. 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
+ * TORREY T. LYONS 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/fullscreen/fullscreen.c,v 1.2 2003/11/12 20:21:52 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "darwin.h"
+#include "quartz.h"
+#include "quartzCursor.h"
+#include "colormapst.h"
+#include "scrnintstr.h"
+#include "micmap.h"
+#include "shadow.h"
+
+// Full screen specific per screen storage structure
+typedef struct {
+    CGDirectDisplayID   displayID;
+    CFDictionaryRef     xDisplayMode;
+    CFDictionaryRef     aquaDisplayMode;
+    CGDirectPaletteRef  xPalette;
+    CGDirectPaletteRef  aquaPalette;
+    unsigned char      *framebuffer;
+    unsigned char      *shadowPtr;
+} FSScreenRec, *FSScreenPtr;
+
+#define FULLSCREEN_PRIV(pScreen) \
+    ((FSScreenPtr)pScreen->devPrivates[fsScreenIndex].ptr)
+
+static int                  fsScreenIndex;
+static CGDirectDisplayID   *quartzDisplayList = NULL;
+static int                  quartzNumScreens = 0;
+static FSScreenPtr          quartzScreens[MAXSCREENS];
+
+static int                  darwinCmapPrivateIndex = -1;
+static unsigned long        darwinCmapGeneration = 0;
+
+#define CMAP_PRIV(pCmap) \
+    ((CGDirectPaletteRef) (pCmap)->devPrivates[darwinCmapPrivateIndex].ptr)
+
+/*
+ =============================================================================
+
+ Colormap handling
+
+ =============================================================================
+*/
+
+/*
+ * FSInitCmapPrivates
+ *  Colormap privates may be allocated after the default colormap has
+ *  already been created for some screens.  This initialization procedure
+ *  is called for each default colormap that is found.
+ */
+static Bool
+FSInitCmapPrivates(
+    ColormapPtr         pCmap)
+{
+    return TRUE;
+}
+
+
+/*
+ * FSCreateColormap
+ *  This is a callback from X after a new colormap is created.
+ *  We allocate a new CoreGraphics pallete for each colormap.
+ */
+static Bool
+FSCreateColormap(
+    ColormapPtr         pCmap)
+{
+    CGDirectPaletteRef  pallete;
+
+    // Allocate private storage for the hardware dependent colormap info.
+    if (darwinCmapGeneration != serverGeneration) {
+        if ((darwinCmapPrivateIndex =
+                AllocateColormapPrivateIndex(FSInitCmapPrivates)) < 0)
+        {
+            return FALSE;
+        }
+        darwinCmapGeneration = serverGeneration;
+    }
+
+    pallete = CGPaletteCreateDefaultColorPalette();
+    if (!pallete) return FALSE;
+
+    CMAP_PRIV(pCmap) = pallete;
+    return TRUE;
+}
+
+
+/*
+ * FSDestroyColormap
+ *  This is called by DIX FreeColormap after it has uninstalled a colormap
+ *  and notified all interested parties. We deallocated the corresponding
+ *  CoreGraphics pallete.
+ */
+static void
+FSDestroyColormap(
+    ColormapPtr         pCmap)
+{
+    CGPaletteRelease( CMAP_PRIV(pCmap) );
+}
+
+
+/*
+ * FSInstallColormap
+ *  Set the current CoreGraphics pallete to the pallete corresponding
+ *  to the provided colormap.
+ */
+static void
+FSInstallColormap(
+    ColormapPtr         pCmap)
+{
+    CGDirectPaletteRef  palette = CMAP_PRIV(pCmap);
+    ScreenPtr           pScreen = pCmap->pScreen;
+    FSScreenPtr         fsDisplayInfo = FULLSCREEN_PRIV(pScreen);
+
+    // Inform all interested parties that the map is being changed.
+    miInstallColormap(pCmap);
+
+    if (quartzServerVisible)
+        CGDisplaySetPalette(fsDisplayInfo->displayID, palette);
+
+    fsDisplayInfo->xPalette = palette;
+}
+
+
+/*
+ * FSStoreColors
+ *  This is a callback from X to change the hardware colormap
+ *  when using PsuedoColor in full screen mode.
+ */
+static void
+FSStoreColors(
+    ColormapPtr         pCmap,
+    int                 numEntries,
+    xColorItem          *pdefs)
+{
+    CGDirectPaletteRef  palette = CMAP_PRIV(pCmap);
+    ScreenPtr           pScreen = pCmap->pScreen;
+    FSScreenPtr         fsDisplayInfo = FULLSCREEN_PRIV(pScreen);
+    CGDeviceColor       color;
+    int                 i;
+
+    if (! palette)
+        return;
+
+    for (i = 0; i < numEntries; i++) {
+        color.red   = pdefs[i].red   / 65535.0;
+        color.green = pdefs[i].green / 65535.0;
+        color.blue  = pdefs[i].blue  / 65535.0;
+        CGPaletteSetColorAtIndex(palette, color, pdefs[i].pixel);
+    }
+
+    // Update hardware colormap
+    if (quartzServerVisible)
+        CGDisplaySetPalette(fsDisplayInfo->displayID, palette);
+}
+
+
+/*
+ =============================================================================
+
+ Switching between Aqua and X
+
+ =============================================================================
+*/
+
+/*
+ * FSCapture
+ *  Capture the screen so we can draw. Called directly from the main thread
+ *  to synchronize with hiding the menubar.
+ */
+static void FSCapture(void)
+{
+    int i;
+
+    if (quartzRootless) return;
+
+    for (i = 0; i < quartzNumScreens; i++) {
+        FSScreenPtr fsDisplayInfo = quartzScreens[i];
+        CGDirectDisplayID cgID = fsDisplayInfo->displayID;
+
+        if (!CGDisplayIsCaptured(cgID)) {
+            CGDisplayCapture(cgID);
+            fsDisplayInfo->aquaDisplayMode = CGDisplayCurrentMode(cgID);
+            if (fsDisplayInfo->xDisplayMode != fsDisplayInfo->aquaDisplayMode)
+                CGDisplaySwitchToMode(cgID, fsDisplayInfo->xDisplayMode);
+            if (fsDisplayInfo->xPalette)
+                CGDisplaySetPalette(cgID, fsDisplayInfo->xPalette);
+        }
+    }
+}
+
+
+/*
+ * FSRelease
+ *  Release the screen so others can draw.
+ */
+static void FSRelease(void)
+{
+    int i;
+
+    if (quartzRootless) return;
+
+    for (i = 0; i < quartzNumScreens; i++) {
+        FSScreenPtr fsDisplayInfo = quartzScreens[i];
+        CGDirectDisplayID cgID = fsDisplayInfo->displayID;
+
+        if (CGDisplayIsCaptured(cgID)) {
+            if (fsDisplayInfo->xDisplayMode != fsDisplayInfo->aquaDisplayMode)
+                CGDisplaySwitchToMode(cgID, fsDisplayInfo->aquaDisplayMode);
+            if (fsDisplayInfo->aquaPalette)
+                CGDisplaySetPalette(cgID, fsDisplayInfo->aquaPalette);
+            CGDisplayRelease(cgID);
+        }
+    }
+}
+
+
+/*
+ * FSSuspendScreen
+ *  Suspend X11 cursor and drawing to the screen.
+ */
+static void FSSuspendScreen(
+    ScreenPtr pScreen)
+{
+    QuartzSuspendXCursor(pScreen);
+    xf86SetRootClip(pScreen, FALSE);
+}
+
+
+/*
+ * FSResumeScreen
+ *  Resume X11 cursor and drawing to the screen.
+ */
+static void FSResumeScreen(
+    ScreenPtr pScreen,
+    int x,			// cursor location
+    int y )
+{
+    QuartzResumeXCursor(pScreen, x, y);
+    xf86SetRootClip(pScreen, TRUE);
+}
+
+
+/*
+ =============================================================================
+
+ Screen initialization
+
+ =============================================================================
+*/
+
+/*
+ * FSDisplayInit
+ *  Full screen specific initialization called from InitOutput.
+ */
+static void FSDisplayInit(void)
+{
+    static unsigned long generation = 0;
+    CGDisplayCount quartzDisplayCount = 0;
+
+    ErrorF("Display mode: Full screen Quartz -- Direct Display\n");
+
+    // Allocate private storage for each screen's mode specific info
+    if (generation != serverGeneration) {
+        fsScreenIndex = AllocateScreenPrivateIndex();
+        generation = serverGeneration;
+    }
+
+    // Find all the CoreGraphics displays
+    CGGetActiveDisplayList(0, NULL, &quartzDisplayCount);
+    quartzDisplayList = xalloc(quartzDisplayCount * sizeof(CGDirectDisplayID));
+    CGGetActiveDisplayList(quartzDisplayCount, quartzDisplayList,
+                           &quartzDisplayCount);
+
+    darwinScreensFound = quartzDisplayCount;
+    atexit(FSRelease);
+}
+
+
+/*
+ * FSFindDisplayMode
+ *  Find the appropriate display mode to use in full screen mode.
+ *  If display mode is not the same as the current Aqua mode, switch
+ *  to the new mode.
+ */
+static Bool FSFindDisplayMode(
+    FSScreenPtr fsDisplayInfo)
+{
+    CGDirectDisplayID cgID = fsDisplayInfo->displayID;
+    size_t height, width, bpp;
+    boolean_t exactMatch;
+
+    fsDisplayInfo->aquaDisplayMode = CGDisplayCurrentMode(cgID);
+
+    // If no user options, use current display mode
+    if (darwinDesiredWidth == 0 && darwinDesiredDepth == -1 &&
+        darwinDesiredRefresh == -1)
+    {
+        fsDisplayInfo->xDisplayMode = fsDisplayInfo->aquaDisplayMode;
+        return TRUE;
+    }
+
+    // If the user has no choice for size, use current
+    if (darwinDesiredWidth == 0) {
+        width = CGDisplayPixelsWide(cgID);
+        height = CGDisplayPixelsHigh(cgID);
+    } else {
+        width = darwinDesiredWidth;
+        height = darwinDesiredHeight;
+    }
+
+    switch (darwinDesiredDepth) {
+        case 0:
+            bpp = 8;
+            break;
+        case 1:
+            bpp = 16;
+            break;
+        case 2:
+            bpp = 32;
+            break;
+        default:
+            bpp = CGDisplayBitsPerPixel(cgID);
+    }
+
+    if (darwinDesiredRefresh == -1) {
+        fsDisplayInfo->xDisplayMode =
+                CGDisplayBestModeForParameters(cgID, bpp, width, height,
+                        &exactMatch);
+    } else {
+        fsDisplayInfo->xDisplayMode =
+                CGDisplayBestModeForParametersAndRefreshRate(cgID, bpp,
+                        width, height, darwinDesiredRefresh, &exactMatch);
+    }
+    if (!exactMatch) {
+        fsDisplayInfo->xDisplayMode = fsDisplayInfo->aquaDisplayMode;
+        return FALSE;
+    }
+
+    // Switch to the new display mode
+    CGDisplaySwitchToMode(cgID, fsDisplayInfo->xDisplayMode);
+    return TRUE;
+}
+
+
+/*
+ * FSAddScreen
+ *  Do initialization of each screen for Quartz in full screen mode.
+ */
+static Bool FSAddScreen(
+    int index,
+    ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    QuartzScreenPtr displayInfo = QUARTZ_PRIV(pScreen);
+    CGDirectDisplayID cgID = quartzDisplayList[index];
+    CGRect bounds;
+    FSScreenPtr fsDisplayInfo;
+
+    // Allocate space for private per screen fullscreen specific storage.
+    fsDisplayInfo = xalloc(sizeof(FSScreenRec));
+    FULLSCREEN_PRIV(pScreen) = fsDisplayInfo;
+
+    displayInfo->displayCount = 1;
+    displayInfo->displayIDs = xrealloc(displayInfo->displayIDs,
+                                      1 * sizeof(CGDirectDisplayID));
+    displayInfo->displayIDs[0] = cgID;
+
+    fsDisplayInfo->displayID = cgID;
+    fsDisplayInfo->xDisplayMode = 0;
+    fsDisplayInfo->aquaDisplayMode = 0;
+    fsDisplayInfo->xPalette = 0;
+    fsDisplayInfo->aquaPalette = 0;
+
+    // Capture full screen because X doesn't like read-only framebuffer.
+    // We need to do this before we (potentially) switch the display mode.
+    CGDisplayCapture(cgID);
+
+    if (! FSFindDisplayMode(fsDisplayInfo)) {
+        ErrorF("Could not support specified display mode on screen %i.\n",
+               index);
+        xfree(fsDisplayInfo);
+        return FALSE;
+    }
+
+    // Don't need to flip y-coordinate as CoreGraphics treats (0, 0)
+    // as the top left of main screen.
+    bounds = CGDisplayBounds(cgID);
+    dfb->x = bounds.origin.x;
+    dfb->y = bounds.origin.y;
+    dfb->width  = bounds.size.width;
+    dfb->height = bounds.size.height;
+    dfb->pitch = CGDisplayBytesPerRow(cgID);
+    dfb->bitsPerPixel = CGDisplayBitsPerPixel(cgID);
+
+    if (dfb->bitsPerPixel == 8) {
+        if (CGDisplayCanSetPalette(cgID)) {
+            dfb->colorType = PseudoColor;
+        } else {
+            dfb->colorType = StaticColor;
+        }
+        dfb->bitsPerComponent = 8;
+        dfb->colorBitsPerPixel = 8;
+    } else {
+        dfb->colorType = TrueColor;
+        dfb->bitsPerComponent = CGDisplayBitsPerSample(cgID);
+        dfb->colorBitsPerPixel = CGDisplaySamplesPerPixel(cgID) *
+                                 dfb->bitsPerComponent;
+    }
+
+    fsDisplayInfo->framebuffer = CGDisplayBaseAddress(cgID);
+
+    // allocate shadow framebuffer
+    fsDisplayInfo->shadowPtr = xalloc(dfb->pitch * dfb->height);
+    dfb->framebuffer = fsDisplayInfo->shadowPtr;
+
+    return TRUE;
+}
+
+
+/*
+ * FSShadowUpdate
+ *  Update the damaged regions of the shadow framebuffer on the display.
+ */
+static void FSShadowUpdate(
+    ScreenPtr pScreen,
+    shadowBufPtr pBuf)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    FSScreenPtr fsDisplayInfo = FULLSCREEN_PRIV(pScreen);
+    RegionPtr damage = &pBuf->damage;
+    int numBox = REGION_NUM_RECTS(damage);
+    BoxPtr pBox = REGION_RECTS(damage);
+    int pitch = dfb->pitch;
+    int bpp = dfb->bitsPerPixel/8;
+
+ErrorF("FSShadowUpdate: %i\n", quartzServerVisible);
+
+    // Don't update if the X server is not visible
+    if (!quartzServerVisible)
+        return;
+
+    // Loop through all the damaged boxes
+    while (numBox--) {
+        int width, height, offset;
+        unsigned char *src, *dst;
+
+        width = (pBox->x2 - pBox->x1) * bpp;
+        height = pBox->y2 - pBox->y1;
+        offset = (pBox->y1 * pitch) + (pBox->x1 * bpp);
+        src = fsDisplayInfo->shadowPtr + offset;
+        dst = fsDisplayInfo->framebuffer + offset;
+
+        while (height--) {
+            memcpy(dst, src, width);
+            dst += pitch;
+            src += pitch;
+        }
+
+        // Get the next box
+        pBox++;
+    }
+}
+
+
+/*
+ * FSSetupScreen
+ *  Finalize full screen specific setup of each screen.
+ */
+static Bool FSSetupScreen(
+    int index,
+    ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+    FSScreenPtr fsDisplayInfo = FULLSCREEN_PRIV(pScreen);
+    CGDirectDisplayID cgID = fsDisplayInfo->displayID;
+
+ErrorF("FSSetupScreen\n");
+    // Initialize shadow framebuffer support
+    if (! shadowInit(pScreen, FSShadowUpdate, NULL)) {
+        ErrorF("Failed to initalize shadow framebuffer for screen %i.\n",
+               index);
+        return FALSE;
+    }
+
+    if (dfb->colorType == PseudoColor) {
+        // Initialize colormap handling
+        size_t aquaBpp;
+
+        // If Aqua is using 8 bits we need to keep track of its pallete.
+        CFNumberGetValue(CFDictionaryGetValue(fsDisplayInfo->aquaDisplayMode,
+                         kCGDisplayBitsPerPixel), kCFNumberLongType, &aquaBpp);
+        if (aquaBpp <= 8)
+            fsDisplayInfo->aquaPalette = CGPaletteCreateWithDisplay(cgID);
+
+        pScreen->CreateColormap = FSCreateColormap;
+        pScreen->DestroyColormap = FSDestroyColormap;
+        pScreen->InstallColormap = FSInstallColormap;
+        pScreen->StoreColors = FSStoreColors;
+
+    }
+
+    quartzScreens[quartzNumScreens++] = fsDisplayInfo;
+    return TRUE;
+}
+
+
+/*
+ * Quartz display mode function list.
+ */
+static QuartzModeProcsRec fsModeProcs = {
+    FSDisplayInit,
+    FSAddScreen,
+    FSSetupScreen,
+    NULL,		// Not needed
+    QuartzInitCursor,
+    QuartzReallySetCursor,
+    FSSuspendScreen,
+    FSResumeScreen,
+    FSCapture,
+    FSRelease,
+    NULL,		// No rootless code in fullscreen
+    NULL,
+    NULL,
+    NULL,		// No support for DRI surfaces
+    NULL
+};
+
+
+/*
+ * QuartzModeBundleInit
+ *  Initialize the display mode bundle after loading.
+ */
+Bool
+QuartzModeBundleInit(void)
+{
+    quartzProcs = &fsModeProcs;
+    quartzOpenGLBundle = NULL;	// Only Mesa support for now
+    return TRUE;
+}
diff --git a/hw/darwin/quartz/fullscreen/quartzCursor.c b/hw/darwin/quartz/fullscreen/quartzCursor.c
new file mode 100644
index 000000000..72ad5ed8e
--- /dev/null
+++ b/hw/darwin/quartz/fullscreen/quartzCursor.c
@@ -0,0 +1,653 @@
+/**************************************************************
+ *
+ * Support for using the Quartz Window Manager cursor
+ *
+ **************************************************************/
+/*
+ * Copyright (c) 2001-2003 Torrey T. Lyons and Greg Parker.
+ *                 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/fullscreen/quartzCursor.c,v 1.1 2003/09/16 00:36:15 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "quartzCursor.h"
+#include "darwin.h"
+
+#include <pthread.h>
+
+#include "mi.h"
+#include "scrnintstr.h"
+#include "cursorstr.h"
+#include "mipointrst.h"
+#include "globals.h"
+
+// Size of the QuickDraw cursor
+#define CURSORWIDTH 16
+#define CURSORHEIGHT 16
+
+typedef struct {
+    int                     qdCursorMode;
+    int                     qdCursorVisible;
+    int                     useQDCursor;
+    QueryBestSizeProcPtr    QueryBestSize;
+    miPointerSpriteFuncPtr  spriteFuncs;
+} QuartzCursorScreenRec, *QuartzCursorScreenPtr;
+
+static int darwinCursorScreenIndex = -1;
+static unsigned long darwinCursorGeneration = 0;
+static CursorPtr quartzLatentCursor = NULL;
+static QD_Cursor gQDArrow; // QuickDraw arrow cursor
+
+// Cursor for the main thread to set (NULL = arrow cursor).
+static CCrsrHandle currentCursor = NULL;
+static pthread_mutex_t cursorMutex;
+static pthread_cond_t cursorCondition;
+
+#define CURSOR_PRIV(pScreen) \
+    ((QuartzCursorScreenPtr)pScreen->devPrivates[darwinCursorScreenIndex].ptr)
+
+#define HIDE_QD_CURSOR(pScreen, visible)                                \
+    if (visible) {                                                      \
+        int ix;                                                         \
+        for (ix = 0; ix < QUARTZ_PRIV(pScreen)->displayCount; ix++) {   \
+            CGDisplayHideCursor(QUARTZ_PRIV(pScreen)->displayIDs[ix]);  \
+        }                                                               \
+        visible = FALSE;                                                \
+    } ((void)0)
+
+#define SHOW_QD_CURSOR(pScreen, visible)                                \
+    {                                                                   \
+        int ix;                                                         \
+        for (ix = 0; ix < QUARTZ_PRIV(pScreen)->displayCount; ix++) {   \
+            CGDisplayShowCursor(QUARTZ_PRIV(pScreen)->displayIDs[ix]);  \
+        }                                                               \
+        visible = TRUE;                                                 \
+    } ((void)0)
+
+#define CHANGE_QD_CURSOR(cursorH)                                       \
+    if (!quartzServerQuitting) {                                        \
+        /* Acquire lock and tell the main thread to change cursor */    \
+        pthread_mutex_lock(&cursorMutex);                               \
+        currentCursor = (CCrsrHandle) (cursorH);                        \
+        QuartzMessageMainThread(kQuartzCursorUpdate, NULL, 0);          \
+                                                                        \
+        /* Wait for the main thread to change the cursor */             \
+        pthread_cond_wait(&cursorCondition, &cursorMutex);              \
+        pthread_mutex_unlock(&cursorMutex);                             \
+    } ((void)0)
+
+
+/*
+ * MakeQDCursor helpers: CTAB_ENTER, interleave
+ */
+
+// Add a color entry to a ctab
+#define CTAB_ENTER(ctab, index, r, g, b)                                \
+    ctab->ctTable[index].value = index;                                 \
+    ctab->ctTable[index].rgb.red = r;                                   \
+    ctab->ctTable[index].rgb.green = g;                                 \
+    ctab->ctTable[index].rgb.blue = b
+
+// Make an unsigned short by interleaving the bits of bytes c1 and c2.
+// High bit of c1 is first; low bit of c2 is last.
+// Interleave is a built-in INTERCAL operator.
+static unsigned short
+interleave(
+    unsigned char c1,
+    unsigned char c2 )
+{
+    return
+        ((c1 & 0x80) << 8) | ((c2 & 0x80) << 7) |
+        ((c1 & 0x40) << 7) | ((c2 & 0x40) << 6) |
+        ((c1 & 0x20) << 6) | ((c2 & 0x20) << 5) |
+        ((c1 & 0x10) << 5) | ((c2 & 0x10) << 4) |
+        ((c1 & 0x08) << 4) | ((c2 & 0x08) << 3) |
+        ((c1 & 0x04) << 3) | ((c2 & 0x04) << 2) |
+        ((c1 & 0x02) << 2) | ((c2 & 0x02) << 1) |
+        ((c1 & 0x01) << 1) | ((c2 & 0x01) << 0) ;
+}
+
+/*
+ * MakeQDCursor
+ * Make a QuickDraw color cursor from the given X11 cursor.
+ * Warning: This code is nasty. Color cursors were meant to be read
+ * from resources; constructing the structures programmatically is messy.
+ */
+/*
+    QuickDraw cursor representation:
+    Our color cursor is a 2 bit per pixel pixmap.
+    Each pixel's bits are (source<<1 | mask) from the original X cursor pixel.
+    The cursor's color table maps the colors like this:
+    (2-bit value | X result    | colortable | Mac result)
+             00  | transparent | white      | transparent (white outside mask)
+             01  | back color  | back color | back color
+             10  | undefined   | black      | invert background (just for fun)
+             11  | fore color  | fore color | fore color
+*/
+static CCrsrHandle
+MakeQDCursor(
+    CursorPtr pCursor )
+{
+    CCrsrHandle result;
+    CCrsrPtr curs;
+    int i, w, h;
+    unsigned short rowMask;
+    PixMap *pix;
+    ColorTable *ctab;
+    unsigned short *image;
+
+    result = (CCrsrHandle) NewHandleClear(sizeof(CCrsr));
+    if (!result) return NULL;
+    HLock((Handle)result);
+    curs = *result;
+
+    // Initialize CCrsr
+    curs->crsrType = 0x8001;     // 0x8000 = b&w, 0x8001 = color
+    curs->crsrMap = (PixMapHandle) NewHandleClear(sizeof(PixMap));
+    if (!curs->crsrMap) goto pixAllocFailed;
+    HLock((Handle)curs->crsrMap);
+    pix = *curs->crsrMap;
+    curs->crsrData = NULL;       // raw cursor image data (set below)
+    curs->crsrXData = NULL;      // QD's processed data
+    curs->crsrXValid = 0;        // zero means QD must re-process cursor data
+    curs->crsrXHandle = NULL;    // reserved
+    memset(curs->crsr1Data, 0, CURSORWIDTH*CURSORHEIGHT/8); // b&w data
+    memset(curs->crsrMask,  0, CURSORWIDTH*CURSORHEIGHT/8); // b&w & color mask
+    curs->crsrHotSpot.h = min(CURSORWIDTH,  pCursor->bits->xhot); // hot spot
+    curs->crsrHotSpot.v = min(CURSORHEIGHT, pCursor->bits->yhot); // hot spot
+    curs->crsrXTable = 0;        // reserved
+    curs->crsrID = GetCTSeed();  // unique ID from Color Manager
+
+    // Set the b&w data and mask
+    w = min(pCursor->bits->width,  CURSORWIDTH);
+    h = min(pCursor->bits->height, CURSORHEIGHT);
+    rowMask = ~((1 << (CURSORWIDTH - w)) - 1);
+    for (i = 0; i < h; i++) {
+        curs->crsr1Data[i] = rowMask &
+        ((pCursor->bits->source[i*4]<<8) | pCursor->bits->source[i*4+1]);
+        curs->crsrMask[i] = rowMask &
+        ((pCursor->bits->mask[i*4]<<8)   | pCursor->bits->mask[i*4+1]);
+    }
+
+    // Set the color data and mask
+    // crsrMap: defines bit depth and size and colortable only
+    pix->rowBytes = (CURSORWIDTH * 2 / 8) | 0x8000; // last bit on means PixMap
+    SetRect(&pix->bounds, 0, 0, CURSORWIDTH, CURSORHEIGHT); // see TN 1020
+    pix->pixelSize = 2;
+    pix->cmpCount = 1;
+    pix->cmpSize = 2;
+    // pix->pmTable set below
+
+    // crsrData is the pixel data. crsrMap's baseAddr is not used.
+    curs->crsrData = NewHandleClear(CURSORWIDTH*CURSORHEIGHT * 2 / 8);
+    if (!curs->crsrData) goto imageAllocFailed;
+    HLock((Handle)curs->crsrData);
+    image = (unsigned short *) *curs->crsrData;
+    // Pixel data is just 1-bit data and mask interleaved (see above)
+    for (i = 0; i < h; i++) {
+        unsigned char s, m;
+        s = pCursor->bits->source[i*4] & (rowMask >> 8);
+        m = pCursor->bits->mask[i*4] & (rowMask >> 8);
+        image[2*i] = interleave(s, m);
+        s = pCursor->bits->source[i*4+1] & (rowMask & 0x00ff);
+        m = pCursor->bits->mask[i*4+1] & (rowMask & 0x00ff);
+        image[2*i+1] = interleave(s, m);
+    }
+
+    // Build the color table (entries described above)
+    // NewPixMap allocates a color table handle.
+    pix->pmTable = (CTabHandle) NewHandleClear(sizeof(ColorTable) + 3
+                    * sizeof(ColorSpec));
+    if (!pix->pmTable) goto ctabAllocFailed;
+    HLock((Handle)pix->pmTable);
+    ctab = *pix->pmTable;
+    ctab->ctSeed = GetCTSeed();
+    ctab->ctFlags = 0;
+    ctab->ctSize = 3; // color count - 1
+    CTAB_ENTER(ctab, 0, 0xffff, 0xffff, 0xffff);
+    CTAB_ENTER(ctab, 1, pCursor->backRed, pCursor->backGreen,
+               pCursor->backBlue);
+    CTAB_ENTER(ctab, 2, 0x0000, 0x0000, 0x0000);
+    CTAB_ENTER(ctab, 3, pCursor->foreRed, pCursor->foreGreen,
+               pCursor->foreBlue);
+
+    HUnlock((Handle)pix->pmTable); // ctab
+    HUnlock((Handle)curs->crsrData); // image data
+    HUnlock((Handle)curs->crsrMap); // pix
+    HUnlock((Handle)result); // cursor
+
+    return result;
+
+    // "What we have here is a failure to allocate"
+ctabAllocFailed:
+    HUnlock((Handle)curs->crsrData);
+    DisposeHandle((Handle)curs->crsrData);
+imageAllocFailed:
+    HUnlock((Handle)curs->crsrMap);
+    DisposeHandle((Handle)curs->crsrMap);
+pixAllocFailed:
+    HUnlock((Handle)result);
+    DisposeHandle((Handle)result);
+    return NULL;
+}
+
+
+/*
+ * FreeQDCursor
+ * Destroy a QuickDraw color cursor created with MakeQDCursor().
+ * The cursor must not currently be on screen.
+ */
+static void FreeQDCursor(CCrsrHandle cursHandle)
+{
+    CCrsrPtr curs;
+    PixMap *pix;
+
+    HLock((Handle)cursHandle);
+    curs = *cursHandle;
+    HLock((Handle)curs->crsrMap);
+    pix = *curs->crsrMap;
+    DisposeHandle((Handle)pix->pmTable);
+    HUnlock((Handle)curs->crsrMap);
+    DisposeHandle((Handle)curs->crsrMap);
+    DisposeHandle((Handle)curs->crsrData);
+    HUnlock((Handle)cursHandle);
+    DisposeHandle((Handle)cursHandle);
+}
+
+
+/*
+===========================================================================
+
+ Pointer sprite functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzRealizeCursor
+ * Convert the X cursor representation to QuickDraw format if possible.
+ */
+Bool
+QuartzRealizeCursor(
+    ScreenPtr pScreen,
+    CursorPtr pCursor )
+{
+    CCrsrHandle qdCursor;
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if(!pCursor || !pCursor->bits)
+        return FALSE;
+
+    // if the cursor is too big we use a software cursor
+    if ((pCursor->bits->height > CURSORHEIGHT) ||
+        (pCursor->bits->width > CURSORWIDTH) || !ScreenPriv->useQDCursor)
+    {
+        if (quartzRootless) {
+            // rootless can't use a software cursor
+            return TRUE;
+        } else {
+            return (*ScreenPriv->spriteFuncs->RealizeCursor)
+                        (pScreen, pCursor);
+        }
+    }
+
+    // make new cursor image
+    qdCursor = MakeQDCursor(pCursor);
+    if (!qdCursor) return FALSE;
+
+    // save the result
+    pCursor->devPriv[pScreen->myNum] = (pointer) qdCursor;
+
+    return TRUE;
+}
+
+
+/*
+ * QuartzUnrealizeCursor
+ * Free the storage space associated with a realized cursor.
+ */
+Bool
+QuartzUnrealizeCursor(
+    ScreenPtr pScreen,
+    CursorPtr pCursor )
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if ((pCursor->bits->height > CURSORHEIGHT) ||
+        (pCursor->bits->width > CURSORWIDTH) || !ScreenPriv->useQDCursor)
+    {
+        if (quartzRootless) {
+            return TRUE;
+        } else {
+            return (*ScreenPriv->spriteFuncs->UnrealizeCursor)
+                        (pScreen, pCursor);
+        }
+    } else {
+        CCrsrHandle oldCursor = (CCrsrHandle) pCursor->devPriv[pScreen->myNum];
+
+        if (currentCursor != oldCursor) {
+            // This should only fail when quitting, in which case we just leak.
+            FreeQDCursor(oldCursor);
+        }
+        pCursor->devPriv[pScreen->myNum] = NULL;
+        return TRUE;
+    }
+}
+
+
+/*
+ * QuartzSetCursor
+ * Set the cursor sprite and position.
+ * Use QuickDraw cursor if possible.
+ */
+static void
+QuartzSetCursor(
+    ScreenPtr       pScreen,
+    CursorPtr       pCursor,
+    int             x,
+    int             y)
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    quartzLatentCursor = pCursor;
+
+    // Don't touch Mac OS cursor if X is hidden!
+    if (!quartzServerVisible)
+        return;
+
+    if (!pCursor) {
+        // Remove the cursor completely.
+        HIDE_QD_CURSOR(pScreen, ScreenPriv->qdCursorVisible);
+        if (! ScreenPriv->qdCursorMode)
+            (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, 0, x, y);
+    }
+    else if ((pCursor->bits->height <= CURSORHEIGHT) &&
+             (pCursor->bits->width <= CURSORWIDTH) && ScreenPriv->useQDCursor)
+    {
+        // Cursor is small enough to use QuickDraw directly.
+        if (! ScreenPriv->qdCursorMode)    // remove the X cursor
+            (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, 0, x, y);
+        ScreenPriv->qdCursorMode = TRUE;
+
+        CHANGE_QD_CURSOR(pCursor->devPriv[pScreen->myNum]);
+        SHOW_QD_CURSOR(pScreen, ScreenPriv->qdCursorVisible);
+    }
+    else if (quartzRootless) {
+        // Rootless can't use a software cursor, so we just use Mac OS arrow.
+        CHANGE_QD_CURSOR(NULL);
+        SHOW_QD_CURSOR(pScreen, ScreenPriv->qdCursorVisible);
+    }
+    else {
+        // Cursor is too big for QuickDraw. Use X software cursor.
+        HIDE_QD_CURSOR(pScreen, ScreenPriv->qdCursorVisible);
+        ScreenPriv->qdCursorMode = FALSE;
+        (*ScreenPriv->spriteFuncs->SetCursor)(pScreen, pCursor, x, y);
+    }
+}
+
+
+/*
+ * QuartzReallySetCursor
+ * Set the QuickDraw cursor. Called from the main thread since changing the
+ * cursor with QuickDraw is not thread safe on dual processor machines.
+ */
+void
+QuartzReallySetCursor()
+{
+    pthread_mutex_lock(&cursorMutex);
+
+    if (currentCursor) {
+        SetCCursor(currentCursor);
+    } else {
+        SetCursor(&gQDArrow);
+    }
+
+    pthread_cond_signal(&cursorCondition);
+    pthread_mutex_unlock(&cursorMutex);
+}
+
+
+/*
+ * QuartzMoveCursor
+ * Move the cursor. This is a noop for QuickDraw.
+ */
+static void
+QuartzMoveCursor(
+    ScreenPtr   pScreen,
+    int         x,
+    int         y)
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    // only the X cursor needs to be explicitly moved
+    if (!ScreenPriv->qdCursorMode)
+        (*ScreenPriv->spriteFuncs->MoveCursor)(pScreen, x, y);
+}
+
+
+static miPointerSpriteFuncRec quartzSpriteFuncsRec = {
+    QuartzRealizeCursor,
+    QuartzUnrealizeCursor,
+    QuartzSetCursor,
+    QuartzMoveCursor
+};
+
+
+/*
+===========================================================================
+
+ Pointer screen functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzCursorOffScreen
+ */
+static Bool QuartzCursorOffScreen(ScreenPtr *pScreen, int *x, int *y)
+{
+    return FALSE;
+}
+
+
+/*
+ * QuartzCrossScreen
+ */
+static void QuartzCrossScreen(ScreenPtr pScreen, Bool entering)
+{
+    return;
+}
+
+
+/*
+ * QuartzWarpCursor
+ *  Change the cursor position without generating an event or motion history.
+ *  The input coordinates (x,y) are in pScreen-local X11 coordinates.
+ *
+ */
+static void
+QuartzWarpCursor(
+    ScreenPtr               pScreen,
+    int                     x,
+    int                     y)
+{
+    static int              neverMoved = TRUE;
+
+    if (neverMoved) {
+        // Don't move the cursor the first time. This is the jump-to-center
+        // initialization, and it's annoying because we may still be in MacOS.
+        neverMoved = FALSE;
+        return;
+    }
+
+    if (quartzServerVisible) {
+        CGDisplayErr        cgErr;
+        CGPoint             cgPoint;
+        // Only need to do this for one display. Any display will do.
+        CGDirectDisplayID   cgID = QUARTZ_PRIV(pScreen)->displayIDs[0];
+        CGRect              cgRect = CGDisplayBounds(cgID);
+
+        // Convert (x,y) to CoreGraphics screen-local CG coordinates.
+        // This is necessary because the X11 screen and CG screen may not
+        // coincide. (e.g. X11 screen may be moved to dodge the menu bar)
+
+        // Make point in X11 global coordinates
+        cgPoint = CGPointMake(x + dixScreenOrigins[pScreen->myNum].x,
+                              y + dixScreenOrigins[pScreen->myNum].y);
+        // Shift to CoreGraphics global screen coordinates
+        cgPoint.x += darwinMainScreenX;
+        cgPoint.y += darwinMainScreenY;
+        // Shift to CoreGraphics screen-local coordinates
+        cgPoint.x -= cgRect.origin.x;
+        cgPoint.y -= cgRect.origin.y;
+
+        cgErr = CGDisplayMoveCursorToPoint(cgID, cgPoint);
+        if (cgErr != CGDisplayNoErr) {
+            ErrorF("Could not set cursor position with error code 0x%x.\n",
+                    cgErr);
+        }
+    }
+
+    miPointerWarpCursor(pScreen, x, y);
+    miPointerUpdate();
+}
+
+
+static miPointerScreenFuncRec quartzScreenFuncsRec = {
+    QuartzCursorOffScreen,
+    QuartzCrossScreen,
+    QuartzWarpCursor,
+    DarwinEQPointerPost,
+    DarwinEQSwitchScreen
+};
+
+
+/*
+===========================================================================
+
+ Other screen functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzCursorQueryBestSize
+ * Handle queries for best cursor size
+ */
+static void
+QuartzCursorQueryBestSize(
+   int              class,
+   unsigned short   *width,
+   unsigned short   *height,
+   ScreenPtr        pScreen)
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if (class == CursorShape) {
+        *width = CURSORWIDTH;
+        *height = CURSORHEIGHT;
+    } else {
+        (*ScreenPriv->QueryBestSize)(class, width, height, pScreen);
+    }
+}
+
+
+/*
+ * QuartzInitCursor
+ * Initialize cursor support
+ */
+Bool
+QuartzInitCursor(
+    ScreenPtr   pScreen )
+{
+    QuartzCursorScreenPtr   ScreenPriv;
+    miPointerScreenPtr      PointPriv;
+    DarwinFramebufferPtr    dfb = SCREEN_PRIV(pScreen);
+
+    // initialize software cursor handling (always needed as backup)
+    if (!miDCInitialize(pScreen, &quartzScreenFuncsRec)) {
+        return FALSE;
+    }
+
+    // allocate private storage for this screen's QuickDraw cursor info
+    if (darwinCursorGeneration != serverGeneration) {
+        if ((darwinCursorScreenIndex = AllocateScreenPrivateIndex()) < 0)
+            return FALSE;
+        darwinCursorGeneration = serverGeneration;
+    }
+
+    ScreenPriv = xcalloc( 1, sizeof(QuartzCursorScreenRec) );
+    if (!ScreenPriv) return FALSE;
+
+    CURSOR_PRIV(pScreen) = ScreenPriv;
+
+    // override some screen procedures
+    ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
+    pScreen->QueryBestSize = QuartzCursorQueryBestSize;
+
+    // initialize QuickDraw cursor handling
+    GetQDGlobalsArrow(&gQDArrow);
+    PointPriv = (miPointerScreenPtr)
+                    pScreen->devPrivates[miPointerScreenIndex].ptr;
+
+    ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
+    PointPriv->spriteFuncs = &quartzSpriteFuncsRec;
+
+    if (!quartzRootless)
+        ScreenPriv->useQDCursor = QuartzFSUseQDCursor(dfb->colorBitsPerPixel);
+    else
+        ScreenPriv->useQDCursor = TRUE;
+    ScreenPriv->qdCursorMode = TRUE;
+    ScreenPriv->qdCursorVisible = TRUE;
+
+    // initialize cursor mutex lock
+    pthread_mutex_init(&cursorMutex, NULL);
+
+    // initialize condition for waiting
+    pthread_cond_init(&cursorCondition, NULL);
+
+    return TRUE;
+}
+
+
+// X server is hiding. Restore the Aqua cursor.
+void QuartzSuspendXCursor(
+    ScreenPtr pScreen )
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    CHANGE_QD_CURSOR(NULL);
+    SHOW_QD_CURSOR(pScreen, ScreenPriv->qdCursorVisible);
+}
+
+
+// X server is showing. Restore the X cursor.
+void QuartzResumeXCursor(
+    ScreenPtr pScreen,
+    int x,
+    int y )
+{
+    QuartzSetCursor(pScreen, quartzLatentCursor, x, y);
+}
diff --git a/hw/darwin/quartz/fullscreen/quartzCursor.h b/hw/darwin/quartz/fullscreen/quartzCursor.h
new file mode 100644
index 000000000..d822c3e86
--- /dev/null
+++ b/hw/darwin/quartz/fullscreen/quartzCursor.h
@@ -0,0 +1,44 @@
+/*
+ * quartzCursor.h
+ *
+ * External interface for Quartz hardware cursor
+ */
+/*
+ * Copyright (c) 2001 Torrey T. Lyons and Greg Parker.
+ *                 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/fullscreen/quartzCursor.h,v 1.1 2003/09/16 00:36:15 torrey Exp $ */
+
+#ifndef QUARTZCURSOR_H
+#define QUARTZCURSOR_H
+
+#include "screenint.h"
+
+Bool QuartzInitCursor(ScreenPtr pScreen);
+void QuartzReallySetCursor(void);
+void QuartzSuspendXCursor(ScreenPtr pScreen);
+void QuartzResumeXCursor(ScreenPtr pScreen, int x, int y);
+
+#endif
diff --git a/hw/darwin/quartz/keysym2ucs.c b/hw/darwin/quartz/keysym2ucs.c
new file mode 100644
index 000000000..420830965
--- /dev/null
+++ b/hw/darwin/quartz/keysym2ucs.c
@@ -0,0 +1,909 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/keysym2ucs.c,v 1.1 2003/11/01 08:13:08 torrey Exp $
+ *
+ * This module converts keysym values into the corresponding ISO 10646
+ * (UCS, Unicode) values.
+ *
+ * The array keysymtab[] contains pairs of X11 keysym values for graphical
+ * characters and the corresponding Unicode value. The function
+ * keysym2ucs() maps a keysym onto a Unicode value using a binary search,
+ * therefore keysymtab[] must remain SORTED by keysym value.
+ *
+ * The keysym -> UTF-8 conversion will hopefully one day be provided
+ * by Xlib via XmbLookupString() and should ideally not have to be
+ * done in X applications. But we are not there yet.
+ *
+ * We allow to represent any UCS character in the range U-00000000 to
+ * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
+ * This admittedly does not cover the entire 31-bit space of UCS, but
+ * it does cover all of the characters up to U-10FFFF, which can be
+ * represented by UTF-16, and more, and it is very unlikely that higher
+ * UCS codes will ever be assigned by ISO. So to get Unicode character
+ * U+ABCD you can directly use keysym 0x0100abcd.
+ *
+ * NOTE: The comments in the table below contain the actual character
+ * encoded in UTF-8, so for viewing and editing best use an editor in
+ * UTF-8 mode.
+ *
+ * Author: Markus G. Kuhn <mkuhn@acm.org>, University of Cambridge, April 2001
+ *
+ * Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing
+ * an initial draft of the mapping table.
+ *
+ * This software is in the public domain. Share and enjoy!
+ *
+ * AUTOMATICALLY GENERATED FILE, DO NOT EDIT !!! (unicode/convmap.pl)
+ */
+
+#include "keysym2ucs.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+struct codepair {
+  unsigned short keysym;
+  unsigned short ucs;
+};
+
+const static struct codepair keysymtab[] = {
+  { 0x01a1, 0x0104 },
+  { 0x01a2, 0x02d8 },
+  { 0x01a3, 0x0141 },
+  { 0x01a5, 0x013d },
+  { 0x01a6, 0x015a },
+  { 0x01a9, 0x0160 },
+  { 0x01aa, 0x015e },
+  { 0x01ab, 0x0164 },
+  { 0x01ac, 0x0179 },
+  { 0x01ae, 0x017d },
+  { 0x01af, 0x017b },
+  { 0x01b1, 0x0105 },
+  { 0x01b2, 0x02db },
+  { 0x01b3, 0x0142 },
+  { 0x01b5, 0x013e },
+  { 0x01b6, 0x015b },
+  { 0x01b7, 0x02c7 },
+  { 0x01b9, 0x0161 },
+  { 0x01ba, 0x015f },
+  { 0x01bb, 0x0165 },
+  { 0x01bc, 0x017a },
+  { 0x01bd, 0x02dd },
+  { 0x01be, 0x017e },
+  { 0x01bf, 0x017c },
+  { 0x01c0, 0x0154 },
+  { 0x01c3, 0x0102 },
+  { 0x01c5, 0x0139 },
+  { 0x01c6, 0x0106 },
+  { 0x01c8, 0x010c },
+  { 0x01ca, 0x0118 },
+  { 0x01cc, 0x011a },
+  { 0x01cf, 0x010e },
+  { 0x01d0, 0x0110 },
+  { 0x01d1, 0x0143 },
+  { 0x01d2, 0x0147 },
+  { 0x01d5, 0x0150 },
+  { 0x01d8, 0x0158 },
+  { 0x01d9, 0x016e },
+  { 0x01db, 0x0170 },
+  { 0x01de, 0x0162 },
+  { 0x01e0, 0x0155 },
+  { 0x01e3, 0x0103 },
+  { 0x01e5, 0x013a },
+  { 0x01e6, 0x0107 },
+  { 0x01e8, 0x010d },
+  { 0x01ea, 0x0119 },
+  { 0x01ec, 0x011b },
+  { 0x01ef, 0x010f },
+  { 0x01f0, 0x0111 },
+  { 0x01f1, 0x0144 },
+  { 0x01f2, 0x0148 },
+  { 0x01f5, 0x0151 },
+  { 0x01f8, 0x0159 },
+  { 0x01f9, 0x016f },
+  { 0x01fb, 0x0171 },
+  { 0x01fe, 0x0163 },
+  { 0x01ff, 0x02d9 },
+  { 0x02a1, 0x0126 },
+  { 0x02a6, 0x0124 },
+  { 0x02a9, 0x0130 },
+  { 0x02ab, 0x011e },
+  { 0x02ac, 0x0134 },
+  { 0x02b1, 0x0127 },
+  { 0x02b6, 0x0125 },
+  { 0x02b9, 0x0131 },
+  { 0x02bb, 0x011f },
+  { 0x02bc, 0x0135 },
+  { 0x02c5, 0x010a },
+  { 0x02c6, 0x0108 },
+  { 0x02d5, 0x0120 },
+  { 0x02d8, 0x011c },
+  { 0x02dd, 0x016c },
+  { 0x02de, 0x015c },
+  { 0x02e5, 0x010b },
+  { 0x02e6, 0x0109 },
+  { 0x02f5, 0x0121 },
+  { 0x02f8, 0x011d },
+  { 0x02fd, 0x016d },
+  { 0x02fe, 0x015d },
+  { 0x03a2, 0x0138 },
+  { 0x03a3, 0x0156 },
+  { 0x03a5, 0x0128 },
+  { 0x03a6, 0x013b },
+  { 0x03aa, 0x0112 },
+  { 0x03ab, 0x0122 },
+  { 0x03ac, 0x0166 },
+  { 0x03b3, 0x0157 },
+  { 0x03b5, 0x0129 },
+  { 0x03b6, 0x013c },
+  { 0x03ba, 0x0113 },
+  { 0x03bb, 0x0123 },
+  { 0x03bc, 0x0167 },
+  { 0x03bd, 0x014a },
+  { 0x03bf, 0x014b },
+  { 0x03c0, 0x0100 },
+  { 0x03c7, 0x012e },
+  { 0x03cc, 0x0116 },
+  { 0x03cf, 0x012a },
+  { 0x03d1, 0x0145 },
+  { 0x03d2, 0x014c },
+  { 0x03d3, 0x0136 },
+  { 0x03d9, 0x0172 },
+  { 0x03dd, 0x0168 },
+  { 0x03de, 0x016a },
+  { 0x03e0, 0x0101 },
+  { 0x03e7, 0x012f },
+  { 0x03ec, 0x0117 },
+  { 0x03ef, 0x012b },
+  { 0x03f1, 0x0146 },
+  { 0x03f2, 0x014d },
+  { 0x03f3, 0x0137 },
+  { 0x03f9, 0x0173 },
+  { 0x03fd, 0x0169 },
+  { 0x03fe, 0x016b },
+  { 0x047e, 0x203e },
+  { 0x04a1, 0x3002 },
+  { 0x04a2, 0x300c },
+  { 0x04a3, 0x300d },
+  { 0x04a4, 0x3001 },
+  { 0x04a5, 0x30fb },
+  { 0x04a6, 0x30f2 },
+  { 0x04a7, 0x30a1 },
+  { 0x04a8, 0x30a3 },
+  { 0x04a9, 0x30a5 },
+  { 0x04aa, 0x30a7 },
+  { 0x04ab, 0x30a9 },
+  { 0x04ac, 0x30e3 },
+  { 0x04ad, 0x30e5 },
+  { 0x04ae, 0x30e7 },
+  { 0x04af, 0x30c3 },
+  { 0x04b0, 0x30fc },
+  { 0x04b1, 0x30a2 },
+  { 0x04b2, 0x30a4 },
+  { 0x04b3, 0x30a6 },
+  { 0x04b4, 0x30a8 },
+  { 0x04b5, 0x30aa },
+  { 0x04b6, 0x30ab },
+  { 0x04b7, 0x30ad },
+  { 0x04b8, 0x30af },
+  { 0x04b9, 0x30b1 },
+  { 0x04ba, 0x30b3 },
+  { 0x04bb, 0x30b5 },
+  { 0x04bc, 0x30b7 },
+  { 0x04bd, 0x30b9 },
+  { 0x04be, 0x30bb },
+  { 0x04bf, 0x30bd },
+  { 0x04c0, 0x30bf },
+  { 0x04c1, 0x30c1 },
+  { 0x04c2, 0x30c4 },
+  { 0x04c3, 0x30c6 },
+  { 0x04c4, 0x30c8 },
+  { 0x04c5, 0x30ca },
+  { 0x04c6, 0x30cb },
+  { 0x04c7, 0x30cc },
+  { 0x04c8, 0x30cd },
+  { 0x04c9, 0x30ce },
+  { 0x04ca, 0x30cf },
+  { 0x04cb, 0x30d2 },
+  { 0x04cc, 0x30d5 },
+  { 0x04cd, 0x30d8 },
+  { 0x04ce, 0x30db },
+  { 0x04cf, 0x30de },
+  { 0x04d0, 0x30df },
+  { 0x04d1, 0x30e0 },
+  { 0x04d2, 0x30e1 },
+  { 0x04d3, 0x30e2 },
+  { 0x04d4, 0x30e4 },
+  { 0x04d5, 0x30e6 },
+  { 0x04d6, 0x30e8 },
+  { 0x04d7, 0x30e9 },
+  { 0x04d8, 0x30ea },
+  { 0x04d9, 0x30eb },
+  { 0x04da, 0x30ec },
+  { 0x04db, 0x30ed },
+  { 0x04dc, 0x30ef },
+  { 0x04dd, 0x30f3 },
+  { 0x04de, 0x309b },
+  { 0x04df, 0x309c },
+  { 0x05ac, 0x060c },
+  { 0x05bb, 0x061b },
+  { 0x05bf, 0x061f },
+  { 0x05c1, 0x0621 },
+  { 0x05c2, 0x0622 },
+  { 0x05c3, 0x0623 },
+  { 0x05c4, 0x0624 },
+  { 0x05c5, 0x0625 },
+  { 0x05c6, 0x0626 },
+  { 0x05c7, 0x0627 },
+  { 0x05c8, 0x0628 },
+  { 0x05c9, 0x0629 },
+  { 0x05ca, 0x062a },
+  { 0x05cb, 0x062b },
+  { 0x05cc, 0x062c },
+  { 0x05cd, 0x062d },
+  { 0x05ce, 0x062e },
+  { 0x05cf, 0x062f },
+  { 0x05d0, 0x0630 },
+  { 0x05d1, 0x0631 },
+  { 0x05d2, 0x0632 },
+  { 0x05d3, 0x0633 },
+  { 0x05d4, 0x0634 },
+  { 0x05d5, 0x0635 },
+  { 0x05d6, 0x0636 },
+  { 0x05d7, 0x0637 },
+  { 0x05d8, 0x0638 },
+  { 0x05d9, 0x0639 },
+  { 0x05da, 0x063a },
+  { 0x05e0, 0x0640 },
+  { 0x05e1, 0x0641 },
+  { 0x05e2, 0x0642 },
+  { 0x05e3, 0x0643 },
+  { 0x05e4, 0x0644 },
+  { 0x05e5, 0x0645 },
+  { 0x05e6, 0x0646 },
+  { 0x05e7, 0x0647 },
+  { 0x05e8, 0x0648 },
+  { 0x05e9, 0x0649 },
+  { 0x05ea, 0x064a },
+  { 0x05eb, 0x064b },
+  { 0x05ec, 0x064c },
+  { 0x05ed, 0x064d },
+  { 0x05ee, 0x064e },
+  { 0x05ef, 0x064f },
+  { 0x05f0, 0x0650 },
+  { 0x05f1, 0x0651 },
+  { 0x05f2, 0x0652 },
+  { 0x06a1, 0x0452 },
+  { 0x06a2, 0x0453 },
+  { 0x06a3, 0x0451 },
+  { 0x06a4, 0x0454 },
+  { 0x06a5, 0x0455 },
+  { 0x06a6, 0x0456 },
+  { 0x06a7, 0x0457 },
+  { 0x06a8, 0x0458 },
+  { 0x06a9, 0x0459 },
+  { 0x06aa, 0x045a },
+  { 0x06ab, 0x045b },
+  { 0x06ac, 0x045c },
+  { 0x06ae, 0x045e },
+  { 0x06af, 0x045f },
+  { 0x06b0, 0x2116 },
+  { 0x06b1, 0x0402 },
+  { 0x06b2, 0x0403 },
+  { 0x06b3, 0x0401 },
+  { 0x06b4, 0x0404 },
+  { 0x06b5, 0x0405 },
+  { 0x06b6, 0x0406 },
+  { 0x06b7, 0x0407 },
+  { 0x06b8, 0x0408 },
+  { 0x06b9, 0x0409 },
+  { 0x06ba, 0x040a },
+  { 0x06bb, 0x040b },
+  { 0x06bc, 0x040c },
+  { 0x06be, 0x040e },
+  { 0x06bf, 0x040f },
+  { 0x06c0, 0x044e },
+  { 0x06c1, 0x0430 },
+  { 0x06c2, 0x0431 },
+  { 0x06c3, 0x0446 },
+  { 0x06c4, 0x0434 },
+  { 0x06c5, 0x0435 },
+  { 0x06c6, 0x0444 },
+  { 0x06c7, 0x0433 },
+  { 0x06c8, 0x0445 },
+  { 0x06c9, 0x0438 },
+  { 0x06ca, 0x0439 },
+  { 0x06cb, 0x043a },
+  { 0x06cc, 0x043b },
+  { 0x06cd, 0x043c },
+  { 0x06ce, 0x043d },
+  { 0x06cf, 0x043e },
+  { 0x06d0, 0x043f },
+  { 0x06d1, 0x044f },
+  { 0x06d2, 0x0440 },
+  { 0x06d3, 0x0441 },
+  { 0x06d4, 0x0442 },
+  { 0x06d5, 0x0443 },
+  { 0x06d6, 0x0436 },
+  { 0x06d7, 0x0432 },
+  { 0x06d8, 0x044c },
+  { 0x06d9, 0x044b },
+  { 0x06da, 0x0437 },
+  { 0x06db, 0x0448 },
+  { 0x06dc, 0x044d },
+  { 0x06dd, 0x0449 },
+  { 0x06de, 0x0447 },
+  { 0x06df, 0x044a },
+  { 0x06e0, 0x042e },
+  { 0x06e1, 0x0410 },
+  { 0x06e2, 0x0411 },
+  { 0x06e3, 0x0426 },
+  { 0x06e4, 0x0414 },
+  { 0x06e5, 0x0415 },
+  { 0x06e6, 0x0424 },
+  { 0x06e7, 0x0413 },
+  { 0x06e8, 0x0425 },
+  { 0x06e9, 0x0418 },
+  { 0x06ea, 0x0419 },
+  { 0x06eb, 0x041a },
+  { 0x06ec, 0x041b },
+  { 0x06ed, 0x041c },
+  { 0x06ee, 0x041d },
+  { 0x06ef, 0x041e },
+  { 0x06f0, 0x041f },
+  { 0x06f1, 0x042f },
+  { 0x06f2, 0x0420 },
+  { 0x06f3, 0x0421 },
+  { 0x06f4, 0x0422 },
+  { 0x06f5, 0x0423 },
+  { 0x06f6, 0x0416 },
+  { 0x06f7, 0x0412 },
+  { 0x06f8, 0x042c },
+  { 0x06f9, 0x042b },
+  { 0x06fa, 0x0417 },
+  { 0x06fb, 0x0428 },
+  { 0x06fc, 0x042d },
+  { 0x06fd, 0x0429 },
+  { 0x06fe, 0x0427 },
+  { 0x06ff, 0x042a },
+  { 0x07a1, 0x0386 },
+  { 0x07a2, 0x0388 },
+  { 0x07a3, 0x0389 },
+  { 0x07a4, 0x038a },
+  { 0x07a5, 0x03aa },
+  { 0x07a7, 0x038c },
+  { 0x07a8, 0x038e },
+  { 0x07a9, 0x03ab },
+  { 0x07ab, 0x038f },
+  { 0x07ae, 0x0385 },
+  { 0x07af, 0x2015 },
+  { 0x07b1, 0x03ac },
+  { 0x07b2, 0x03ad },
+  { 0x07b3, 0x03ae },
+  { 0x07b4, 0x03af },
+  { 0x07b5, 0x03ca },
+  { 0x07b6, 0x0390 },
+  { 0x07b7, 0x03cc },
+  { 0x07b8, 0x03cd },
+  { 0x07b9, 0x03cb },
+  { 0x07ba, 0x03b0 },
+  { 0x07bb, 0x03ce },
+  { 0x07c1, 0x0391 },
+  { 0x07c2, 0x0392 },
+  { 0x07c3, 0x0393 },
+  { 0x07c4, 0x0394 },
+  { 0x07c5, 0x0395 },
+  { 0x07c6, 0x0396 },
+  { 0x07c7, 0x0397 },
+  { 0x07c8, 0x0398 },
+  { 0x07c9, 0x0399 },
+  { 0x07ca, 0x039a },
+  { 0x07cb, 0x039b },
+  { 0x07cc, 0x039c },
+  { 0x07cd, 0x039d },
+  { 0x07ce, 0x039e },
+  { 0x07cf, 0x039f },
+  { 0x07d0, 0x03a0 },
+  { 0x07d1, 0x03a1 },
+  { 0x07d2, 0x03a3 },
+  { 0x07d4, 0x03a4 },
+  { 0x07d5, 0x03a5 },
+  { 0x07d6, 0x03a6 },
+  { 0x07d7, 0x03a7 },
+  { 0x07d8, 0x03a8 },
+  { 0x07d9, 0x03a9 },
+  { 0x07e1, 0x03b1 },
+  { 0x07e2, 0x03b2 },
+  { 0x07e3, 0x03b3 },
+  { 0x07e4, 0x03b4 },
+  { 0x07e5, 0x03b5 },
+  { 0x07e6, 0x03b6 },
+  { 0x07e7, 0x03b7 },
+  { 0x07e8, 0x03b8 },
+  { 0x07e9, 0x03b9 },
+  { 0x07ea, 0x03ba },
+  { 0x07eb, 0x03bb },
+  { 0x07ec, 0x03bc },
+  { 0x07ed, 0x03bd },
+  { 0x07ee, 0x03be },
+  { 0x07ef, 0x03bf },
+  { 0x07f0, 0x03c0 },
+  { 0x07f1, 0x03c1 },
+  { 0x07f2, 0x03c3 },
+  { 0x07f3, 0x03c2 },
+  { 0x07f4, 0x03c4 },
+  { 0x07f5, 0x03c5 },
+  { 0x07f6, 0x03c6 },
+  { 0x07f7, 0x03c7 },
+  { 0x07f8, 0x03c8 },
+  { 0x07f9, 0x03c9 },
+  { 0x08a1, 0x23b7 },
+  { 0x08a2, 0x250c },
+  { 0x08a3, 0x2500 },
+  { 0x08a4, 0x2320 },
+  { 0x08a5, 0x2321 },
+  { 0x08a6, 0x2502 },
+  { 0x08a7, 0x23a1 },
+  { 0x08a8, 0x23a3 },
+  { 0x08a9, 0x23a4 },
+  { 0x08aa, 0x23a6 },
+  { 0x08ab, 0x239b },
+  { 0x08ac, 0x239d },
+  { 0x08ad, 0x239e },
+  { 0x08ae, 0x23a0 },
+  { 0x08af, 0x23a8 },
+  { 0x08b0, 0x23ac },
+  { 0x08bc, 0x2264 },
+  { 0x08bd, 0x2260 },
+  { 0x08be, 0x2265 },
+  { 0x08bf, 0x222b },
+  { 0x08c0, 0x2234 },
+  { 0x08c1, 0x221d },
+  { 0x08c2, 0x221e },
+  { 0x08c5, 0x2207 },
+  { 0x08c8, 0x223c },
+  { 0x08c9, 0x2243 },
+  { 0x08cd, 0x21d4 },
+  { 0x08ce, 0x21d2 },
+  { 0x08cf, 0x2261 },
+  { 0x08d6, 0x221a },
+  { 0x08da, 0x2282 },
+  { 0x08db, 0x2283 },
+  { 0x08dc, 0x2229 },
+  { 0x08dd, 0x222a },
+  { 0x08de, 0x2227 },
+  { 0x08df, 0x2228 },
+  { 0x08ef, 0x2202 },
+  { 0x08f6, 0x0192 },
+  { 0x08fb, 0x2190 },
+  { 0x08fc, 0x2191 },
+  { 0x08fd, 0x2192 },
+  { 0x08fe, 0x2193 },
+  { 0x09e0, 0x25c6 },
+  { 0x09e1, 0x2592 },
+  { 0x09e2, 0x2409 },
+  { 0x09e3, 0x240c },
+  { 0x09e4, 0x240d },
+  { 0x09e5, 0x240a },
+  { 0x09e8, 0x2424 },
+  { 0x09e9, 0x240b },
+  { 0x09ea, 0x2518 },
+  { 0x09eb, 0x2510 },
+  { 0x09ec, 0x250c },
+  { 0x09ed, 0x2514 },
+  { 0x09ee, 0x253c },
+  { 0x09ef, 0x23ba },
+  { 0x09f0, 0x23bb },
+  { 0x09f1, 0x2500 },
+  { 0x09f2, 0x23bc },
+  { 0x09f3, 0x23bd },
+  { 0x09f4, 0x251c },
+  { 0x09f5, 0x2524 },
+  { 0x09f6, 0x2534 },
+  { 0x09f7, 0x252c },
+  { 0x09f8, 0x2502 },
+  { 0x0aa1, 0x2003 },
+  { 0x0aa2, 0x2002 },
+  { 0x0aa3, 0x2004 },
+  { 0x0aa4, 0x2005 },
+  { 0x0aa5, 0x2007 },
+  { 0x0aa6, 0x2008 },
+  { 0x0aa7, 0x2009 },
+  { 0x0aa8, 0x200a },
+  { 0x0aa9, 0x2014 },
+  { 0x0aaa, 0x2013 },
+  { 0x0aae, 0x2026 },
+  { 0x0aaf, 0x2025 },
+  { 0x0ab0, 0x2153 },
+  { 0x0ab1, 0x2154 },
+  { 0x0ab2, 0x2155 },
+  { 0x0ab3, 0x2156 },
+  { 0x0ab4, 0x2157 },
+  { 0x0ab5, 0x2158 },
+  { 0x0ab6, 0x2159 },
+  { 0x0ab7, 0x215a },
+  { 0x0ab8, 0x2105 },
+  { 0x0abb, 0x2012 },
+  { 0x0abc, 0x2329 },
+  { 0x0abe, 0x232a },
+  { 0x0ac3, 0x215b },
+  { 0x0ac4, 0x215c },
+  { 0x0ac5, 0x215d },
+  { 0x0ac6, 0x215e },
+  { 0x0ac9, 0x2122 },
+  { 0x0aca, 0x2613 },
+  { 0x0acc, 0x25c1 },
+  { 0x0acd, 0x25b7 },
+  { 0x0ace, 0x25cb },
+  { 0x0acf, 0x25af },
+  { 0x0ad0, 0x2018 },
+  { 0x0ad1, 0x2019 },
+  { 0x0ad2, 0x201c },
+  { 0x0ad3, 0x201d },
+  { 0x0ad4, 0x211e },
+  { 0x0ad6, 0x2032 },
+  { 0x0ad7, 0x2033 },
+  { 0x0ad9, 0x271d },
+  { 0x0adb, 0x25ac },
+  { 0x0adc, 0x25c0 },
+  { 0x0add, 0x25b6 },
+  { 0x0ade, 0x25cf },
+  { 0x0adf, 0x25ae },
+  { 0x0ae0, 0x25e6 },
+  { 0x0ae1, 0x25ab },
+  { 0x0ae2, 0x25ad },
+  { 0x0ae3, 0x25b3 },
+  { 0x0ae4, 0x25bd },
+  { 0x0ae5, 0x2606 },
+  { 0x0ae6, 0x2022 },
+  { 0x0ae7, 0x25aa },
+  { 0x0ae8, 0x25b2 },
+  { 0x0ae9, 0x25bc },
+  { 0x0aea, 0x261c },
+  { 0x0aeb, 0x261e },
+  { 0x0aec, 0x2663 },
+  { 0x0aed, 0x2666 },
+  { 0x0aee, 0x2665 },
+  { 0x0af0, 0x2720 },
+  { 0x0af1, 0x2020 },
+  { 0x0af2, 0x2021 },
+  { 0x0af3, 0x2713 },
+  { 0x0af4, 0x2717 },
+  { 0x0af5, 0x266f },
+  { 0x0af6, 0x266d },
+  { 0x0af7, 0x2642 },
+  { 0x0af8, 0x2640 },
+  { 0x0af9, 0x260e },
+  { 0x0afa, 0x2315 },
+  { 0x0afb, 0x2117 },
+  { 0x0afc, 0x2038 },
+  { 0x0afd, 0x201a },
+  { 0x0afe, 0x201e },
+  { 0x0ba3, 0x003c },
+  { 0x0ba6, 0x003e },
+  { 0x0ba8, 0x2228 },
+  { 0x0ba9, 0x2227 },
+  { 0x0bc0, 0x00af },
+  { 0x0bc2, 0x22a5 },
+  { 0x0bc3, 0x2229 },
+  { 0x0bc4, 0x230a },
+  { 0x0bc6, 0x005f },
+  { 0x0bca, 0x2218 },
+  { 0x0bcc, 0x2395 },
+  { 0x0bce, 0x22a4 },
+  { 0x0bcf, 0x25cb },
+  { 0x0bd3, 0x2308 },
+  { 0x0bd6, 0x222a },
+  { 0x0bd8, 0x2283 },
+  { 0x0bda, 0x2282 },
+  { 0x0bdc, 0x22a2 },
+  { 0x0bfc, 0x22a3 },
+  { 0x0cdf, 0x2017 },
+  { 0x0ce0, 0x05d0 },
+  { 0x0ce1, 0x05d1 },
+  { 0x0ce2, 0x05d2 },
+  { 0x0ce3, 0x05d3 },
+  { 0x0ce4, 0x05d4 },
+  { 0x0ce5, 0x05d5 },
+  { 0x0ce6, 0x05d6 },
+  { 0x0ce7, 0x05d7 },
+  { 0x0ce8, 0x05d8 },
+  { 0x0ce9, 0x05d9 },
+  { 0x0cea, 0x05da },
+  { 0x0ceb, 0x05db },
+  { 0x0cec, 0x05dc },
+  { 0x0ced, 0x05dd },
+  { 0x0cee, 0x05de },
+  { 0x0cef, 0x05df },
+  { 0x0cf0, 0x05e0 },
+  { 0x0cf1, 0x05e1 },
+  { 0x0cf2, 0x05e2 },
+  { 0x0cf3, 0x05e3 },
+  { 0x0cf4, 0x05e4 },
+  { 0x0cf5, 0x05e5 },
+  { 0x0cf6, 0x05e6 },
+  { 0x0cf7, 0x05e7 },
+  { 0x0cf8, 0x05e8 },
+  { 0x0cf9, 0x05e9 },
+  { 0x0cfa, 0x05ea },
+  { 0x0da1, 0x0e01 },
+  { 0x0da2, 0x0e02 },
+  { 0x0da3, 0x0e03 },
+  { 0x0da4, 0x0e04 },
+  { 0x0da5, 0x0e05 },
+  { 0x0da6, 0x0e06 },
+  { 0x0da7, 0x0e07 },
+  { 0x0da8, 0x0e08 },
+  { 0x0da9, 0x0e09 },
+  { 0x0daa, 0x0e0a },
+  { 0x0dab, 0x0e0b },
+  { 0x0dac, 0x0e0c },
+  { 0x0dad, 0x0e0d },
+  { 0x0dae, 0x0e0e },
+  { 0x0daf, 0x0e0f },
+  { 0x0db0, 0x0e10 },
+  { 0x0db1, 0x0e11 },
+  { 0x0db2, 0x0e12 },
+  { 0x0db3, 0x0e13 },
+  { 0x0db4, 0x0e14 },
+  { 0x0db5, 0x0e15 },
+  { 0x0db6, 0x0e16 },
+  { 0x0db7, 0x0e17 },
+  { 0x0db8, 0x0e18 },
+  { 0x0db9, 0x0e19 },
+  { 0x0dba, 0x0e1a },
+  { 0x0dbb, 0x0e1b },
+  { 0x0dbc, 0x0e1c },
+  { 0x0dbd, 0x0e1d },
+  { 0x0dbe, 0x0e1e },
+  { 0x0dbf, 0x0e1f },
+  { 0x0dc0, 0x0e20 },
+  { 0x0dc1, 0x0e21 },
+  { 0x0dc2, 0x0e22 },
+  { 0x0dc3, 0x0e23 },
+  { 0x0dc4, 0x0e24 },
+  { 0x0dc5, 0x0e25 },
+  { 0x0dc6, 0x0e26 },
+  { 0x0dc7, 0x0e27 },
+  { 0x0dc8, 0x0e28 },
+  { 0x0dc9, 0x0e29 },
+  { 0x0dca, 0x0e2a },
+  { 0x0dcb, 0x0e2b },
+  { 0x0dcc, 0x0e2c },
+  { 0x0dcd, 0x0e2d },
+  { 0x0dce, 0x0e2e },
+  { 0x0dcf, 0x0e2f },
+  { 0x0dd0, 0x0e30 },
+  { 0x0dd1, 0x0e31 },
+  { 0x0dd2, 0x0e32 },
+  { 0x0dd3, 0x0e33 },
+  { 0x0dd4, 0x0e34 },
+  { 0x0dd5, 0x0e35 },
+  { 0x0dd6, 0x0e36 },
+  { 0x0dd7, 0x0e37 },
+  { 0x0dd8, 0x0e38 },
+  { 0x0dd9, 0x0e39 },
+  { 0x0dda, 0x0e3a },
+  { 0x0ddf, 0x0e3f },
+  { 0x0de0, 0x0e40 },
+  { 0x0de1, 0x0e41 },
+  { 0x0de2, 0x0e42 },
+  { 0x0de3, 0x0e43 },
+  { 0x0de4, 0x0e44 },
+  { 0x0de5, 0x0e45 },
+  { 0x0de6, 0x0e46 },
+  { 0x0de7, 0x0e47 },
+  { 0x0de8, 0x0e48 },
+  { 0x0de9, 0x0e49 },
+  { 0x0dea, 0x0e4a },
+  { 0x0deb, 0x0e4b },
+  { 0x0dec, 0x0e4c },
+  { 0x0ded, 0x0e4d },
+  { 0x0df0, 0x0e50 },
+  { 0x0df1, 0x0e51 },
+  { 0x0df2, 0x0e52 },
+  { 0x0df3, 0x0e53 },
+  { 0x0df4, 0x0e54 },
+  { 0x0df5, 0x0e55 },
+  { 0x0df6, 0x0e56 },
+  { 0x0df7, 0x0e57 },
+  { 0x0df8, 0x0e58 },
+  { 0x0df9, 0x0e59 },
+  { 0x0ea1, 0x3131 },
+  { 0x0ea2, 0x3132 },
+  { 0x0ea3, 0x3133 },
+  { 0x0ea4, 0x3134 },
+  { 0x0ea5, 0x3135 },
+  { 0x0ea6, 0x3136 },
+  { 0x0ea7, 0x3137 },
+  { 0x0ea8, 0x3138 },
+  { 0x0ea9, 0x3139 },
+  { 0x0eaa, 0x313a },
+  { 0x0eab, 0x313b },
+  { 0x0eac, 0x313c },
+  { 0x0ead, 0x313d },
+  { 0x0eae, 0x313e },
+  { 0x0eaf, 0x313f },
+  { 0x0eb0, 0x3140 },
+  { 0x0eb1, 0x3141 },
+  { 0x0eb2, 0x3142 },
+  { 0x0eb3, 0x3143 },
+  { 0x0eb4, 0x3144 },
+  { 0x0eb5, 0x3145 },
+  { 0x0eb6, 0x3146 },
+  { 0x0eb7, 0x3147 },
+  { 0x0eb8, 0x3148 },
+  { 0x0eb9, 0x3149 },
+  { 0x0eba, 0x314a },
+  { 0x0ebb, 0x314b },
+  { 0x0ebc, 0x314c },
+  { 0x0ebd, 0x314d },
+  { 0x0ebe, 0x314e },
+  { 0x0ebf, 0x314f },
+  { 0x0ec0, 0x3150 },
+  { 0x0ec1, 0x3151 },
+  { 0x0ec2, 0x3152 },
+  { 0x0ec3, 0x3153 },
+  { 0x0ec4, 0x3154 },
+  { 0x0ec5, 0x3155 },
+  { 0x0ec6, 0x3156 },
+  { 0x0ec7, 0x3157 },
+  { 0x0ec8, 0x3158 },
+  { 0x0ec9, 0x3159 },
+  { 0x0eca, 0x315a },
+  { 0x0ecb, 0x315b },
+  { 0x0ecc, 0x315c },
+  { 0x0ecd, 0x315d },
+  { 0x0ece, 0x315e },
+  { 0x0ecf, 0x315f },
+  { 0x0ed0, 0x3160 },
+  { 0x0ed1, 0x3161 },
+  { 0x0ed2, 0x3162 },
+  { 0x0ed3, 0x3163 },
+  { 0x0ed4, 0x11a8 },
+  { 0x0ed5, 0x11a9 },
+  { 0x0ed6, 0x11aa },
+  { 0x0ed7, 0x11ab },
+  { 0x0ed8, 0x11ac },
+  { 0x0ed9, 0x11ad },
+  { 0x0eda, 0x11ae },
+  { 0x0edb, 0x11af },
+  { 0x0edc, 0x11b0 },
+  { 0x0edd, 0x11b1 },
+  { 0x0ede, 0x11b2 },
+  { 0x0edf, 0x11b3 },
+  { 0x0ee0, 0x11b4 },
+  { 0x0ee1, 0x11b5 },
+  { 0x0ee2, 0x11b6 },
+  { 0x0ee3, 0x11b7 },
+  { 0x0ee4, 0x11b8 },
+  { 0x0ee5, 0x11b9 },
+  { 0x0ee6, 0x11ba },
+  { 0x0ee7, 0x11bb },
+  { 0x0ee8, 0x11bc },
+  { 0x0ee9, 0x11bd },
+  { 0x0eea, 0x11be },
+  { 0x0eeb, 0x11bf },
+  { 0x0eec, 0x11c0 },
+  { 0x0eed, 0x11c1 },
+  { 0x0eee, 0x11c2 },
+  { 0x0eef, 0x316d },
+  { 0x0ef0, 0x3171 },
+  { 0x0ef1, 0x3178 },
+  { 0x0ef2, 0x317f },
+  { 0x0ef3, 0x3181 },
+  { 0x0ef4, 0x3184 },
+  { 0x0ef5, 0x3186 },
+  { 0x0ef6, 0x318d },
+  { 0x0ef7, 0x318e },
+  { 0x0ef8, 0x11eb },
+  { 0x0ef9, 0x11f0 },
+  { 0x0efa, 0x11f9 },
+  { 0x0eff, 0x20a9 },
+#if 0
+  /* FIXME: there is no keysym 0x13a4? But 0x20ac is EuroSign in both
+     keysym and Unicode */
+  { 0x13a4, 0x20ac },
+#endif
+  { 0x13bc, 0x0152 },
+  { 0x13bd, 0x0153 },
+  { 0x13be, 0x0178 },
+  { 0x20ac, 0x20ac },
+
+  /* Special function keys. */
+
+  { 0xff08, 0x0008 },			/* XK_BackSpace */
+  { 0xff09, 0x0009 },			/* XK_Tab */
+  { 0xff0a, 0x000a },			/* XK_Linefeed */
+  { 0xff0d, 0x000d },			/* XK_Return */
+  { 0xff13, 0x0013 },			/* XK_Pause */
+  { 0xff1b, 0x001b },			/* XK_Escape */
+  { 0xff50, 0x0001 },			/* XK_Home */
+  { 0xff51, 0x001c },			/* XK_Left */
+  { 0xff52, 0x001e },			/* XK_Up */
+  { 0xff53, 0x001d },			/* XK_Right */
+  { 0xff54, 0x001f },			/* XK_Down */
+  { 0xff55, 0x000b },			/* XK_Prior */
+  { 0xff56, 0x000c },			/* XK_Next */
+  { 0xff57, 0x0004 },			/* XK_End */
+  { 0xff6a, 0x0005 },			/* XK_Help */
+  { 0xffff, 0x007f },			/* XK_Delete */
+};
+
+long keysym2ucs(int keysym)
+{
+    int min = 0;
+    int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
+    int mid;
+
+    /* first check for Latin-1 characters (1:1 mapping) */
+    if ((keysym >= 0x0020 && keysym <= 0x007e) ||
+        (keysym >= 0x00a0 && keysym <= 0x00ff))
+        return keysym;
+
+    /* also check for directly encoded 24-bit UCS characters */
+    if ((keysym & 0xff000000) == 0x01000000)
+	return keysym & 0x00ffffff;
+
+    /* binary search in table */
+    while (max >= min) {
+	mid = (min + max) / 2;
+	if (keysymtab[mid].keysym < keysym)
+	    min = mid + 1;
+	else if (keysymtab[mid].keysym > keysym)
+	    max = mid - 1;
+	else {
+	    /* found it */
+	    return keysymtab[mid].ucs;
+	}
+    }
+
+    /* no matching Unicode value found */
+    return -1;
+}
+
+static int reverse_compare (const void *a, const void *b)
+{
+    const struct codepair *ca = a, *cb = b;
+
+    return ca->ucs - cb->ucs;
+}
+
+int ucs2keysym(long ucs)
+{
+    static struct codepair *reverse_keysymtab;
+
+    int min = 0;
+    int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
+    int mid;
+
+    if (reverse_keysymtab == NULL)
+    {
+	reverse_keysymtab = malloc (sizeof (keysymtab));
+	memcpy (reverse_keysymtab, keysymtab, sizeof (keysymtab));
+
+	qsort (reverse_keysymtab,
+	       sizeof (keysymtab) / sizeof (struct codepair),
+	       sizeof (struct codepair),
+	       reverse_compare);
+    }
+
+    /* first check for Latin-1 characters (1:1 mapping) */
+    if ((ucs >= 0x0020 && ucs <= 0x007e) ||
+        (ucs >= 0x00a0 && ucs <= 0x00ff))
+        return ucs;
+
+    /* binary search in table */
+    while (max >= min) {
+	mid = (min + max) / 2;
+	if (reverse_keysymtab[mid].ucs < ucs)
+	    min = mid + 1;
+	else if (reverse_keysymtab[mid].ucs > ucs)
+	    max = mid - 1;
+	else {
+	    /* found it */
+	    return reverse_keysymtab[mid].keysym;
+	}
+    }
+
+    /* finally, assume a directly encoded 24-bit UCS character */
+    return ucs | 0x01000000;
+}
diff --git a/hw/darwin/quartz/keysym2ucs.h b/hw/darwin/quartz/keysym2ucs.h
new file mode 100644
index 000000000..1d9183448
--- /dev/null
+++ b/hw/darwin/quartz/keysym2ucs.h
@@ -0,0 +1,37 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/keysym2ucs.h,v 1.1 2003/11/01 08:13:08 torrey Exp $
+ *
+ * This module converts keysym values into the corresponding ISO 10646
+ * (UCS, Unicode) values.
+ *
+ * The array keysymtab[] contains pairs of X11 keysym values for graphical
+ * characters and the corresponding Unicode value. The function
+ * keysym2ucs() maps a keysym onto a Unicode value using a binary search,
+ * therefore keysymtab[] must remain SORTED by keysym value.
+ *
+ * The keysym -> UTF-8 conversion will hopefully one day be provided
+ * by Xlib via XmbLookupString() and should ideally not have to be
+ * done in X applications. But we are not there yet.
+ *
+ * We allow to represent any UCS character in the range U-00000000 to
+ * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
+ * This admittedly does not cover the entire 31-bit space of UCS, but
+ * it does cover all of the characters up to U-10FFFF, which can be
+ * represented by UTF-16, and more, and it is very unlikely that higher
+ * UCS codes will ever be assigned by ISO. So to get Unicode character
+ * U+ABCD you can directly use keysym 0x0100abcd.
+ *
+ * Author: Markus G. Kuhn <mkuhn@acm.org>, University of Cambridge, April 2001
+ *
+ * Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing
+ * an initial draft of the mapping table.
+ *
+ * This software is in the public domain. Share and enjoy!
+ */
+
+#ifndef KEYSYM2UCS_H
+#define KEYSYM2UCS_H 1
+
+extern long keysym2ucs(int keysym);
+extern int ucs2keysym(long ucs);
+
+#endif /* KEYSYM2UCS_H */
diff --git a/hw/darwin/quartz/quartzKeyboard.c b/hw/darwin/quartz/quartzKeyboard.c
new file mode 100644
index 000000000..8d580830b
--- /dev/null
+++ b/hw/darwin/quartz/quartzKeyboard.c
@@ -0,0 +1,380 @@
+/*
+   quartzKeyboard.c
+   $Id$
+
+   Code to build a keymap using the Carbon Keyboard Layout API,
+   which is supported on Mac OS X 10.2 and newer.
+
+   Copyright (c) 2003 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/quartzKeyboard.c,v 1.1 2003/11/01 08:13:08 torrey Exp $ */
+
+#ifdef HAS_KL_API
+
+#include "quartzCommon.h"
+
+#include <CoreServices/CoreServices.h>
+#include <Carbon/Carbon.h>
+
+#include "darwinKeyboard.h"
+#include "keysym.h"
+#include "keysym2ucs.h"
+
+#define HACK_MISSING 1
+#define HACK_KEYPAD 1
+
+enum {
+    MOD_COMMAND = 256,
+    MOD_SHIFT = 512,
+    MOD_OPTION = 2048,
+    MOD_CONTROL = 4096,
+};
+
+#define UKEYSYM(u) ((u) | 0x01000000)
+
+/* Table of keycode->keysym mappings we use to fallback on for important
+   keys that are often not in the Unicode mapping. */
+
+const static struct {
+    unsigned short keycode;
+    KeySym keysym;
+} known_keys[] = {
+    {55,  XK_Meta_L},
+    {56,  XK_Shift_L},
+    {57,  XK_Caps_Lock},
+    {58,  XK_Alt_L},
+    {59,  XK_Control_L},
+    {60,  XK_Shift_R},
+    {61,  XK_Alt_R},
+    {62,  XK_Control_R},
+
+    {122, XK_F1},
+    {120, XK_F2},
+    {99,  XK_F3},
+    {118, XK_F4},
+    {96,  XK_F5},
+    {97,  XK_F6},
+    {98,  XK_F7},
+    {100, XK_F8},
+    {101, XK_F9},
+    {109, XK_F10},
+    {103, XK_F11},
+    {111, XK_F12},
+    {105, XK_F13},
+    {107, XK_F14},
+    {113, XK_F15},
+};
+
+/* Table of keycode->old,new-keysym mappings we use to fixup the numeric
+   keypad entries. */
+
+const static struct {
+    unsigned short keycode;
+    KeySym normal, keypad;
+} known_numeric_keys[] = {
+    {65, XK_period, XK_KP_Decimal},
+    {67, XK_asterisk, XK_KP_Multiply},
+    {69, XK_plus, XK_KP_Add},
+    {75, XK_slash, XK_KP_Divide},
+    {76, 0x01000003, XK_KP_Enter},
+    {78, XK_minus, XK_KP_Subtract},
+    {81, XK_equal, XK_KP_Equal},
+    {82, XK_0, XK_KP_0},
+    {83, XK_1, XK_KP_1},
+    {84, XK_2, XK_KP_2},
+    {85, XK_3, XK_KP_3},
+    {86, XK_4, XK_KP_4},
+    {87, XK_5, XK_KP_5},
+    {88, XK_6, XK_KP_6},
+    {89, XK_7, XK_KP_7},
+    {91, XK_8, XK_KP_8},
+    {92, XK_9, XK_KP_9},
+};
+
+/* Table mapping normal keysyms to their dead equivalents.
+   FIXME: all the unicode keysyms (apart from circumflex) were guessed. */
+
+const static struct {
+    KeySym normal, dead;
+} dead_keys[] = {
+    {XK_grave, XK_dead_grave},
+    {XK_acute, XK_dead_acute},
+    {XK_asciicircum, XK_dead_circumflex},
+    {UKEYSYM (0x2c6), XK_dead_circumflex},	/* MODIFIER LETTER CIRCUMFLEX ACCENT */
+    {XK_asciitilde, XK_dead_tilde},
+    {UKEYSYM (0x2dc), XK_dead_tilde},		/* SMALL TILDE */
+    {XK_macron, XK_dead_macron},
+    {XK_breve, XK_dead_breve},
+    {XK_abovedot, XK_dead_abovedot},
+    {XK_diaeresis, XK_dead_diaeresis},
+    {UKEYSYM (0x2da), XK_dead_abovering},	/* DOT ABOVE */
+    {XK_doubleacute, XK_dead_doubleacute},
+    {XK_caron, XK_dead_caron},
+    {XK_cedilla, XK_dead_cedilla},
+    {XK_ogonek, XK_dead_ogonek},
+    {UKEYSYM (0x269), XK_dead_iota},		/* LATIN SMALL LETTER IOTA */
+    {UKEYSYM (0x2ec), XK_dead_voiced_sound},	/* MODIFIER LETTER VOICING */
+/*  {XK_semivoiced_sound, XK_dead_semivoiced_sound}, */
+    {UKEYSYM (0x323), XK_dead_belowdot},	/* COMBINING DOT BELOW */
+    {UKEYSYM (0x309), XK_dead_hook}, 		/* COMBINING HOOK ABOVE */
+    {UKEYSYM (0x31b), XK_dead_horn},		/* COMBINING HORN */
+};
+
+unsigned int
+DarwinSystemKeymapSeed (void)
+{
+    static unsigned int seed;
+
+    static KeyboardLayoutRef last_key_layout;
+    KeyboardLayoutRef key_layout;
+
+    KLGetCurrentKeyboardLayout (&key_layout);
+
+    if (key_layout != last_key_layout)
+        seed++;
+
+    last_key_layout = key_layout;
+
+    return seed;
+}
+
+static inline UniChar
+macroman2ucs (unsigned char c)
+{
+    /* Precalculated table mapping MacRoman-128 to Unicode. Generated
+       by creating single element CFStringRefs then extracting the
+       first character. */
+
+    static const unsigned short table[128] = {
+        0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,
+        0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,
+        0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,
+        0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,
+        0x2020, 0xb0, 0xa2, 0xa3, 0xa7, 0x2022, 0xb6, 0xdf,
+        0xae, 0xa9, 0x2122, 0xb4, 0xa8, 0x2260, 0xc6, 0xd8,
+        0x221e, 0xb1, 0x2264, 0x2265, 0xa5, 0xb5, 0x2202, 0x2211,
+        0x220f, 0x3c0, 0x222b, 0xaa, 0xba, 0x3a9, 0xe6, 0xf8,
+        0xbf, 0xa1, 0xac, 0x221a, 0x192, 0x2248, 0x2206, 0xab,
+        0xbb, 0x2026, 0xa0, 0xc0, 0xc3, 0xd5, 0x152, 0x153,
+        0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0xf7, 0x25ca,
+        0xff, 0x178, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,
+        0x2021, 0xb7, 0x201a, 0x201e, 0x2030, 0xc2, 0xca, 0xc1,
+        0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,
+        0xf8ff, 0xd2, 0xda, 0xdb, 0xd9, 0x131, 0x2c6, 0x2dc,
+        0xaf, 0x2d8, 0x2d9, 0x2da, 0xb8, 0x2dd, 0x2db, 0x2c7,
+    };
+
+    if (c < 128)
+        return c;
+    else
+        return table[c - 128];
+}
+
+static KeySym
+make_dead_key (KeySym in)
+{
+    int i;
+
+    for (i = 0; i < sizeof (dead_keys) / sizeof (dead_keys[0]); i++)
+    {
+        if (dead_keys[i].normal == in)
+            return dead_keys[i].dead;
+    }
+
+    return in;
+}
+
+Bool
+DarwinModeReadSystemKeymap (darwinKeyboardInfo *info)
+{
+    KeyboardLayoutRef key_layout;
+    const void *chr_data;
+    int num_keycodes = NUM_KEYCODES;
+    UInt32 keyboard_type = 0;
+    int is_uchr, i, j;
+    OSStatus err;
+    KeySym *k;
+
+    KLGetCurrentKeyboardLayout (&key_layout);
+    KLGetKeyboardLayoutProperty (key_layout, kKLuchrData, &chr_data);
+
+    if (chr_data != NULL)
+    {
+        is_uchr = 1;
+        keyboard_type = LMGetKbdType ();
+    }
+    else
+    {
+        KLGetKeyboardLayoutProperty (key_layout, kKLKCHRData, &chr_data);
+
+        if (chr_data == NULL)
+        {
+            ErrorF ( "Couldn't get uchr or kchr resource\n");
+            return FALSE;
+        }
+
+        is_uchr = 0;
+        num_keycodes = 128;
+    }    
+
+
+    /* Scan the keycode range for the Unicode character that each
+       key produces in the four shift states. Then convert that to
+       an X11 keysym (which may just the bit that says "this is
+       Unicode" if it can't find the real symbol.) */
+
+    for (i = 0; i < num_keycodes; i++)
+    {
+        static const int mods[4] = {0, MOD_SHIFT, MOD_OPTION,
+                                    MOD_OPTION | MOD_SHIFT};
+
+        k = info->keyMap + i * GLYPHS_PER_KEY;
+
+        for (j = 0; j < 4; j++)
+        {
+            if (is_uchr)
+            {
+                UniChar s[8];
+                UniCharCount len;
+                UInt32 dead_key_state, extra_dead;
+
+                dead_key_state = 0;
+                err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,
+                                      mods[j] >> 8, keyboard_type, 0,
+                                      &dead_key_state, 8, &len, s);
+                if (err != noErr)
+                    continue;
+
+                if (len == 0 && dead_key_state != 0)
+                {
+                    /* Found a dead key. Work out which one it is, but
+                       remembering that it's dead. */
+
+                    extra_dead = 0;
+                    err = UCKeyTranslate (chr_data, i, kUCKeyActionDown,
+                                          mods[j] >> 8, keyboard_type,
+                                          kUCKeyTranslateNoDeadKeysMask,
+                                          &extra_dead, 8, &len, s);
+                    if (err != noErr)
+                        continue;
+                }
+
+                if (len > 0 && s[0] != 0x0010)
+                {
+                    k[j] = ucs2keysym (s[0]);
+    
+                    if (dead_key_state != 0)
+                        k[j] = make_dead_key (k[j]);
+                }
+            }
+            else
+            {
+                UInt32 c, state = 0;
+                UInt16 code;
+
+                code = i | mods[j];
+                c = KeyTranslate (chr_data, code, &state);
+
+                /* Dead keys are only processed on key-down, so ask
+                   to translate those events. When we find a dead key,
+                   translating the matching key up event will give
+                   us the actual dead character. */
+
+                if (state != 0)
+                {
+                    UInt32 state2 = 0;
+                    c = KeyTranslate (chr_data, code | 128, &state2);
+                }
+
+                /* Characters seem to be in MacRoman encoding. */
+
+                if (c != 0 && c != 0x0010)
+                {
+                    k[j] = ucs2keysym (macroman2ucs (c & 255));
+
+                    if (state != 0)
+                        k[j] = make_dead_key (k[j]);
+                }
+            }
+        }
+
+        if (k[3] == k[2])
+            k[3] = NoSymbol;
+        if (k[2] == k[1])
+            k[2] = NoSymbol;
+        if (k[1] == k[0])
+            k[1] = NoSymbol;
+        if (k[0] == k[2] && k[1] == k[3])
+            k[2] = k[3] = NoSymbol;
+    }
+
+    /* Fix up some things that are normally missing.. */
+
+    if (HACK_MISSING)
+    {
+        for (i = 0; i < sizeof (known_keys) / sizeof (known_keys[0]); i++)
+        {
+            k = info->keyMap + known_keys[i].keycode * GLYPHS_PER_KEY;
+
+            if (k[0] == NoSymbol && k[1] == NoSymbol
+                && k[2] == NoSymbol && k[3] == NoSymbol)
+            {
+                k[0] = known_keys[i].keysym;
+            }
+        }
+    }
+
+    /* And some more things. We find the right symbols for the numeric
+       keypad, but not the KP_ keysyms. So try to convert known keycodes. */
+
+    if (HACK_KEYPAD)
+    {
+        for (i = 0; i < sizeof (known_numeric_keys)
+                        / sizeof (known_numeric_keys[0]); i++)
+        {
+            k = info->keyMap + known_numeric_keys[i].keycode * GLYPHS_PER_KEY;
+
+            if (k[0] == known_numeric_keys[i].normal)
+            {
+                k[0] = known_numeric_keys[i].keypad;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+#else /* !HAS_KL_API */
+
+Bool
+DarwinModeReadSystemKeymap (darwinKeyboardInfo *info)
+{
+    return FALSE;
+}
+
+#endif /* HAS_KL_API */
diff --git a/hw/darwin/quartz/xpr/Xplugin.h b/hw/darwin/quartz/xpr/Xplugin.h
new file mode 100644
index 000000000..8985f7b11
--- /dev/null
+++ b/hw/darwin/quartz/xpr/Xplugin.h
@@ -0,0 +1,591 @@
+/* Xplugin.h -- windowing API for rootless X11 server
+   $Id$
+
+   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.
+
+   Note that these interfaces are provided solely for the use of the
+   X11 server. Any other uses are unsupported and strongly discouraged. */
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/xpr/Xplugin.h,v 1.3 2003/06/27 20:21:42 torrey Exp $ */
+
+#ifndef XPLUGIN_H
+#define XPLUGIN_H 1
+
+#include <stdint.h>
+
+/* By default we use the X server definition of BoxRec to define xp_box,
+   so that the compiler can silently convert between the two. But if
+   XP_NO_X_HEADERS is defined, we'll define it ourselves. */
+
+#ifndef XP_NO_X_HEADERS
+# include "miscstruct.h"
+  typedef BoxRec xp_box;
+#else
+  struct xp_box_struct {
+      short x1, y1, x2, y2;
+  };
+  typedef struct xp_box_struct xp_box;
+#endif
+
+typedef unsigned int xp_resource_id;
+typedef xp_resource_id xp_window_id;
+typedef xp_resource_id xp_surface_id;
+typedef unsigned int xp_client_id;
+typedef unsigned int xp_request_type;
+typedef int xp_error;
+typedef int xp_bool;
+
+
+/* Error codes that the functions declared here may return. They all
+   numerically match their X equivalents, i.e. the XP_ can be dropped
+   if <X11/X.h> has been included. */
+
+enum xp_error_enum {
+    XP_Success			= 0,
+    XP_BadRequest		= 1,
+    XP_BadValue			= 2,
+    XP_BadWindow		= 3,
+    XP_BadMatch			= 8,
+    XP_BadAccess		= 10,
+    XP_BadImplementation	= 17,
+};    
+
+
+/* Event types generated by the plugin. */
+
+enum xp_event_type_enum {
+    /* The global display configuration changed somehow. */
+    XP_EVENT_DISPLAY_CHANGED	= 1 << 0,
+
+    /* A window changed state. Argument is xp_window_state_event */
+    XP_EVENT_WINDOW_STATE_CHANGED = 1 << 1,
+
+    /* An async request encountered an error. Argument is of type
+       xp_async_error_event */
+    XP_EVENT_ASYNC_ERROR	= 1 << 2,
+
+    /* Sent when a surface is destroyed as a side effect of destroying
+       a window. Arg is of type xp_surface_id. */
+    XP_EVENT_SURFACE_DESTROYED	= 1 << 3,
+
+    /* Sent when any GL contexts pointing at the given surface need to
+       call xp_update_gl_context () to refresh their state (because the
+       window moved or was resized. Arg is of type xp_surface_id. */
+    XP_EVENT_SURFACE_CHANGED	= 1 << 4,
+
+    /* Sent when a window has been moved. Arg is of type xp_window_id. */
+    XP_EVENT_WINDOW_MOVED	= 1 << 5,
+};
+
+/* Function type used to receive events. */
+
+typedef void (xp_event_fun) (unsigned int type, const void *arg,
+			     unsigned int arg_size, void *user_data);
+
+
+/* Operation types. Used when reporting errors asynchronously. */
+
+enum xp_request_type_enum {
+    XP_REQUEST_NIL = 0,
+    XP_REQUEST_DESTROY_WINDOW = 1,
+    XP_REQUEST_CONFIGURE_WINDOW = 2,
+    XP_REQUEST_FLUSH_WINDOW = 3,
+    XP_REQUEST_COPY_WINDOW = 4,
+    XP_REQUEST_UNLOCK_WINDOW = 5,
+    XP_REQUEST_DISABLE_UPDATE = 6,
+    XP_REQUEST_REENABLE_UPDATE = 7,
+    XP_REQUEST_HIDE_CURSOR = 8,
+    XP_REQUEST_SHOW_CURSOR = 9,
+    XP_REQUEST_FRAME_DRAW = 10,
+};
+
+/* Structure used to report an error asynchronously. Passed as the "arg"
+   of an XP_EVENT_ASYNC_ERROR event. */
+
+struct xp_async_error_event_struct {
+    xp_request_type request_type;
+    xp_resource_id id;
+    xp_error error;
+};
+
+typedef struct xp_async_error_event_struct xp_async_error_event;
+
+
+/* Possible window states. */
+
+enum xp_window_state_enum {
+    /* The window is not in the global list of possibly-visible windows. */
+    XP_WINDOW_STATE_OFFSCREEN	= 1 << 0,
+
+    /* Parts of the window may be obscured by other windows. */
+    XP_WINDOW_STATE_OBSCURED	= 1 << 1,
+};
+
+/* Structure passed as argument of an XP_EVENT_WINDOW_STATE_CHANGED event. */
+
+struct xp_window_state_event_struct {
+    xp_window_id id;
+    unsigned int state;
+};
+
+typedef struct xp_window_state_event_struct xp_window_state_event;
+
+
+/* Function type used to supply a colormap for indexed drawables. */
+
+typedef xp_error (xp_colormap_fun) (void *data, int first_color,
+				    int n_colors, uint32_t *colors);
+
+
+/* Window attributes structure. Used when creating and configuring windows.
+   Also used when configuring surfaces attached to windows. Functions that
+   take one of these structures also take a bit mask defining which
+   fields are set to meaningful values. */
+
+enum xp_window_changes_enum {
+    XP_ORIGIN			= 1 << 0,
+    XP_SIZE			= 1 << 1,
+    XP_BOUNDS			= XP_ORIGIN | XP_SIZE,
+    XP_SHAPE			= 1 << 2,
+    XP_STACKING			= 1 << 3,
+    XP_DEPTH			= 1 << 4,
+    XP_COLORMAP			= 1 << 5,
+    XP_WINDOW_LEVEL		= 1 << 6,
+};
+
+struct xp_window_changes_struct {
+    /* XP_ORIGIN */
+    int x, y;
+
+    /* XP_SIZE */
+    unsigned int width, height;
+    int bit_gravity;			/* how to resize the backing store */
+
+    /* XP_SHAPE */
+    int shape_nrects;			/* -1 = remove shape */
+    xp_box *shape_rects;
+    int shape_tx, shape_ty;		/* translation for shape */
+
+    /* XP_STACKING */
+    int stack_mode;
+    xp_window_id sibling;		/* may be zero; in ABOVE/BELOW modes
+					   it may specify a relative window */
+    /* XP_DEPTH, window-only */
+    unsigned int depth;
+
+    /* XP_COLORMAP, window-only */
+    xp_colormap_fun *colormap;
+    void *colormap_data;
+
+    /* XP_WINDOW_LEVEL, window-only */
+    int window_level;
+};
+
+typedef struct xp_window_changes_struct xp_window_changes;
+
+/* Values for bit_gravity field */
+
+enum xp_bit_gravity_enum {
+    XP_GRAVITY_NONE		= 0,	/* no gravity, fill everything */
+    XP_GRAVITY_NORTH_WEST	= 1,	/* anchor to top-left corner */
+    XP_GRAVITY_NORTH_EAST	= 2,	/* anchor to top-right corner */
+    XP_GRAVITY_SOUTH_EAST	= 3,	/* anchor to bottom-right corner */
+    XP_GRAVITY_SOUTH_WEST	= 4,	/* anchor to bottom-left corner */
+};
+
+/* Values for stack_mode field */
+
+enum xp_window_stack_mode_enum {
+    XP_UNMAPPED			= 0,	/* remove the window */
+    XP_MAPPED_ABOVE		= 1,	/* display the window on top */
+    XP_MAPPED_BELOW		= 2,	/* display the window at bottom */
+};
+
+/* Data formats for depth field and composite functions */
+
+enum xp_depth_enum {
+    XP_DEPTH_NIL = 0,			/* null source when compositing */
+    XP_DEPTH_ARGB8888,
+    XP_DEPTH_RGB555,
+    XP_DEPTH_A8,			/* for masks when compositing */
+    XP_DEPTH_INDEX8,
+};
+
+/* Options that may be passed to the xp_init () function. */
+
+enum xp_init_options_enum {
+    /* Don't mark that this process can be in the foreground. */
+    XP_IN_BACKGROUND		= 1 << 0,
+
+    /* Deliver background pointer events to this process. */
+    XP_BACKGROUND_EVENTS	= 1 << 1,
+};
+
+
+
+/* Miscellaneous functions */
+
+/* Initialize the plugin library. Only the copy/fill/composite functions
+   may be called without having previously called xp_init () */
+
+extern xp_error xp_init (unsigned int options);
+
+/* Sets the current set of requested notifications to MASK. When any of
+   these arrive, CALLBACK will be invoked with CALLBACK-DATA. Note that
+   calling this function cancels any previously requested notifications
+   that aren't set in MASK. */
+
+extern xp_error xp_select_events (unsigned int mask,
+				  xp_event_fun *callback,
+				  void *callback_data);
+
+/* Waits for all initiated operations to complete. */
+
+extern xp_error xp_synchronize (void);
+
+/* Causes any display update initiated through the plugin libary to be
+   queued until update is reenabled. Note that calls to these functions
+   nest. */
+  
+extern xp_error xp_disable_update (void);
+extern xp_error xp_reenable_update (void);
+
+
+
+/* Cursor functions. */
+
+/* Installs the specified cursor. ARGB-DATA should point to 32-bit
+   premultiplied big-endian ARGB data. The HOT-X,HOT-Y parameters
+   specify the offset to the cursor's hot spot from its top-left
+   corner. */
+
+extern xp_error xp_set_cursor (unsigned int width, unsigned int height,
+			       unsigned int hot_x, unsigned int hot_y,
+			       const uint32_t *argb_data,
+			       unsigned int rowbytes);
+
+/* Hide and show the cursor if it's owned by the current process. Calls
+   to these functions nest. */
+
+extern xp_error xp_hide_cursor (void);
+extern xp_error xp_show_cursor (void);
+
+
+
+/* Window functions. */
+
+/* Create a new window as defined by MASK and VALUES. MASK must contain
+   XP_BOUNDS or an error is raised. The id of the newly created window
+   is stored in *RET-ID if this function returns XP_Success. */
+
+extern xp_error xp_create_window (unsigned int mask,
+				  const xp_window_changes *values,
+				  xp_window_id *ret_id);
+
+/* Destroys the window identified by ID. */
+
+extern xp_error xp_destroy_window (xp_window_id id);
+
+/* Reconfigures the given window according to MASK and VALUES. */
+
+extern xp_error xp_configure_window (xp_window_id id, unsigned int mask,
+				     const xp_window_changes *values);
+
+
+/* Returns true if NATIVE-ID is a window created by the plugin library.
+   If so and RET-ID is non-null, stores the id of the window in *RET-ID. */
+
+extern xp_bool xp_lookup_native_window (unsigned int native_id,
+					xp_window_id *ret_id);
+
+/* If ID names a window created by the plugin library, stores it's native
+   window id in *RET-NATIVE-ID. */
+
+extern xp_error xp_get_native_window (xp_window_id id,
+				      unsigned int *ret_native_id);
+
+
+/* Locks the rectangle IN-RECT (or, if null, the entire window) of the
+   given window's backing store. Any other non-null parameters are filled
+   in as follows:
+
+   DEPTH = format of returned data. Currently either XP_DEPTH_ARGB8888
+   or XP_DEPTH_RGB565 (possibly with 8 bit planar alpha). Data is
+   always stored in native byte order.
+
+   BITS[0] = pointer to top-left pixel of locked color data
+   BITS[1] = pointer to top-left of locked alpha data, or null if window
+   has no alpha. If the alpha data is meshed, then BITS[1] = BITS[0].
+
+   ROWBYTES[0,1] = size in bytes of each row of color,alpha data
+
+   OUT-RECT = rectangle specifying the current position and size of the
+   locked region relative to the window origin.
+
+   Note that an error is raised when trying to lock an already locked
+   window. While the window is locked, the only operations that may
+   be performed on it are to modify, access or flush its marked region. */
+
+extern xp_error xp_lock_window (xp_window_id id,
+				const xp_box *in_rect,
+				unsigned int *depth,
+				void *bits[2],
+				unsigned int rowbytes[2],
+				xp_box *out_rect);
+
+/* Mark that the region specified by SHAPE-NRECTS, SHAPE-RECTS,
+   SHAPE-TX, and SHAPE-TY in the specified window has been updated, and
+   will need to subsequently be redisplayed. */
+
+extern xp_error xp_mark_window (xp_window_id id, int shape_nrects,
+				const xp_box *shape_rects,
+				int shape_tx, int shape_ty);
+
+/* Unlocks the specified window. If FLUSH is true, then any marked
+   regions are immediately redisplayed. Note that it's an error to
+   unlock an already unlocked window. */
+
+extern xp_error xp_unlock_window (xp_window_id id, xp_bool flush);
+
+/* If anything is marked in the given window for redisplay, do it now. */
+
+extern xp_error xp_flush_window (xp_window_id id);
+
+/* Moves the contents of the region DX,DY pixels away from that specified
+   by DST_RECTS and DST_NRECTS in the window with SRC-ID to the
+   destination region in the window DST-ID. Note that currently source
+   and destination windows must be the same. */
+
+extern xp_error xp_copy_window (xp_window_id src_id, xp_window_id dst_id,
+				int dst_nrects, const xp_box *dst_rects,
+				int dx, int dy);
+
+/* Returns true if the given window has any regions marked for
+   redisplay. */
+
+extern xp_bool xp_is_window_marked (xp_window_id id);
+
+/* If successful returns a superset of the region marked for update in
+   the given window. Use xp_free_region () to release the returned data. */
+
+extern xp_error xp_get_marked_shape (xp_window_id id,
+				     int *ret_nrects, xp_box **ret_rects);
+
+extern void xp_free_shape (int nrects, xp_box *rects);
+
+/* Searches for the first window below ABOVE-ID containing the point X,Y,
+   and returns it's window id in *RET-ID. If no window is found, *RET-ID
+   is set to zero. If ABOVE-ID is zero, finds the topmost window
+   containing the given point. */
+
+extern xp_error xp_find_window (int x, int y, xp_window_id above_id,
+				xp_window_id *ret_id);
+
+/* Returns the current origin and size of the window ID in *BOUNDS-RET if
+   successful. */
+extern xp_error xp_get_window_bounds (xp_window_id id, xp_box *bounds_ret);
+
+
+
+/* Window surface functions. */
+
+/* Create a new VRAM surface on the specified window. If successful,
+   returns the identifier of the new surface in *RET-SID. */
+
+extern xp_error xp_create_surface (xp_window_id id, xp_surface_id *ret_sid);
+
+/* Destroys the specified surface. */
+
+extern xp_error xp_destroy_surface (xp_surface_id sid);
+
+/* Reconfigures the specified surface as defined by MASK and VALUES.
+   Note that specifying XP_DEPTH is an error. */
+
+extern xp_error xp_configure_surface (xp_surface_id sid, unsigned int mask,
+				      const xp_window_changes *values);
+
+/* If successful, places the client identifier of the current process
+   in *RET-CLIENT. */
+
+extern xp_error xp_get_client_id (xp_client_id *ret_client);
+
+/* Given a valid window,surface combination created by the current
+   process, attempts to allow the specified external client access
+   to that surface. If successful, returns two integers in RET-KEY
+   which the client can use to import the surface into their process. */
+
+extern xp_error xp_export_surface (xp_window_id wid, xp_surface_id sid,
+				   xp_client_id client,
+				   unsigned int ret_key[2]);
+
+/* Given a two integer key returned from xp_export_surface (), tries
+   to import the surface into the current process. If successful the
+   local surface identifier is stored in *SID-RET. */
+
+extern xp_error xp_import_surface (const unsigned int key[2],
+				   xp_surface_id *sid_ret);
+
+/* If successful, stores the number of surfaces attached to the
+   specified window in *RET. */
+
+extern xp_error xp_get_window_surface_count (xp_window_id id,
+					     unsigned int *ret);
+
+/* Attaches the CGLContextObj CGL-CTX to the specified surface. */
+
+extern xp_error xp_attach_gl_context (void *cgl_ctx, xp_surface_id sid);
+
+/* Updates the CGLContextObj CGL-CTX to reflect any recent changes to
+   the surface it's attached to. */
+
+extern xp_error xp_update_gl_context (void *cgl_ctx);
+
+
+
+/* Window frame functions. */
+
+/* Possible arguments to xp_frame_get_rect (). */
+
+enum xp_frame_rect_enum {
+    XP_FRAME_RECT_TITLEBAR		= 1,
+    XP_FRAME_RECT_TRACKING		= 2,
+    XP_FRAME_RECT_GROWBOX		= 3,
+};
+
+/* Classes of window frame. */
+
+enum xp_frame_class_enum {
+    XP_FRAME_CLASS_DOCUMENT		= 1 << 0,
+    XP_FRAME_CLASS_DIALOG		= 1 << 1,
+    XP_FRAME_CLASS_MODAL_DIALOG		= 1 << 2,
+    XP_FRAME_CLASS_SYSTEM_MODAL_DIALOG	= 1 << 3,
+    XP_FRAME_CLASS_UTILITY		= 1 << 4,
+    XP_FRAME_CLASS_TOOLBAR		= 1 << 5,
+    XP_FRAME_CLASS_MENU			= 1 << 6,
+    XP_FRAME_CLASS_SPLASH		= 1 << 7,
+    XP_FRAME_CLASS_BORDERLESS		= 1 << 8,
+};
+
+/* Attributes of window frames. */
+
+enum xp_frame_attr_enum {
+    XP_FRAME_ACTIVE			= 0x0001,
+    XP_FRAME_URGENT			= 0x0002,
+    XP_FRAME_TITLE			= 0x0004,
+    XP_FRAME_PRELIGHT			= 0x0008,
+    XP_FRAME_SHADED			= 0x0010,
+    XP_FRAME_CLOSE_BOX			= 0x0100,
+    XP_FRAME_COLLAPSE			= 0x0200,
+    XP_FRAME_ZOOM			= 0x0400,
+    XP_FRAME_ANY_BUTTON			= 0x0700,
+    XP_FRAME_CLOSE_BOX_CLICKED		= 0x0800,
+    XP_FRAME_COLLAPSE_BOX_CLICKED	= 0x1000,
+    XP_FRAME_ZOOM_BOX_CLICKED		= 0x2000,
+    XP_FRAME_ANY_CLICKED		= 0x3800,
+    XP_FRAME_GROW_BOX			= 0x4000,
+};
+
+#define XP_FRAME_ATTR_IS_SET(a,b)	(((a) & (b)) == (b))
+#define XP_FRAME_ATTR_IS_CLICKED(a,m)	((a) & ((m) << 3))
+#define XP_FRAME_ATTR_SET_CLICKED(a,m)	((a) |= ((m) << 3))
+#define XP_FRAME_ATTR_UNSET_CLICKED(a,m) ((a) &= ~((m) << 3))
+
+#define XP_FRAME_POINTER_ATTRS		(XP_FRAME_PRELIGHT		\
+					 | XP_FRAME_ANY_BUTTON		\
+					 | XP_FRAME_ANY_CLICKED)
+
+extern xp_error xp_frame_get_rect (int type, int class, const xp_box *outer,
+				   const xp_box *inner, xp_box *ret);
+extern xp_error xp_frame_hit_test (int class, int x, int y,
+				   const xp_box *outer,
+				   const xp_box *inner, int *ret);
+extern xp_error xp_frame_draw (xp_window_id wid, int class, unsigned int attr,
+			       const xp_box *outer, const xp_box *inner,
+			       unsigned int title_len,
+			       const unsigned char *title_bytes);
+
+
+
+/* Memory manipulation functions. */
+
+enum xp_composite_op_enum {
+    XP_COMPOSITE_SRC = 0,
+    XP_COMPOSITE_OVER,
+};
+
+#define XP_COMPOSITE_FUNCTION(op, src_depth, mask_depth, dest_depth) \
+    (((op) << 24) | ((src_depth) << 16) \
+     | ((mask_depth) << 8) | ((dest_depth) << 0))
+
+#define XP_COMPOSITE_FUNCTION_OP(f)         (((f) >> 24) & 255)
+#define XP_COMPOSITE_FUNCTION_SRC_DEPTH(f)  (((f) >> 16) & 255)
+#define XP_COMPOSITE_FUNCTION_MASK_DEPTH(f) (((f) >>  8) & 255)
+#define XP_COMPOSITE_FUNCTION_DEST_DEPTH(f) (((f) >>  0) & 255)
+
+/* Composite WIDTH by HEIGHT pixels from source and mask to destination
+   using a specified function (if source and destination overlap,
+   undefined behavior results).
+
+   For SRC and DEST, the first element of the array is the color data. If
+   the second element is non-null it implies that there is alpha data
+   (which may be meshed or planar). Data without alpha is assumed to be
+   opaque.
+
+   Passing a null SRC-ROWBYTES pointer implies that the data SRC points
+   to is a single element.
+
+   Operations that are not supported will return XP_BadImplementation. */
+
+extern xp_error xp_composite_pixels (unsigned int width, unsigned int height,
+				     unsigned int function,
+				     void *src[2], unsigned int src_rowbytes[2],
+				     void *mask, unsigned int mask_rowbytes,
+				     void *dest[2], unsigned int dest_rowbytes[2]);
+
+/* Fill HEIGHT rows of data starting at DST. Each row will have WIDTH
+   bytes filled with the 32-bit pattern VALUE. Each row is DST-ROWBYTES
+   wide in total. */
+
+extern void xp_fill_bytes (unsigned int width,
+			   unsigned int height, uint32_t value,
+			   void *dst, unsigned int dst_rowbytes);
+
+/* Copy HEIGHT rows of bytes from SRC to DST. Each row will have WIDTH
+   bytes copied. SRC and DST may overlap, and the right thing will happen. */
+
+extern void xp_copy_bytes (unsigned int width, unsigned int height,
+			   const void *src, unsigned int src_rowbytes,
+			   void *dst, unsigned int dst_rowbytes);
+
+/* Suggestions for the minimum number of bytes or pixels for which it
+   makes sense to use some of the xp_ functions */
+
+extern unsigned int xp_fill_bytes_threshold, xp_copy_bytes_threshold,
+    xp_composite_area_threshold, xp_scroll_area_threshold;
+
+
+#endif /* XPLUGIN_H */
diff --git a/hw/darwin/quartz/xpr/appledri.c b/hw/darwin/quartz/xpr/appledri.c
new file mode 100644
index 000000000..3062d964a
--- /dev/null
+++ b/hw/darwin/quartz/xpr/appledri.c
@@ -0,0 +1,350 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/xpr/appledri.c,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@valinux.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "misc.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "colormapst.h"
+#include "cursorstr.h"
+#include "scrnintstr.h"
+#include "servermd.h"
+#define _APPLEDRI_SERVER_
+#include "appledristr.h"
+#include "swaprep.h"
+#include "dri.h"
+#include "dristruct.h"
+
+static int DRIErrorBase = 0;
+
+static DISPATCH_PROC(ProcAppleDRIDispatch);
+static DISPATCH_PROC(SProcAppleDRIDispatch);
+
+static void AppleDRIResetProc(ExtensionEntry* extEntry);
+
+static unsigned char DRIReqCode = 0;
+static int DRIEventBase = 0;
+
+static void SNotifyEvent(xAppleDRINotifyEvent *from, xAppleDRINotifyEvent *to);
+
+typedef struct _DRIEvent *DRIEventPtr;
+typedef struct _DRIEvent {
+    DRIEventPtr     next;
+    ClientPtr       client;
+    XID             clientResource;
+    unsigned int    mask;
+} DRIEventRec;
+
+
+void
+AppleDRIExtensionInit(void)
+{
+    ExtensionEntry* extEntry;
+
+    if (DRIExtensionInit() &&
+        (extEntry = AddExtension(APPLEDRINAME,
+                                 AppleDRINumberEvents,
+                                 AppleDRINumberErrors,
+                                 ProcAppleDRIDispatch,
+                                 SProcAppleDRIDispatch,
+                                 AppleDRIResetProc,
+                                 StandardMinorOpcode))) {
+        DRIReqCode = (unsigned char)extEntry->base;
+        DRIErrorBase = extEntry->errorBase;
+        DRIEventBase = extEntry->eventBase;
+        EventSwapVector[DRIEventBase] = (EventSwapPtr) SNotifyEvent;
+    }
+}
+
+/*ARGSUSED*/
+static void
+AppleDRIResetProc (
+    ExtensionEntry* extEntry
+)
+{
+    DRIReset();
+}
+
+static int
+ProcAppleDRIQueryVersion(
+    register ClientPtr client
+)
+{
+    xAppleDRIQueryVersionReply rep;
+    register int n;
+
+    REQUEST_SIZE_MATCH(xAppleDRIQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = APPLE_DRI_MAJOR_VERSION;
+    rep.minorVersion = APPLE_DRI_MINOR_VERSION;
+    rep.patchVersion = APPLE_DRI_PATCH_VERSION;
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber, n);
+        swapl(&rep.length, n);
+    }
+    WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+
+/* surfaces */
+
+static int
+ProcAppleDRIQueryDirectRenderingCapable(
+    register ClientPtr client
+)
+{
+    xAppleDRIQueryDirectRenderingCapableReply rep;
+    Bool isCapable;
+
+    REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
+    REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!DRIQueryDirectRenderingCapable( screenInfo.screens[stuff->screen], 
+                                         &isCapable)) {
+        return BadValue;
+    }
+    rep.isCapable = isCapable;
+
+    if (!LocalClient(client))
+        rep.isCapable = 0;
+
+    WriteToClient(client, 
+        sizeof(xAppleDRIQueryDirectRenderingCapableReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static int
+ProcAppleDRIAuthConnection(
+    register ClientPtr client
+)
+{
+    xAppleDRIAuthConnectionReply rep;
+    
+    REQUEST(xAppleDRIAuthConnectionReq);
+    REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);
+
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.authenticated = 1;
+
+    if (!DRIAuthConnection( screenInfo.screens[stuff->screen], stuff->magic)) {
+        ErrorF("Failed to authenticate %u\n", stuff->magic);
+        rep.authenticated = 0;
+    }
+    WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static void surface_notify(
+    void *_arg,
+    void *data
+)
+{
+    DRISurfaceNotifyArg *arg = _arg;
+    int client_index = (int) data;
+    ClientPtr client;
+    xAppleDRINotifyEvent se;
+
+    if (client_index < 0 || client_index >= currentMaxClients)
+        return;
+
+    client = clients[client_index];
+    if (client == NULL || client == serverClient || client->clientGone)
+        return;
+
+    se.type = DRIEventBase + AppleDRISurfaceNotify;
+    se.kind = arg->kind;
+    se.arg = arg->id;
+    se.sequenceNumber = client->sequence;
+    se.time = currentTime.milliseconds;
+    WriteEventsToClient (client, 1, (xEvent *) &se);
+}
+
+static int
+ProcAppleDRICreateSurface(
+    ClientPtr client
+)
+{
+    xAppleDRICreateSurfaceReply rep;
+    DrawablePtr pDrawable;
+    xp_surface_id sid;
+    unsigned int key[2];
+
+    REQUEST(xAppleDRICreateSurfaceReq);
+    REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+
+    if (!(pDrawable = (DrawablePtr)SecurityLookupDrawable(
+                                                (Drawable)stuff->drawable,
+                                                client, 
+                                                SecurityReadAccess))) {
+        return BadValue;
+    }
+
+    rep.key_0 = rep.key_1 = rep.uid = 0;
+
+    if (!DRICreateSurface( screenInfo.screens[stuff->screen],
+                           (Drawable)stuff->drawable, pDrawable,
+                           stuff->client_id, &sid, key,
+                           surface_notify, (void *) client->index)) {
+        return BadValue;
+    }
+
+    rep.key_0 = key[0];
+    rep.key_1 = key[1];
+    rep.uid = sid;
+
+    WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), (char *)&rep);
+    return (client->noClientException);
+}
+
+static int
+ProcAppleDRIDestroySurface(
+    register ClientPtr client
+)
+{
+    REQUEST(xAppleDRIDestroySurfaceReq);
+    DrawablePtr pDrawable;
+    REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);
+
+    if (!(pDrawable = (DrawablePtr)SecurityLookupDrawable(
+                                                (Drawable)stuff->drawable,
+                                                client, 
+                                                SecurityReadAccess))) {
+        return BadValue;
+    }
+
+    if (!DRIDestroySurface( screenInfo.screens[stuff->screen], 
+                            (Drawable)stuff->drawable,
+                            pDrawable, NULL, NULL)) {
+        return BadValue;
+    }
+
+    return (client->noClientException);
+}
+
+
+/* dispatch */
+
+static int
+ProcAppleDRIDispatch (
+    register ClientPtr client
+)
+{
+    REQUEST(xReq);
+
+    switch (stuff->data)
+    {
+    case X_AppleDRIQueryVersion:
+        return ProcAppleDRIQueryVersion(client);
+    case X_AppleDRIQueryDirectRenderingCapable:
+        return ProcAppleDRIQueryDirectRenderingCapable(client);
+    }
+
+    if (!LocalClient(client))
+        return DRIErrorBase + AppleDRIClientNotLocal;
+
+    switch (stuff->data)
+    {
+    case X_AppleDRIAuthConnection:
+        return ProcAppleDRIAuthConnection(client);
+    case X_AppleDRICreateSurface:
+        return ProcAppleDRICreateSurface(client);
+    case X_AppleDRIDestroySurface:
+        return ProcAppleDRIDestroySurface(client);
+    default:
+        return BadRequest;
+    }
+}
+
+static void
+SNotifyEvent(
+    xAppleDRINotifyEvent *from,
+    xAppleDRINotifyEvent *to
+)
+{
+    to->type = from->type;
+    to->kind = from->kind;
+    cpswaps (from->sequenceNumber, to->sequenceNumber);
+    cpswapl (from->time, to->time);
+    cpswapl (from->arg, to->arg);
+}
+
+static int
+SProcAppleDRIQueryVersion(
+    register ClientPtr client
+)
+{
+    register int n;
+    REQUEST(xAppleDRIQueryVersionReq);
+    swaps(&stuff->length, n);
+    return ProcAppleDRIQueryVersion(client);
+}
+
+static int
+SProcAppleDRIDispatch (
+    register ClientPtr client
+)
+{
+    REQUEST(xReq);
+
+    /* It is bound to be non-local when there is byte swapping */
+    if (!LocalClient(client))
+        return DRIErrorBase + AppleDRIClientNotLocal;
+
+    /* only local clients are allowed DRI access */
+    switch (stuff->data)
+    {
+    case X_AppleDRIQueryVersion:
+        return SProcAppleDRIQueryVersion(client);
+    default:
+        return BadRequest;
+    }
+}
diff --git a/hw/darwin/quartz/xpr/dri.c b/hw/darwin/quartz/xpr/dri.c
new file mode 100644
index 000000000..aa595af85
--- /dev/null
+++ b/hw/darwin/quartz/xpr/dri.c
@@ -0,0 +1,690 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/xpr/dri.c,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Jens Owen <jens@valinux.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+#ifdef XFree86LOADER
+#include "xf86.h"
+#include "xf86_ansic.h"
+#else
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include "X.h"
+#include "Xproto.h"
+#include "misc.h"
+#include "dixstruct.h"
+#include "extnsionst.h"
+#include "colormapst.h"
+#include "cursorstr.h"
+#include "scrnintstr.h"
+#include "windowstr.h"
+#include "servermd.h"
+#define _APPLEDRI_SERVER_
+#include "appledristr.h"
+#include "swaprep.h"
+#include "dri.h"
+#include "dristruct.h"
+#include "mi.h"
+#include "mipointer.h"
+#include "rootless.h"
+#include "x-hash.h"
+#include "x-hook.h"
+
+static int DRIScreenPrivIndex = -1;
+static int DRIWindowPrivIndex = -1;
+
+static RESTYPE DRIDrawablePrivResType;
+
+static x_hash_table *surface_hash;	/* maps surface ids -> drawablePrivs */
+
+/* FIXME: don't hardcode this? */
+#define CG_INFO_FILE "/System/Library/Frameworks/ApplicationServices.framework/Frameworks/CoreGraphics.framework/Resources/Info-macos.plist"
+
+/* Corresponds to SU Jaguar Green */
+#define CG_REQUIRED_MAJOR 1
+#define CG_REQUIRED_MINOR 157
+#define CG_REQUIRED_MICRO 11
+
+/* Returns version as major.minor.micro in 10.10.10 fixed form */
+static unsigned int
+get_cg_version (void)
+{
+    static unsigned int version;
+
+    FILE *fh;
+    char *ptr;
+
+    if (version != 0)
+        return version;
+
+    /* I tried CFBundleGetVersion, but it returns zero, so.. */
+
+    fh = fopen (CG_INFO_FILE, "r");
+    if (fh != NULL)
+    {
+        char buf[256];
+
+        while (fgets (buf, sizeof (buf), fh) != NULL)
+        {
+            unsigned char c;
+
+            if (!strstr (buf, "<key>CFBundleShortVersionString</key>")
+                || fgets (buf, sizeof (buf), fh) == NULL)
+            {
+                continue;
+            }
+
+            ptr = strstr (buf, "<string>");
+            if (ptr == NULL)
+                continue;
+
+            ptr += strlen ("<string>");
+
+            /* Now PTR points to "MAJOR.MINOR.MICRO". */
+
+            version = 0;
+
+        again:
+            switch ((c = *ptr++))
+            {
+            case '.':
+                version = version * 1024;
+                goto again;
+
+            case '0': case '1': case '2': case '3': case '4':
+            case '5': case '6': case '7': case '8': case '9':
+                version = ((version & ~0x3ff)
+                          + (version & 0x3ff) * 10 + (c - '0'));
+                goto again;
+            }
+            break;
+        }
+
+        fclose (fh);
+    }
+
+    return version;
+}
+
+static Bool
+test_cg_version (unsigned int major, unsigned int minor, unsigned int micro)
+{
+    unsigned int cg_ver = get_cg_version ();
+
+    unsigned int cg_major = (cg_ver >> 20) & 0x3ff;
+    unsigned int cg_minor = (cg_ver >> 10) & 0x3ff;
+    unsigned int cg_micro =  cg_ver        & 0x3ff;
+
+    if (cg_major > major)
+        return TRUE;
+    else if (cg_major < major)
+        return FALSE;
+
+    /* cg_major == major */
+
+    if (cg_minor > minor)
+        return TRUE;
+    else if (cg_minor < minor)
+        return FALSE;
+
+    /* cg_minor == minor */
+
+    if (cg_micro < micro)
+        return FALSE;
+
+    return TRUE;
+}
+
+Bool
+DRIScreenInit(ScreenPtr pScreen)
+{
+    DRIScreenPrivPtr    pDRIPriv;
+    int                 i;
+
+    pDRIPriv = (DRIScreenPrivPtr) xcalloc(1, sizeof(DRIScreenPrivRec));
+    if (!pDRIPriv) {
+        pScreen->devPrivates[DRIScreenPrivIndex].ptr = NULL;
+        return FALSE;
+    }
+
+    pScreen->devPrivates[DRIScreenPrivIndex].ptr = (pointer) pDRIPriv;
+    pDRIPriv->directRenderingSupport = TRUE;
+    pDRIPriv->nrWindows = 0;
+
+    /* Need recent cg for window access update */
+    if (!test_cg_version (CG_REQUIRED_MAJOR,
+                          CG_REQUIRED_MINOR,
+                          CG_REQUIRED_MICRO))
+    {
+        ErrorF ("[DRI] disabled direct rendering; requires CoreGraphics %d.%d.%d\n",
+                CG_REQUIRED_MAJOR, CG_REQUIRED_MINOR, CG_REQUIRED_MICRO);
+
+        pDRIPriv->directRenderingSupport = FALSE;
+
+        /* Note we don't nuke the dri private, since we need it for
+           managing indirect surfaces. */
+    }
+
+    /* Initialize drawable tables */
+    for (i = 0; i < DRI_MAX_DRAWABLES; i++) {
+        pDRIPriv->DRIDrawables[i] = NULL;
+    }
+
+    return TRUE;
+}
+
+Bool
+DRIFinishScreenInit(ScreenPtr pScreen)
+{
+    DRIScreenPrivPtr  pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+
+    /* Allocate zero sized private area for each window. Should a window
+     * become a DRI window, we'll hang a DRIWindowPrivateRec off of this
+     * private index.
+     */
+    if (!AllocateWindowPrivate(pScreen, DRIWindowPrivIndex, 0))
+        return FALSE;
+
+    /* Wrap DRI support */
+    pDRIPriv->wrap.ValidateTree = pScreen->ValidateTree;
+    pScreen->ValidateTree = DRIValidateTree;
+
+    pDRIPriv->wrap.PostValidateTree = pScreen->PostValidateTree;
+    pScreen->PostValidateTree = DRIPostValidateTree;
+
+    pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;
+    pScreen->WindowExposures = DRIWindowExposures;
+
+    pDRIPriv->wrap.CopyWindow = pScreen->CopyWindow;
+    pScreen->CopyWindow = DRICopyWindow;
+
+    pDRIPriv->wrap.ClipNotify = pScreen->ClipNotify;
+    pScreen->ClipNotify = DRIClipNotify;
+
+    ErrorF("[DRI] screen %d installation complete\n", pScreen->myNum);
+
+    return TRUE;
+}
+
+void
+DRICloseScreen(ScreenPtr pScreen)
+{
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+
+    if (pDRIPriv && pDRIPriv->directRenderingSupport) {
+        xfree(pDRIPriv);
+        pScreen->devPrivates[DRIScreenPrivIndex].ptr = NULL;
+    }
+}
+
+Bool
+DRIExtensionInit(void)
+{
+    static unsigned long DRIGeneration = 0;
+
+    if (DRIGeneration != serverGeneration) {
+        if ((DRIScreenPrivIndex = AllocateScreenPrivateIndex()) < 0)
+            return FALSE;
+        DRIGeneration = serverGeneration;
+    }
+
+    /* Allocate a window private index with a zero sized private area for
+     * each window, then should a window become a DRI window, we'll hang
+     * a DRIWindowPrivateRec off of this private index.
+     */
+    if ((DRIWindowPrivIndex = AllocateWindowPrivateIndex()) < 0)
+        return FALSE;
+
+    DRIDrawablePrivResType = CreateNewResourceType(DRIDrawablePrivDelete);
+
+    return TRUE;
+}
+
+void
+DRIReset(void)
+{
+    /*
+     * This stub routine is called when the X Server recycles, resources
+     * allocated by DRIExtensionInit need to be managed here.
+     *
+     * Currently this routine is a stub because all the interesting resources
+     * are managed via the screen init process.
+     */
+}
+
+Bool
+DRIQueryDirectRenderingCapable(ScreenPtr pScreen, Bool* isCapable)
+{
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+
+    if (pDRIPriv)
+        *isCapable = pDRIPriv->directRenderingSupport;
+    else
+        *isCapable = FALSE;
+
+    return TRUE;
+}
+
+Bool
+DRIAuthConnection(ScreenPtr pScreen, unsigned int magic)
+{
+#if 0
+    /* FIXME: something? */
+
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+
+    if (drmAuthMagic(pDRIPriv->drmFD, magic)) return FALSE;
+#endif
+    return TRUE;
+}
+
+static void
+DRIUpdateSurface(DRIDrawablePrivPtr pDRIDrawablePriv, WindowPtr pWin)
+{
+    WindowPtr pTopWin;
+    xp_window_changes wc;
+
+    if (pDRIDrawablePriv->sid == 0)
+        return;
+
+    pTopWin = TopLevelParent(pWin);
+
+    wc.x = pWin->drawable.x - (pTopWin->drawable.x - pTopWin->borderWidth);
+    wc.y = pWin->drawable.y - (pTopWin->drawable.y - pTopWin->borderWidth);
+    wc.width = pWin->drawable.width + 2 * pWin->borderWidth;
+    wc.height = pWin->drawable.height + 2 * pWin->borderWidth;
+    wc.bit_gravity = XP_GRAVITY_NONE;
+
+    wc.shape_nrects = REGION_NUM_RECTS(&pWin->clipList);
+    wc.shape_rects = REGION_RECTS(&pWin->clipList);
+    wc.shape_tx = - (pTopWin->drawable.x - pTopWin->borderWidth);
+    wc.shape_ty = - (pTopWin->drawable.y - pTopWin->borderWidth);
+
+    xp_configure_surface(pDRIDrawablePriv->sid, XP_BOUNDS | XP_SHAPE, &wc);
+}
+
+Bool
+DRICreateSurface (ScreenPtr pScreen, Drawable id,
+                  DrawablePtr pDrawable, xp_client_id client_id,
+                  xp_surface_id *surface_id, unsigned int ret_key[2],
+                  void (*notify) (void *arg, void *data), void *notify_data)
+{
+    DRIScreenPrivPtr	pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+    DRIDrawablePrivPtr	pDRIDrawablePriv;
+    WindowPtr		pWin;
+
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        pWin = (WindowPtr)pDrawable;
+        if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin))) {
+            pDRIDrawablePriv->refCount++;
+        }
+        else {
+            xp_window_id wid;
+            xp_surface_id sid;
+            xp_error err;
+            unsigned int key[2];
+            xp_window_changes wc;
+
+            /* allocate a DRI Window Private record */
+            if (!(pDRIDrawablePriv = xalloc(sizeof(DRIDrawablePrivRec)))) {
+                return FALSE;
+            }
+
+            /* find the physical window */
+            wid = (xp_window_id) RootlessFrameForWindow (pWin, TRUE);
+            if (wid == 0) {
+                xfree (pDRIDrawablePriv);
+                return FALSE;
+            }
+
+            /* allocate the physical surface */
+            err = xp_create_surface (wid, &sid);
+            if (err != Success) {
+                xfree (pDRIDrawablePriv);
+                return FALSE;
+            }
+
+            /* try to give the client access to the surface */
+            if (client_id != 0)
+            {
+                err = xp_export_surface (wid, sid, client_id, key);
+                if (err != Success) {
+                    xp_destroy_surface (sid);
+                    xfree (pDRIDrawablePriv);
+                    return FALSE;
+                }
+            }
+
+            /* Make it visible */
+            wc.stack_mode = XP_MAPPED_ABOVE;
+            wc.sibling = 0;
+            err = xp_configure_surface (sid, XP_STACKING, &wc);
+            if (err != Success)
+            {
+                xp_destroy_surface (sid);
+                xfree (pDRIDrawablePriv);
+                return FALSE;
+            }
+
+            /* add it to the list of DRI drawables for this screen */
+            pDRIDrawablePriv->sid = sid;
+            pDRIDrawablePriv->pDraw = pDrawable;
+            pDRIDrawablePriv->pScreen = pScreen;
+            pDRIDrawablePriv->refCount = 1;
+            pDRIDrawablePriv->drawableIndex = -1;
+            pDRIDrawablePriv->key[0] = key[0];
+            pDRIDrawablePriv->key[1] = key[1];
+            pDRIDrawablePriv->notifiers = NULL;
+
+            /* save private off of preallocated index */
+            pWin->devPrivates[DRIWindowPrivIndex].ptr =
+                                                (pointer)pDRIDrawablePriv;
+
+            ++pDRIPriv->nrWindows;
+
+            /* and stash it by surface id */
+            if (surface_hash == NULL)
+                surface_hash = x_hash_table_new (NULL, NULL, NULL, NULL);
+            x_hash_table_insert (surface_hash, (void *) sid, pDRIDrawablePriv);
+
+            /* track this in case this window is destroyed */
+            AddResource(id, DRIDrawablePrivResType, (pointer)pWin);
+
+            /* Initialize shape */
+            DRIUpdateSurface (pDRIDrawablePriv, pWin);
+        }
+
+        if (notify != NULL) {
+            pDRIDrawablePriv->notifiers
+                = x_hook_add (pDRIDrawablePriv->notifiers,
+                              notify, notify_data);
+        }
+
+        *surface_id = pDRIDrawablePriv->sid;
+
+        if (ret_key != NULL)
+        {
+            ret_key[0] = pDRIDrawablePriv->key[0];
+            ret_key[1] = pDRIDrawablePriv->key[1];
+        }
+    }
+    else { /* pixmap (or for GLX 1.3, a PBuffer) */
+        /* NOT_DONE */
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+Bool
+DRIDestroySurface(ScreenPtr pScreen, Drawable id, DrawablePtr pDrawable,
+                  void (*notify) (void *, void *), void *notify_data)
+{
+    DRIDrawablePrivPtr	pDRIDrawablePriv;
+    WindowPtr		pWin;
+
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        pWin = (WindowPtr)pDrawable;
+        pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
+        if (pDRIDrawablePriv != NULL) {
+            if (notify != NULL)
+            {
+                pDRIDrawablePriv->notifiers
+                    = x_hook_remove (pDRIDrawablePriv->notifiers,
+                                     notify, notify_data);
+            }
+            if (--pDRIDrawablePriv->refCount <= 0) {
+                /* This calls back to DRIDrawablePrivDelete
+                   which frees the private area */
+                FreeResourceByType(id, DRIDrawablePrivResType, FALSE);
+            }
+        }
+    }
+    else { /* pixmap (or for GLX 1.3, a PBuffer) */
+        /* NOT_DONE */
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+Bool
+DRIDrawablePrivDelete(pointer pResource, XID id)
+{
+    DrawablePtr		pDrawable = (DrawablePtr)pResource;
+    DRIScreenPrivPtr	pDRIPriv = DRI_SCREEN_PRIV(pDrawable->pScreen);
+    DRIDrawablePrivPtr	pDRIDrawablePriv;
+    WindowPtr		pWin;
+
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        pWin = (WindowPtr)pDrawable;
+        pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
+
+        if (pDRIDrawablePriv->drawableIndex != -1) {
+            /* release drawable table entry */
+            pDRIPriv->DRIDrawables[pDRIDrawablePriv->drawableIndex] = NULL;
+        }
+
+        if (pDRIDrawablePriv->sid != 0) {
+            xp_destroy_surface (pDRIDrawablePriv->sid);
+            x_hash_table_remove (surface_hash, (void *) pDRIDrawablePriv->sid);
+        }
+
+        if (pDRIDrawablePriv->notifiers != NULL)
+            x_hook_free (pDRIDrawablePriv->notifiers);
+
+        xfree(pDRIDrawablePriv);
+        pWin->devPrivates[DRIWindowPrivIndex].ptr = NULL;
+
+        --pDRIPriv->nrWindows;
+    }
+    else { /* pixmap (or for GLX 1.3, a PBuffer) */
+        /* NOT_DONE */
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+void
+DRIWindowExposures(WindowPtr pWin, RegionPtr prgn, RegionPtr bsreg)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+    DRIDrawablePrivPtr pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin);
+
+    if(pDRIDrawablePriv) {
+        /* FIXME: something? */
+    }
+
+    pScreen->WindowExposures = pDRIPriv->wrap.WindowExposures;
+
+    (*pScreen->WindowExposures)(pWin, prgn, bsreg);
+
+    pDRIPriv->wrap.WindowExposures = pScreen->WindowExposures;
+    pScreen->WindowExposures = DRIWindowExposures;
+
+}
+
+void
+DRICopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+    DRIDrawablePrivPtr pDRIDrawablePriv;
+
+    if (pDRIPriv->nrWindows > 0) {
+       pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW (pWin);
+       if (pDRIDrawablePriv != NULL) {
+            DRIUpdateSurface (pDRIDrawablePriv, pWin);
+       }
+    }
+
+    /* unwrap */
+    pScreen->CopyWindow = pDRIPriv->wrap.CopyWindow;
+
+    /* call lower layers */
+    (*pScreen->CopyWindow)(pWin, ptOldOrg, prgnSrc);
+
+    /* rewrap */
+    pDRIPriv->wrap.CopyWindow = pScreen->CopyWindow;
+    pScreen->CopyWindow = DRICopyWindow;
+}
+
+int
+DRIValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind)
+{
+    ScreenPtr pScreen = pParent->drawable.pScreen;
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+    int returnValue;
+
+    /* unwrap */
+    pScreen->ValidateTree = pDRIPriv->wrap.ValidateTree;
+
+    /* call lower layers */
+    returnValue = (*pScreen->ValidateTree)(pParent, pChild, kind);
+
+    /* rewrap */
+    pDRIPriv->wrap.ValidateTree = pScreen->ValidateTree;
+    pScreen->ValidateTree = DRIValidateTree;
+
+    return returnValue;
+}
+
+void
+DRIPostValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind)
+{
+    ScreenPtr pScreen;
+    DRIScreenPrivPtr pDRIPriv;
+
+    if (pParent) {
+        pScreen = pParent->drawable.pScreen;
+    } else {
+        pScreen = pChild->drawable.pScreen;
+    }
+    pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+
+    if (pDRIPriv->wrap.PostValidateTree) {
+        /* unwrap */
+        pScreen->PostValidateTree = pDRIPriv->wrap.PostValidateTree;
+
+        /* call lower layers */
+        (*pScreen->PostValidateTree)(pParent, pChild, kind);
+
+        /* rewrap */
+        pDRIPriv->wrap.PostValidateTree = pScreen->PostValidateTree;
+        pScreen->PostValidateTree = DRIPostValidateTree;
+    }
+}
+
+void
+DRIClipNotify(WindowPtr pWin, int dx, int dy)
+{
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
+    DRIDrawablePrivPtr	pDRIDrawablePriv;
+
+    if ((pDRIDrawablePriv = DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin))) {
+        DRIUpdateSurface (pDRIDrawablePriv, pWin);
+    }
+
+    if(pDRIPriv->wrap.ClipNotify) {
+        pScreen->ClipNotify = pDRIPriv->wrap.ClipNotify;
+
+        (*pScreen->ClipNotify)(pWin, dx, dy);
+
+        pDRIPriv->wrap.ClipNotify = pScreen->ClipNotify;
+        pScreen->ClipNotify = DRIClipNotify;
+    }
+}
+
+/* This lets us get at the unwrapped functions so that they can correctly
+ * call the lower level functions, and choose whether they will be
+ * called at every level of recursion (eg in validatetree).
+ */
+DRIWrappedFuncsRec *
+DRIGetWrappedFuncs(ScreenPtr pScreen)
+{
+    return &(DRI_SCREEN_PRIV(pScreen)->wrap);
+}
+
+void
+DRIQueryVersion(int *majorVersion,
+                int *minorVersion,
+                int *patchVersion)
+{
+    *majorVersion = APPLE_DRI_MAJOR_VERSION;
+    *minorVersion = APPLE_DRI_MINOR_VERSION;
+    *patchVersion = APPLE_DRI_PATCH_VERSION;
+}
+
+void
+DRISurfaceNotify (xp_surface_id id, int kind)
+{
+    DRIDrawablePrivPtr pDRIDrawablePriv = NULL;
+    DRISurfaceNotifyArg arg;
+
+    arg.id = id;
+    arg.kind = kind;
+
+    if (surface_hash != NULL)
+    {
+        pDRIDrawablePriv = x_hash_table_lookup (surface_hash,
+                                                (void *) id, NULL);
+    }
+
+    if (pDRIDrawablePriv == NULL)
+        return;
+
+    if (kind == AppleDRISurfaceNotifyDestroyed)
+    {
+        pDRIDrawablePriv->sid = 0;
+        x_hash_table_remove (surface_hash, (void *) id);
+    }
+
+    x_hook_run (pDRIDrawablePriv->notifiers, &arg);
+
+    if (kind == AppleDRISurfaceNotifyDestroyed)
+    {
+        /* Kill off the handle. */
+
+        FreeResourceByType (pDRIDrawablePriv->pDraw->id,
+                            DRIDrawablePrivResType, FALSE);
+    }
+}
diff --git a/hw/darwin/quartz/xpr/dri.h b/hw/darwin/quartz/xpr/dri.h
new file mode 100644
index 000000000..350f61b56
--- /dev/null
+++ b/hw/darwin/quartz/xpr/dri.h
@@ -0,0 +1,130 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/xpr/dri.h,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Jens Owen <jens@precisioninsight.com>
+ *
+ */
+
+/* Prototypes for AppleDRI functions */
+
+#ifndef _DRI_H_
+
+#include "Xdefs.h"
+#include "scrnintstr.h"
+#define _APPLEDRI_SERVER_
+#include "appledri.h"
+#include "Xplugin.h"
+
+typedef void (*ClipNotifyPtr)( WindowPtr, int, int );
+
+
+/*
+ * These functions can be wrapped by the DRI.  Each of these have
+ * generic default funcs (initialized in DRICreateInfoRec) and can be
+ * overridden by the driver in its [driver]DRIScreenInit function.
+ */
+typedef struct {
+    WindowExposuresProcPtr       WindowExposures;
+    CopyWindowProcPtr            CopyWindow;
+    ValidateTreeProcPtr          ValidateTree;
+    PostValidateTreeProcPtr      PostValidateTree;
+    ClipNotifyProcPtr            ClipNotify;
+} DRIWrappedFuncsRec, *DRIWrappedFuncsPtr;
+
+typedef struct {
+    xp_surface_id id;
+    int kind;
+} DRISurfaceNotifyArg;
+
+extern Bool DRIScreenInit(ScreenPtr pScreen);
+
+extern Bool DRIFinishScreenInit(ScreenPtr pScreen);
+
+extern void DRICloseScreen(ScreenPtr pScreen);
+
+extern Bool DRIExtensionInit(void);
+
+extern void DRIReset(void);
+
+extern Bool DRIQueryDirectRenderingCapable(ScreenPtr pScreen,
+                                           Bool *isCapable);
+
+extern Bool DRIAuthConnection(ScreenPtr pScreen, unsigned int magic);
+
+extern Bool DRICreateSurface(ScreenPtr pScreen,
+                             Drawable id,
+                             DrawablePtr pDrawable,
+                             xp_client_id client_id,
+                             xp_surface_id *surface_id,
+                             unsigned int key[2],
+                             void (*notify) (void *arg, void *data),
+                             void *notify_data);
+
+extern Bool DRIDestroySurface(ScreenPtr pScreen,
+                             Drawable id,
+                             DrawablePtr pDrawable,
+                             void (*notify) (void *arg, void *data),
+                             void *notify_data);
+
+extern Bool DRIDrawablePrivDelete(pointer pResource,
+                                  XID id);
+
+extern DRIWrappedFuncsRec *DRIGetWrappedFuncs(ScreenPtr pScreen);
+
+extern void DRICopyWindow(WindowPtr pWin,
+                          DDXPointRec ptOldOrg,
+                          RegionPtr prgnSrc);
+
+extern int DRIValidateTree(WindowPtr pParent,
+                           WindowPtr pChild,
+                           VTKind    kind);
+
+extern void DRIPostValidateTree(WindowPtr pParent,
+                                WindowPtr pChild,
+                                VTKind    kind);
+
+extern void DRIClipNotify(WindowPtr pWin,
+                          int dx,
+                          int dy);
+
+extern void DRIWindowExposures(WindowPtr pWin,
+                              RegionPtr prgn,
+                              RegionPtr bsreg);
+
+extern void DRISurfaceNotify (xp_surface_id id, int kind);
+
+extern void DRIQueryVersion(int *majorVersion,
+                            int *minorVersion,
+                            int *patchVersion);
+
+#define _DRI_H_
+
+#endif
diff --git a/hw/darwin/quartz/xpr/dristruct.h b/hw/darwin/quartz/xpr/dristruct.h
new file mode 100644
index 000000000..1a2949b18
--- /dev/null
+++ b/hw/darwin/quartz/xpr/dristruct.h
@@ -0,0 +1,82 @@
+/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/xpr/dristruct.h,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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, sub license, 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 (including the
+next paragraph) 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 NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Jens Owen <jens@precisioninsight.com>
+ *
+ */
+
+#ifndef DRI_STRUCT_H
+#define DRI_STRUCT_H
+
+#include "dri.h"
+#include "x-list.h"
+
+#define DRI_MAX_DRAWABLES 256
+
+#define DRI_DRAWABLE_PRIV_FROM_WINDOW(pWin) \
+    ((DRIWindowPrivIndex < 0) ? \
+     NULL : \
+     ((DRIDrawablePrivPtr)((pWin)->devPrivates[DRIWindowPrivIndex].ptr)))
+
+#define DRI_DRAWABLE_PRIV_FROM_PIXMAP(pPix) \
+    ((DRIPixmapPrivIndex < 0) ? \
+     NULL : \
+     ((DRIDrawablePrivPtr)((pPix)->devPrivates[DRIWindowPrivIndex].ptr)))
+
+typedef struct _DRIDrawablePrivRec
+{
+    xp_surface_id	sid;
+    int			drawableIndex;
+    DrawablePtr		pDraw;
+    ScreenPtr		pScreen;
+    int 		refCount;
+    unsigned int	key[2];
+    x_list		*notifiers;	/* list of (FUN . DATA) */
+} DRIDrawablePrivRec, *DRIDrawablePrivPtr;
+
+#define DRI_SCREEN_PRIV(pScreen) \
+    ((DRIScreenPrivIndex < 0) ? \
+     NULL : \
+     ((DRIScreenPrivPtr)((pScreen)->devPrivates[DRIScreenPrivIndex].ptr)))
+
+#define DRI_SCREEN_PRIV_FROM_INDEX(screenIndex) ((DRIScreenPrivPtr) \
+    (screenInfo.screens[screenIndex]->devPrivates[DRIScreenPrivIndex].ptr))
+
+
+typedef struct _DRIScreenPrivRec
+{
+    Bool		directRenderingSupport;
+    int                 nrWindows;
+    DRIWrappedFuncsRec	wrap;
+    DrawablePtr		DRIDrawables[DRI_MAX_DRAWABLES];
+} DRIScreenPrivRec, *DRIScreenPrivPtr;
+
+#endif /* DRI_STRUCT_H */
diff --git a/hw/darwin/quartz/xpr/x-hash.c b/hw/darwin/quartz/xpr/x-hash.c
new file mode 100644
index 000000000..ad36204c5
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-hash.c
@@ -0,0 +1,341 @@
+/* x-hash.c - basic hash tables
+   $Id$
+
+   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/xpr/x-hash.c,v 1.2 2003/06/30 01:45:13 torrey Exp $ */
+
+#include "x-hash.h"
+#include "x-list.h"
+#include <stdlib.h>
+#include <assert.h>
+
+struct x_hash_table_struct {
+    int bucket_index;
+    int total_keys;
+    x_list **buckets;
+
+    x_hash_fun *hash_key;
+    x_compare_fun *compare_keys;
+    x_destroy_fun *destroy_key;
+    x_destroy_fun *destroy_value;
+};
+
+#define ITEM_NEW(k, v) X_PFX (list_prepend) ((x_list *) (k), v)
+#define ITEM_FREE(i) X_PFX (list_free_1) (i)
+#define ITEM_KEY(i) ((void *) (i)->next)
+#define ITEM_VALUE(i) ((i)->data)
+
+#define SPLIT_THRESHOLD_FACTOR 2
+
+/* http://planetmath.org/?op=getobj&from=objects&name=GoodHashTablePrimes */
+static const unsigned int bucket_sizes[] = {
+    29, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593, 49157,
+    98317, 196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917,
+    25165843, 50331653, 100663319, 201326611, 402653189, 805306457,
+    1610612741
+};
+
+#define N_BUCKET_SIZES (sizeof (bucket_sizes) / sizeof (bucket_sizes[0]))
+
+static inline unsigned int
+hash_table_total_buckets (x_hash_table *h)
+{
+    return bucket_sizes[h->bucket_index];
+}
+
+static inline void
+hash_table_destroy_item (x_hash_table *h, void *k, void *v)
+{
+    if (h->destroy_key != 0)
+	(*h->destroy_key) (k);
+
+    if (h->destroy_value != 0)
+	(*h->destroy_value) (v);
+}
+
+static inline unsigned int
+hash_table_hash_key (x_hash_table *h, void *k)
+{
+    if (h->hash_key != 0)
+	return (*h->hash_key) (k);
+    else
+	return (unsigned int) k;
+}
+
+static inline int
+hash_table_compare_keys (x_hash_table *h, void *k1, void *k2)
+{
+    if (h->compare_keys == 0)
+	return k1 == k2;
+    else
+	return (*h->compare_keys) (k1, k2) == 0;
+}
+
+static void
+hash_table_split (x_hash_table *h)
+{
+    x_list **new, **old;
+    x_list *node, *item, *next;
+    int new_size, old_size;
+    unsigned int b;
+    int i;
+
+    if (h->bucket_index == N_BUCKET_SIZES - 1)
+	return;
+
+    old_size = hash_table_total_buckets (h);
+    old = h->buckets;
+
+    h->bucket_index++;
+
+    new_size = hash_table_total_buckets (h);
+    new = calloc (new_size, sizeof (x_list *));
+
+    if (new == 0)
+    {
+	h->bucket_index--;
+	return;
+    }
+
+    for (i = 0; i < old_size; i++)
+    {
+	for (node = old[i]; node != 0; node = next)
+	{
+	    next = node->next;
+	    item = node->data;
+
+	    b = hash_table_hash_key (h, ITEM_KEY (item)) % new_size;
+
+	    node->next = new[b];
+	    new[b] = node;
+	}
+    }
+
+    h->buckets = new;
+    free (old);
+}
+
+X_EXTERN x_hash_table *
+X_PFX (hash_table_new) (x_hash_fun *hash,
+			x_compare_fun *compare,
+			x_destroy_fun *key_destroy,
+			x_destroy_fun *value_destroy)
+{
+    x_hash_table *h;
+
+    h = calloc (1, sizeof (x_hash_table));
+    if (h == 0)
+	return 0;
+
+    h->bucket_index = 0;
+    h->buckets = calloc (hash_table_total_buckets (h), sizeof (x_list *));
+
+    if (h->buckets == 0)
+    {
+	free (h);
+	return 0;
+    }
+    
+    h->hash_key = hash;
+    h->compare_keys = compare;
+    h->destroy_key = key_destroy;
+    h->destroy_value = value_destroy;
+
+    return h;
+}
+
+X_EXTERN void
+X_PFX (hash_table_free) (x_hash_table *h)
+{
+    int n, i;
+    x_list *node, *item;
+
+    assert (h != NULL);
+
+    n = hash_table_total_buckets (h);
+
+    for (i = 0; i < n; i++)
+    {
+	for (node = h->buckets[i]; node != 0; node = node->next)
+	{
+	    item = node->data;
+	    hash_table_destroy_item (h, ITEM_KEY (item), ITEM_VALUE (item));
+	    ITEM_FREE (item);
+	}
+	X_PFX (list_free) (h->buckets[i]);
+    }
+
+    free (h->buckets);
+    free (h);
+}
+
+X_EXTERN unsigned int
+X_PFX (hash_table_size) (x_hash_table *h)
+{
+    assert (h != NULL);
+
+    return h->total_keys;
+}
+
+static void
+hash_table_modify (x_hash_table *h, void *k, void *v, int replace)
+{
+    unsigned int hash_value;
+    x_list *node, *item;
+
+    assert (h != NULL);
+
+    hash_value = hash_table_hash_key (h, k);
+
+    for (node = h->buckets[hash_value % hash_table_total_buckets (h)];
+	 node != 0; node = node->next)
+    {
+	item = node->data;
+
+	if (hash_table_compare_keys (h, ITEM_KEY (item), k))
+	{
+	    if (replace)
+	    {
+		hash_table_destroy_item (h, ITEM_KEY (item),
+					 ITEM_VALUE (item));
+		ITEM_KEY (item) = k;
+		ITEM_VALUE (item) = v;
+	    }
+	    else
+	    {
+		hash_table_destroy_item (h, k, ITEM_VALUE (item));
+		ITEM_VALUE (item) = v;
+	    }
+	    return;
+	}
+    }
+
+    /* Key isn't already in the table. Insert it. */
+
+    if (h->total_keys + 1
+	> hash_table_total_buckets (h) * SPLIT_THRESHOLD_FACTOR)
+    {
+	hash_table_split (h);
+    }
+
+    hash_value = hash_value % hash_table_total_buckets (h);
+    h->buckets[hash_value] = X_PFX (list_prepend) (h->buckets[hash_value],
+						   ITEM_NEW (k, v));
+    h->total_keys++;
+}
+
+X_EXTERN void
+X_PFX (hash_table_insert) (x_hash_table *h, void *k, void *v)
+{
+    hash_table_modify (h, k, v, 0);
+}
+
+X_EXTERN void
+X_PFX (hash_table_replace) (x_hash_table *h, void *k, void *v)
+{
+    hash_table_modify (h, k, v, 1);
+}
+
+X_EXTERN void
+X_PFX (hash_table_remove) (x_hash_table *h, void *k)
+{
+    unsigned int hash_value;
+    x_list **ptr, *item;
+
+    assert (h != NULL);
+
+    hash_value = hash_table_hash_key (h, k);
+
+    for (ptr = &h->buckets[hash_value % hash_table_total_buckets (h)];
+	 *ptr != 0; ptr = &((*ptr)->next))
+    {
+	item = (*ptr)->data;
+
+	if (hash_table_compare_keys (h, ITEM_KEY (item), k))
+	{
+	    hash_table_destroy_item (h, ITEM_KEY (item), ITEM_VALUE (item));
+	    ITEM_FREE (item);
+	    item = *ptr;
+	    *ptr = item->next;
+	    X_PFX (list_free_1) (item);
+	    h->total_keys--;
+	    return;
+	}
+    }
+}
+
+X_EXTERN void *
+X_PFX (hash_table_lookup) (x_hash_table *h, void *k, void **k_ret)
+{
+    unsigned int hash_value;
+    x_list *node, *item;
+
+    assert (h != NULL);
+
+    hash_value = hash_table_hash_key (h, k);
+
+    for (node = h->buckets[hash_value % hash_table_total_buckets (h)];
+	 node != 0; node = node->next)
+    {
+	item = node->data;
+
+	if (hash_table_compare_keys (h, ITEM_KEY (item), k))
+	{
+	    if (k_ret != 0)
+		*k_ret = ITEM_KEY (item);
+
+	    return ITEM_VALUE (item);
+	}
+    }
+
+    if (k_ret != 0)
+	*k_ret = 0;
+
+    return 0;
+}
+
+X_EXTERN void
+X_PFX (hash_table_foreach) (x_hash_table *h,
+			    x_hash_foreach_fun *fun, void *data)
+{
+    int i, n;
+    x_list *node, *item;
+
+    assert (h != NULL);
+
+    n = hash_table_total_buckets (h);
+
+    for (i = 0; i < n; i++)
+    {
+	for (node = h->buckets[i]; node != 0; node = node->next)
+	{
+	    item = node->data;
+	    (*fun) (ITEM_KEY (item), ITEM_VALUE (item), data);
+	}
+    }
+}
diff --git a/hw/darwin/quartz/xpr/x-hash.h b/hw/darwin/quartz/xpr/x-hash.h
new file mode 100644
index 000000000..2abb08cd7
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-hash.h
@@ -0,0 +1,62 @@
+/* x-hash.h -- basic hash table class
+   $Id$
+
+   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/xpr/x-hash.h,v 1.2 2003/06/30 01:45:13 torrey Exp $ */
+
+#ifndef X_HASH_H
+#define X_HASH_H 1
+
+typedef struct x_hash_table_struct x_hash_table;
+
+typedef int (x_compare_fun) (const void *a, const void *b);
+typedef unsigned int (x_hash_fun) (const void *k);
+typedef void (x_destroy_fun) (void *x);
+typedef void (x_hash_foreach_fun) (void *k, void *v, void *data);
+
+/* for X_PFX and X_EXTERN */
+#include "x-list.h"
+
+X_EXTERN x_hash_table *X_PFX (hash_table_new) (x_hash_fun *hash,
+					       x_compare_fun *compare,
+					       x_destroy_fun *key_destroy,
+					       x_destroy_fun *value_destroy);
+X_EXTERN void X_PFX (hash_table_free) (x_hash_table *h);
+
+X_EXTERN unsigned int X_PFX (hash_table_size) (x_hash_table *h);
+
+X_EXTERN void X_PFX (hash_table_insert) (x_hash_table *h, void *k, void *v);
+X_EXTERN void X_PFX (hash_table_replace) (x_hash_table *h, void *k, void *v);
+X_EXTERN void X_PFX (hash_table_remove) (x_hash_table *h, void *k);
+X_EXTERN void *X_PFX (hash_table_lookup) (x_hash_table *h,
+					  void *k, void **k_ret);
+X_EXTERN void X_PFX (hash_table_foreach) (x_hash_table *h,
+					  x_hash_foreach_fun *fun,
+					  void *data);
+
+#endif /* X_HASH_H */
diff --git a/hw/darwin/quartz/xpr/x-hook.c b/hw/darwin/quartz/xpr/x-hook.c
new file mode 100644
index 000000000..3414e1543
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-hook.c
@@ -0,0 +1,106 @@
+/* x-hook.c
+   $Id$
+
+   Copyright (c) 2003 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/xpr/x-hook.c,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+
+#include "x-hook.h"
+#include <stdlib.h>
+#include <assert.h>
+
+#define CELL_NEW(f,d) X_PFX (list_prepend) ((x_list *) (f), (d))
+#define CELL_FREE(c)  X_PFX (list_free_1) (c)
+#define CELL_FUN(c)   ((x_hook_function *) ((c)->next))
+#define CELL_DATA(c)  ((c)->data)
+
+X_EXTERN x_list *
+X_PFX (hook_add) (x_list *lst, x_hook_function *fun, void *data)
+{
+    return X_PFX (list_prepend) (lst, CELL_NEW (fun, data));
+}
+
+X_EXTERN x_list *
+X_PFX (hook_remove) (x_list *lst, x_hook_function *fun, void *data)
+{
+    x_list *node, *cell;
+    x_list *to_delete = NULL;
+
+    for (node = lst; node != NULL; node = node->next)
+    {
+	cell = node->data;
+	if (CELL_FUN (cell) == fun && CELL_DATA (cell) == data)
+	    to_delete = X_PFX (list_prepend) (to_delete, cell);
+    }
+
+    for (node = to_delete; node != NULL; node = node->next)
+    {
+	cell = node->data;
+	lst = X_PFX (list_remove) (lst, cell);
+	CELL_FREE (cell);
+    }
+
+    X_PFX (list_free) (to_delete);
+}
+
+X_EXTERN void
+X_PFX (hook_run) (x_list *lst, void *arg)
+{
+    x_list *node, *cell;
+    x_hook_function **fun;
+    void **data;
+    int length, i;
+
+    length = X_PFX (list_length) (lst);
+    fun = alloca (sizeof (x_hook_function *) * length);
+    data = alloca (sizeof (void *) * length);
+
+    for (i = 0, node = lst; node != NULL; node = node->next, i++)
+    {
+	cell = node->data;
+	fun[i] = CELL_FUN (cell);
+	data[i] = CELL_DATA (cell);
+    }
+
+    for (i = 0; i < length; i++)
+    {
+	(*fun[i]) (arg, data[i]);
+    }
+}
+
+X_EXTERN void
+X_PFX (hook_free) (x_list *lst)
+{
+    x_list *node;
+
+    for (node = lst; node != NULL; node = node->next)
+    {
+	CELL_FREE (node->data);
+    }
+
+    X_PFX (list_free) (lst);
+}
diff --git a/hw/darwin/quartz/xpr/x-hook.h b/hw/darwin/quartz/xpr/x-hook.h
new file mode 100644
index 000000000..14e8ca1f5
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-hook.h
@@ -0,0 +1,44 @@
+/* x-hook.h -- lists of function,data pairs to call.
+   $Id$
+
+   Copyright (c) 2003 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/xpr/x-hook.h,v 1.1 2003/06/30 01:45:13 torrey Exp $ */
+
+#ifndef X_HOOK_H
+#define X_HOOK_H 1
+
+#include "x-list.h"
+
+typedef void x_hook_function (void *arg, void *data);
+
+X_EXTERN x_list *X_PFX (hook_add) (x_list *lst, x_hook_function *fun, void *data);
+X_EXTERN x_list *X_PFX (hook_remove) (x_list *lst, x_hook_function *fun, void *data);
+X_EXTERN void X_PFX (hook_run) (x_list *lst, void *arg);
+X_EXTERN void X_PFX (hook_free) (x_list *lst);
+
+#endif /* X_HOOK_H */
diff --git a/hw/darwin/quartz/xpr/x-list.c b/hw/darwin/quartz/xpr/x-list.c
new file mode 100644
index 000000000..859a5163d
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-list.c
@@ -0,0 +1,316 @@
+/* x-list.c
+   $Id$
+
+   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/xpr/x-list.c,v 1.2 2003/06/30 01:45:13 torrey Exp $ */
+
+#include "x-list.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+
+/* Allocate in ~4k blocks */
+#define NODES_PER_BLOCK 508
+
+typedef struct x_list_block_struct x_list_block;
+
+struct x_list_block_struct {
+    x_list l[NODES_PER_BLOCK];
+};
+
+static x_list *freelist;
+
+static pthread_mutex_t freelist_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static inline void
+list_free_1 (x_list *node)
+{
+    node->next = freelist;
+    freelist = node;
+}
+
+X_EXTERN void
+X_PFX (list_free_1) (x_list *node)
+{
+    assert (node != NULL);
+
+    pthread_mutex_lock (&freelist_lock);
+
+    list_free_1 (node);
+
+    pthread_mutex_unlock (&freelist_lock);
+}
+
+X_EXTERN void
+X_PFX (list_free) (x_list *lst)
+{
+    x_list *next;
+
+    pthread_mutex_lock (&freelist_lock);
+
+    for (; lst != NULL; lst = next)
+    {
+	next = lst->next;
+	list_free_1 (lst);
+    }
+
+    pthread_mutex_unlock (&freelist_lock);
+}
+
+X_EXTERN x_list *
+X_PFX (list_prepend) (x_list *lst, void *data)
+{
+    x_list *node;
+
+    pthread_mutex_lock (&freelist_lock);
+
+    if (freelist == NULL)
+    {
+	x_list_block *b;
+	int i;
+
+	b = malloc (sizeof (x_list_block));
+
+	for (i = 0; i < NODES_PER_BLOCK - 1; i++)
+	    b->l[i].next = &(b->l[i+1]);
+	b->l[i].next = NULL;
+
+	freelist = b->l;
+    }
+
+    node = freelist;
+    freelist = node->next;
+
+    pthread_mutex_unlock (&freelist_lock);
+
+    node->next = lst;
+    node->data = data;
+
+    return node;
+}
+
+X_EXTERN x_list *
+X_PFX (list_append) (x_list *lst, void *data)
+{
+    x_list *head = lst;
+
+    if (lst == NULL)
+	return X_PFX (list_prepend) (NULL, data);
+
+    while (lst->next != NULL)
+	lst = lst->next;
+
+    lst->next = X_PFX (list_prepend) (NULL, data);
+
+    return head;
+}
+
+X_EXTERN x_list *
+X_PFX (list_reverse) (x_list *lst)
+{
+    x_list *head = NULL, *next;
+    
+    while (lst != NULL)
+    {
+	next = lst->next;
+	lst->next = head;
+	head = lst;
+	lst = next;
+    }
+
+    return head;
+}
+
+X_EXTERN x_list *
+X_PFX (list_find) (x_list *lst, void *data)
+{
+    for (; lst != NULL; lst = lst->next)
+    {
+	if (lst->data == data)
+	    return lst;
+    }
+
+    return NULL;
+}
+
+X_EXTERN x_list *
+X_PFX (list_nth) (x_list *lst, int n)
+{
+    while (n-- > 0 && lst != NULL)
+	lst = lst->next;
+
+    return lst;
+}
+
+X_EXTERN x_list *
+X_PFX (list_filter) (x_list *lst,
+		     int (*pred) (void *item, void *data), void *data)
+{
+    x_list *ret = NULL, *node;
+
+    for (node = lst; node != NULL; node = node->next)
+    {
+	if ((*pred) (node->data, data))
+	    ret = X_PFX (list_prepend) (ret, node->data);
+    }
+
+    return X_PFX (list_reverse) (ret);
+}
+
+X_EXTERN x_list *
+X_PFX (list_map) (x_list *lst,
+		  void *(*fun) (void *item, void *data), void *data)
+{
+    x_list *ret = NULL, *node;
+
+    for (node = lst; node != NULL; node = node->next)
+    {
+	X_PFX (list_prepend) (ret, fun (node->data, data));
+    }
+
+    return X_PFX (list_reverse) (ret);
+}
+
+X_EXTERN x_list *
+X_PFX (list_copy) (x_list *lst)
+{
+    x_list *copy = NULL;
+
+    for (; lst != NULL; lst = lst->next)
+    {
+	copy = X_PFX (list_prepend) (copy, lst->data);
+    }
+
+    return X_PFX (list_reverse) (copy);
+}
+
+X_EXTERN x_list *
+X_PFX (list_remove) (x_list *lst, void *data)
+{
+    x_list **ptr, *node;
+
+    for (ptr = &lst; *ptr != NULL;)
+    {
+	node = *ptr;
+
+	if (node->data == data)
+	{
+	    *ptr = node->next;
+	    X_PFX (list_free_1) (node);
+	}
+	else
+	    ptr = &((*ptr)->next);
+    }
+
+    return lst;
+}
+
+X_EXTERN unsigned int
+X_PFX (list_length) (x_list *lst)
+{
+    unsigned int n;
+
+    n = 0;
+    for (; lst != NULL; lst = lst->next)
+	n++;
+
+    return n;
+}
+
+X_EXTERN void
+X_PFX (list_foreach) (x_list *lst,
+		      void (*fun) (void *data, void *user_data),
+		      void *user_data)
+{
+    for (; lst != NULL; lst = lst->next)
+    {
+	(*fun) (lst->data, user_data);
+    }
+}
+
+static x_list *
+list_sort_1 (x_list *lst, int length,
+	     int (*less) (const void *, const void *))
+{
+    x_list *mid, *ptr;
+    x_list *out_head, *out;
+    int mid_point, i;
+
+    /* This is a standard (stable) list merge sort */
+
+    if (length < 2)
+	return lst;
+
+    /* Calculate the halfway point. Split the list into two sub-lists. */
+
+    mid_point = length / 2;
+    ptr = lst;
+    for (i = mid_point - 1; i > 0; i--)
+        ptr = ptr->next;
+    mid = ptr->next;
+    ptr->next = NULL;
+
+    /* Sort each sub-list. */
+
+    lst = list_sort_1 (lst, mid_point, less);
+    mid = list_sort_1 (mid, length - mid_point, less);
+
+    /* Then merge them back together. */
+
+    assert (lst != NULL && mid != NULL);
+
+    if ((*less) (mid->data, lst->data))
+	out = out_head = mid, mid = mid->next;
+    else
+	out = out_head = lst, lst = lst->next;
+
+    while (lst != NULL && mid != NULL)
+    {
+        if ((*less) (mid->data, lst->data))
+	    out = out->next = mid, mid = mid->next;
+        else
+	    out = out->next = lst, lst = lst->next;
+    }
+
+    if (lst != NULL)
+        out->next = lst;
+    else
+        out->next = mid;
+
+    return out_head;
+}
+
+X_EXTERN x_list *
+X_PFX (list_sort) (x_list *lst, int (*less) (const void *, const void *))
+{
+    int length;
+
+    length = X_PFX (list_length) (lst);
+
+    return list_sort_1 (lst, length, less);
+}
diff --git a/hw/darwin/quartz/xpr/x-list.h b/hw/darwin/quartz/xpr/x-list.h
new file mode 100644
index 000000000..a65cfcb7c
--- /dev/null
+++ b/hw/darwin/quartz/xpr/x-list.h
@@ -0,0 +1,78 @@
+/* x-list.h -- simple list type
+   $Id$
+
+   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/xpr/x-list.h,v 1.2 2003/06/30 01:45:13 torrey Exp $ */
+
+#ifndef X_LIST_H
+#define X_LIST_H 1
+
+/* This is just a cons. */
+
+typedef struct x_list_struct x_list;
+
+struct x_list_struct {
+    void *data;
+    x_list *next;
+};
+
+#ifndef X_PFX
+# define X_PFX(x) x_ ## x
+#endif
+
+#ifndef X_EXTERN
+# define X_EXTERN __private_extern__
+#endif
+
+X_EXTERN void X_PFX (list_free_1) (x_list *node);
+X_EXTERN x_list *X_PFX (list_prepend) (x_list *lst, void *data);
+
+X_EXTERN x_list *X_PFX (list_append) (x_list *lst, void *data);
+X_EXTERN x_list *X_PFX (list_remove) (x_list *lst, void *data);
+X_EXTERN void X_PFX (list_free) (x_list *lst);
+
+X_EXTERN x_list *X_PFX (list_copy) (x_list *lst);
+X_EXTERN x_list *X_PFX (list_reverse) (x_list *lst);
+X_EXTERN x_list *X_PFX (list_find) (x_list *lst, void *data);
+X_EXTERN x_list *X_PFX (list_nth) (x_list *lst, int n);
+X_EXTERN x_list *X_PFX (list_filter) (x_list *src,
+				      int (*pred) (void *item, void *data),
+				      void *data);
+X_EXTERN x_list *X_PFX (list_map) (x_list *src,
+				   void *(*fun) (void *item, void *data),
+				   void *data);
+
+X_EXTERN unsigned int X_PFX (list_length) (x_list *lst);
+X_EXTERN void X_PFX (list_foreach) (x_list *lst, void (*fun)
+				    (void *data, void *user_data),
+				    void *user_data);
+
+X_EXTERN x_list *X_PFX (list_sort) (x_list *lst, int (*less) (const void *,
+							    const void *));
+
+#endif /* X_LIST_H */
diff --git a/hw/darwin/quartz/xpr/xpr.h b/hw/darwin/quartz/xpr/xpr.h
new file mode 100644
index 000000000..3d447b226
--- /dev/null
+++ b/hw/darwin/quartz/xpr/xpr.h
@@ -0,0 +1,47 @@
+/*
+ * Xplugin rootless implementation
+ */
+/*
+ * Copyright (c) 2003 Torrey T. Lyons. 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/xpr/xpr.h,v 1.4 2003/11/12 20:21:52 torrey Exp $ */
+
+#ifndef XPR_H
+#define XPR_H
+
+#include "screenint.h"
+
+extern Bool QuartzModeBundleInit(void);
+
+void AppleDRIExtensionInit(void);
+void xprAppleWMInit(void);
+Bool xprInit(ScreenPtr pScreen);
+Bool xprIsX11Window(void *nsWindow, int windowNumber);
+
+Bool QuartzInitCursor(ScreenPtr pScreen);
+void QuartzSuspendXCursor(ScreenPtr pScreen);
+void QuartzResumeXCursor(ScreenPtr pScreen, int x, int y);
+
+#endif /* XPR_H */
diff --git a/hw/darwin/quartz/xpr/xprAppleWM.c b/hw/darwin/quartz/xpr/xprAppleWM.c
new file mode 100644
index 000000000..eca0de334
--- /dev/null
+++ b/hw/darwin/quartz/xpr/xprAppleWM.c
@@ -0,0 +1,99 @@
+/*
+ * Xplugin rootless implementation functions for AppleWM extension
+ */
+/*
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003 Torrey T. Lyons. 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/xpr/xprAppleWM.c,v 1.1 2003/09/16 00:36:15 torrey Exp $ */
+
+#include "xpr.h"
+#include "applewmExt.h"
+#include "rootless.h"
+#include "Xplugin.h"
+#include "X.h"
+
+
+static int xprSetWindowLevel(
+    WindowPtr pWin,
+    int level)
+{
+    xp_window_id wid;
+    xp_window_changes wc;
+
+    wid = (xp_window_id) RootlessFrameForWindow (pWin, TRUE);
+    if (wid == 0)
+        return BadWindow;
+
+    RootlessStopDrawing (pWin, FALSE);
+
+    wc.window_level = level;
+    if (xp_configure_window (wid, XP_WINDOW_LEVEL, &wc) != Success) {
+        return BadValue;
+    }
+
+    return Success;
+}
+
+
+static int xprFrameDraw(
+    WindowPtr pWin,
+    int class,
+    unsigned int attr,
+    const BoxRec *outer,
+    const BoxRec *inner,
+    unsigned int title_len,
+    const unsigned char *title_bytes)
+{
+    xp_window_id wid;
+
+    wid = (xp_window_id) RootlessFrameForWindow (pWin, FALSE);
+    if (wid == 0)
+        return BadWindow;
+
+    if (xp_frame_draw (wid, class, attr, outer, inner,
+                       title_len, title_bytes) != Success)
+    {
+        return BadValue;
+    }
+
+    return Success;
+}
+
+
+static AppleWMProcsRec xprAppleWMProcs = {
+    xp_disable_update,
+    xp_reenable_update,
+    xprSetWindowLevel,
+    xp_frame_get_rect,
+    xp_frame_hit_test,
+    xprFrameDraw
+};
+
+
+void xprAppleWMInit(void)
+{
+    AppleWMExtensionInit(&xprAppleWMProcs);
+}
diff --git a/hw/darwin/quartz/xpr/xprCursor.c b/hw/darwin/quartz/xpr/xprCursor.c
new file mode 100644
index 000000000..a3dea69e2
--- /dev/null
+++ b/hw/darwin/quartz/xpr/xprCursor.c
@@ -0,0 +1,420 @@
+/**************************************************************
+ *
+ * Xplugin cursor support
+ *
+ **************************************************************/
+/*
+ * Copyright (c) 2001 Torrey T. Lyons and Greg Parker.
+ * 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/xpr/xprCursor.c,v 1.2 2003/09/16 00:36:15 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "xpr.h"
+#include "darwin.h"
+#include "Xplugin.h"
+
+#include "mi.h"
+#include "scrnintstr.h"
+#include "cursorstr.h"
+#include "mipointrst.h"
+#include "windowstr.h"
+#include "globals.h"
+#include "servermd.h"
+#include "dixevents.h"
+
+typedef struct {
+    int                     cursorVisible;
+    QueryBestSizeProcPtr    QueryBestSize;
+    miPointerSpriteFuncPtr  spriteFuncs;
+} QuartzCursorScreenRec, *QuartzCursorScreenPtr;
+
+static int darwinCursorScreenIndex = -1;
+static unsigned long darwinCursorGeneration = 0;
+
+#define CURSOR_PRIV(pScreen) \
+    ((QuartzCursorScreenPtr)pScreen->devPrivates[darwinCursorScreenIndex].ptr)
+
+
+static Bool
+load_cursor(CursorPtr src, int screen)
+{
+    uint32_t *data;
+    uint32_t rowbytes;
+    int width, height;
+    int hot_x, hot_y;
+
+    uint32_t fg_color, bg_color;
+    uint8_t *srow, *sptr;
+    uint8_t *mrow, *mptr;
+    uint32_t *drow, *dptr;
+    unsigned xcount, ycount;
+
+    xp_error err;
+
+    width = src->bits->width;
+    height = src->bits->height;
+    hot_x = src->bits->xhot;
+    hot_y = src->bits->yhot;
+
+#ifdef ARGB_CURSOR
+    if (src->bits->argb != NULL)
+    {
+        rowbytes = src->bits->width * sizeof(CARD32);
+        data = (uint32_t *) src->bits->argb;
+    }
+    else
+#endif
+    {
+        fg_color = 0xFF00 | (src->foreRed >> 8);
+        fg_color <<= 16;
+        fg_color |= src->foreGreen & 0xFF00;
+        fg_color |= src->foreBlue >> 8;
+
+        bg_color = 0xFF00 | (src->backRed >> 8);
+        bg_color <<= 16;
+        bg_color |= src->backGreen & 0xFF00;
+        bg_color |= src->backBlue >> 8;
+
+        fg_color = htonl(fg_color);
+        bg_color = htonl(bg_color);
+
+        /* round up to 8 pixel boundary so we can convert whole bytes */
+        rowbytes = ((src->bits->width * 4) + 31) & ~31;
+        data = alloca(rowbytes * src->bits->height);
+
+        if (!src->bits->emptyMask)
+        {
+            ycount = src->bits->height;
+            srow = src->bits->source; mrow = src->bits->mask;
+            drow = data;
+
+            while (ycount-- > 0)
+            {
+                xcount = (src->bits->width + 7) / 8;
+                sptr = srow; mptr = mrow;
+                dptr = drow;
+
+                while (xcount-- > 0)
+                {
+                    uint8_t s, m;
+                    int i;
+
+                    s = *sptr++; m = *mptr++;
+                    for (i = 0; i < 8; i++)
+                    {
+#if BITMAP_BIT_ORDER == MSBFirst
+                        if (m & 128)
+                            *dptr++ = (s & 128) ? fg_color : bg_color;
+                        else
+                            *dptr++ = 0;
+                        s <<= 1; m <<= 1;
+#else
+                        if (m & 1)
+                            *dptr++ = (s & 1) ? fg_color : bg_color;
+                        else
+                            *dptr++ = 0;
+                        s >>= 1; m >>= 1;
+#endif
+                    }
+                }
+
+                srow += BitmapBytePad(src->bits->width);
+                mrow += BitmapBytePad(src->bits->width);
+                drow = (uint32_t *) ((char *) drow + rowbytes);
+            }
+        }
+        else
+        {
+            memset(data, 0, src->bits->height * rowbytes);
+        }
+    }
+
+    err = xp_set_cursor(width, height, hot_x, hot_y, data, rowbytes);
+    return err == Success;
+}
+
+
+/*
+===========================================================================
+
+ Pointer sprite functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzRealizeCursor
+ *  Convert the X cursor representation to native format if possible.
+ */
+static Bool
+QuartzRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
+{
+    if(pCursor == NULL || pCursor->bits == NULL)
+        return FALSE;
+
+    /* FIXME: cache ARGB8888 representation? */
+
+    return TRUE;
+}
+
+
+/*
+ * QuartzUnrealizeCursor
+ *  Free the storage space associated with a realized cursor.
+ */
+static Bool
+QuartzUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
+{
+    return TRUE;
+}
+
+
+/*
+ * QuartzSetCursor
+ *  Set the cursor sprite and position.
+ */
+static void
+QuartzSetCursor(ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if (!quartzServerVisible)
+        return;
+
+    if (pCursor == NULL)
+    {
+        if (ScreenPriv->cursorVisible)
+        {
+            xp_hide_cursor();
+            ScreenPriv->cursorVisible = FALSE;
+        }
+    }
+    else
+    {
+        load_cursor(pCursor, pScreen->myNum);
+
+        if (!ScreenPriv->cursorVisible)
+        {
+            xp_show_cursor();
+            ScreenPriv->cursorVisible = TRUE;
+        }
+    }
+}
+
+
+/*
+ * QuartzMoveCursor
+ *  Move the cursor. This is a noop for us.
+ */
+static void
+QuartzMoveCursor(ScreenPtr pScreen, int x, int y)
+{
+}
+
+
+static miPointerSpriteFuncRec quartzSpriteFuncsRec = {
+    QuartzRealizeCursor,
+    QuartzUnrealizeCursor,
+    QuartzSetCursor,
+    QuartzMoveCursor
+};
+
+
+/*
+===========================================================================
+
+ Pointer screen functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzCursorOffScreen
+ */
+static Bool
+QuartzCursorOffScreen(ScreenPtr *pScreen, int *x, int *y)
+{
+    return FALSE;
+}
+
+
+/*
+ * QuartzCrossScreen
+ */
+static void
+QuartzCrossScreen(ScreenPtr pScreen, Bool entering)
+{
+    return;
+}
+
+
+/*
+ * QuartzWarpCursor
+ *  Change the cursor position without generating an event or motion history.
+ *  The input coordinates (x,y) are in pScreen-local X11 coordinates.
+ *
+ */
+static void
+QuartzWarpCursor(ScreenPtr pScreen, int x, int y)
+{
+    static Bool neverMoved = TRUE;
+
+    if (neverMoved)
+    {
+        /* Don't move the cursor the first time. This is the
+           jump-to-center initialization, and it's annoying. */
+        neverMoved = FALSE;
+        return;
+    }
+
+    if (quartzServerVisible)
+    {
+        int sx, sy;
+
+        sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
+        sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
+
+        CGWarpMouseCursorPosition(CGPointMake(sx + x, sy + y));
+    }
+
+    miPointerWarpCursor(pScreen, x, y);
+    miPointerUpdate();
+}
+
+
+static miPointerScreenFuncRec quartzScreenFuncsRec = {
+    QuartzCursorOffScreen,
+    QuartzCrossScreen,
+    QuartzWarpCursor,
+    DarwinEQPointerPost,
+    DarwinEQSwitchScreen
+};
+
+
+/*
+===========================================================================
+
+ Other screen functions
+
+===========================================================================
+*/
+
+/*
+ * QuartzCursorQueryBestSize
+ *  Handle queries for best cursor size
+ */
+static void
+QuartzCursorQueryBestSize(int class, unsigned short *width,
+                          unsigned short *height, ScreenPtr pScreen)
+{
+    QuartzCursorScreenPtr ScreenPriv = CURSOR_PRIV(pScreen);
+
+    if (class == CursorShape)
+    {
+        /* FIXME: query window server? */
+        *width = 32;
+        *height = 32;
+    }
+    else
+    {
+        (*ScreenPriv->QueryBestSize)(class, width, height, pScreen);
+    }
+}
+
+/*
+ * QuartzInitCursor
+ *  Initialize cursor support
+ */
+Bool
+QuartzInitCursor(ScreenPtr pScreen)
+{
+    QuartzCursorScreenPtr ScreenPriv;
+    miPointerScreenPtr PointPriv;
+
+    /* initialize software cursor handling (always needed as backup) */
+    if (!miDCInitialize(pScreen, &quartzScreenFuncsRec))
+        return FALSE;
+
+    /* allocate private storage for this screen's QuickDraw cursor info */
+    if (darwinCursorGeneration != serverGeneration)
+    {
+        if ((darwinCursorScreenIndex = AllocateScreenPrivateIndex()) < 0)
+            return FALSE;
+
+        darwinCursorGeneration = serverGeneration;
+    }
+
+    ScreenPriv = xcalloc(1, sizeof(QuartzCursorScreenRec));
+    if (ScreenPriv == NULL)
+        return FALSE;
+
+    CURSOR_PRIV(pScreen) = ScreenPriv;
+
+    /* override some screen procedures */
+    ScreenPriv->QueryBestSize = pScreen->QueryBestSize;
+    pScreen->QueryBestSize = QuartzCursorQueryBestSize;
+
+    PointPriv = (miPointerScreenPtr) pScreen->devPrivates[miPointerScreenIndex].ptr;
+
+    ScreenPriv->spriteFuncs = PointPriv->spriteFuncs;
+    PointPriv->spriteFuncs = &quartzSpriteFuncsRec;
+
+    ScreenPriv->cursorVisible = TRUE;
+    return TRUE;
+}
+
+
+/*
+ * QuartzSuspendXCursor
+ *  X server is hiding. Restore the Aqua cursor.
+ */
+void
+QuartzSuspendXCursor(ScreenPtr pScreen)
+{
+}
+
+
+/*
+ * QuartzResumeXCursor
+ *  X server is showing. Restore the X cursor.
+ */
+void
+QuartzResumeXCursor(ScreenPtr pScreen, int x, int y)
+{
+    WindowPtr pWin;
+    CursorPtr pCursor;
+
+    pWin = GetSpriteWindow();
+    if (pWin->drawable.pScreen != pScreen)
+        return;
+
+    pCursor = GetSpriteCursor();
+    if (pCursor == NULL)
+        return;
+
+    QuartzSetCursor(pScreen, pCursor, x, y);
+}
diff --git a/hw/darwin/quartz/xpr/xprFrame.c b/hw/darwin/quartz/xpr/xprFrame.c
new file mode 100644
index 000000000..ae24bc42a
--- /dev/null
+++ b/hw/darwin/quartz/xpr/xprFrame.c
@@ -0,0 +1,439 @@
+/*
+ * Xplugin rootless implementation frame functions
+ */
+/*
+ * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003 Torrey T. Lyons. 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/xpr/xprFrame.c,v 1.4 2003/11/12 20:21:52 torrey Exp $ */
+
+#include "xpr.h"
+#include "rootless.h"
+#include "Xplugin.h"
+#include "x-hash.h"
+#include "x-list.h"
+
+#include "propertyst.h"
+#include "dix.h"
+#include "Xatom.h"
+#include "windowstr.h"
+
+#include <pthread.h>
+
+#define DEFINE_ATOM_HELPER(func,atom_name)			\
+static Atom func (void) {					\
+    static int generation;					\
+    static Atom atom;						\
+    if (generation != serverGeneration) {			\
+        generation = serverGeneration;				\
+        atom = MakeAtom (atom_name, strlen (atom_name), TRUE);	\
+    }								\
+    return atom;						\
+}
+
+DEFINE_ATOM_HELPER(xa_native_window_id, "_NATIVE_WINDOW_ID")
+
+/* Maps xp_window_id -> RootlessWindowRec */
+static x_hash_table *window_hash;
+static pthread_mutex_t window_hash_mutex;
+
+static Bool no_configure_window;
+
+
+static inline xp_error
+xprConfigureWindow(xp_window_id id, unsigned int mask,
+                   const xp_window_changes *values)
+{
+    if (!no_configure_window)
+        return xp_configure_window(id, mask, values);
+    else
+        return XP_Success;
+}
+
+
+static void
+xprSetNativeProperty(RootlessWindowPtr pFrame)
+{
+    xp_error err;
+    unsigned int native_id;
+    long data;
+
+    err = xp_get_native_window((xp_window_id) pFrame->wid, &native_id);
+    if (err == Success)
+    {
+        /* FIXME: move this to AppleWM extension */
+
+        data = native_id;
+        ChangeWindowProperty(pFrame->win, xa_native_window_id(),
+                             XA_INTEGER, 32, PropModeReplace, 1, &data, TRUE);
+    }
+}
+
+
+/*
+ * Create and display a new frame.
+ */
+Bool
+xprCreateFrame(RootlessWindowPtr pFrame, ScreenPtr pScreen,
+               int newX, int newY, RegionPtr pShape)
+{
+    WindowPtr pWin = pFrame->win;
+    xp_window_changes wc;
+    unsigned int mask = 0;
+    xp_error err;
+
+    wc.x = newX;
+    wc.y = newY;
+    wc.width = pFrame->width;
+    wc.height = pFrame->height;
+    wc.bit_gravity = XP_GRAVITY_NONE;
+    mask |= XP_BOUNDS;
+
+    if (pWin->drawable.depth == 8)
+    {
+        wc.depth = XP_DEPTH_INDEX8;
+#if 0
+        wc.colormap = xprColormapCallback;
+        wc.colormap_data = pScreen;
+        mask |= XP_COLORMAP;
+#endif
+    }
+    else if (pWin->drawable.depth == 15)
+        wc.depth = XP_DEPTH_RGB555;
+    else if (pWin->drawable.depth == 24)
+        wc.depth = XP_DEPTH_ARGB8888;
+    else
+        wc.depth = XP_DEPTH_NIL;
+    mask |= XP_DEPTH;
+
+    if (pShape != NULL)
+    {
+        wc.shape_nrects = REGION_NUM_RECTS(pShape);
+        wc.shape_rects = REGION_RECTS(pShape);
+        wc.shape_tx = wc.shape_ty = 0;
+        mask |= XP_SHAPE;
+    }
+
+    err = xp_create_window(mask, &wc, (xp_window_id *) &pFrame->wid);
+
+    if (err != Success)
+    {
+        return FALSE;
+    }
+
+    if (window_hash == NULL)
+    {
+        window_hash = x_hash_table_new(NULL, NULL, NULL, NULL);
+        pthread_mutex_init(&window_hash_mutex, NULL);
+    }
+
+    pthread_mutex_lock(&window_hash_mutex);
+    x_hash_table_insert(window_hash, pFrame->wid, pFrame);
+    pthread_mutex_unlock(&window_hash_mutex);
+
+    xprSetNativeProperty(pFrame);
+
+    return TRUE;
+}
+
+
+/*
+ * Destroy a frame.
+ */
+void
+xprDestroyFrame(RootlessFrameID wid)
+{
+    pthread_mutex_lock(&window_hash_mutex);
+    x_hash_table_remove(window_hash, wid);
+    pthread_mutex_unlock(&window_hash_mutex);
+
+    xp_destroy_window((xp_window_id) wid);
+}
+
+
+/*
+ * Move a frame on screen.
+ */
+void
+xprMoveFrame(RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY)
+{
+    xp_window_changes wc;
+
+    wc.x = newX;
+    wc.y = newY;
+
+    xprConfigureWindow((xp_window_id) wid, XP_ORIGIN, &wc);
+}
+
+
+/*
+ * Resize and move a frame.
+ */
+void
+xprResizeFrame(RootlessFrameID wid, ScreenPtr pScreen,
+               int newX, int newY, unsigned int newW, unsigned int newH,
+               unsigned int gravity)
+{
+    xp_window_changes wc;
+
+    wc.x = newX;
+    wc.y = newY;
+    wc.width = newW;
+    wc.height = newH;
+    wc.bit_gravity = gravity;
+
+    /* It's unlikely that being async will save us anything here.
+       But it can't hurt. */
+
+    xprConfigureWindow((xp_window_id) wid, XP_BOUNDS, &wc);
+}
+
+
+/*
+ * Change frame stacking.
+ */
+void
+xprRestackFrame(RootlessFrameID wid, RootlessFrameID nextWid)
+{
+    xp_window_changes wc;
+
+    /* Stack frame below nextWid it if it exists, or raise
+       frame above everything otherwise. */
+
+    if (nextWid == NULL)
+    {
+        wc.stack_mode = XP_MAPPED_ABOVE;
+        wc.sibling = 0;
+    }
+    else
+    {
+        wc.stack_mode = XP_MAPPED_BELOW;
+        wc.sibling = (xp_window_id) nextWid;
+    }
+
+    xprConfigureWindow((xp_window_id) wid, XP_STACKING, &wc);
+}
+
+
+/*
+ * Change the frame's shape.
+ */
+void
+xprReshapeFrame(RootlessFrameID wid, RegionPtr pShape)
+{
+    xp_window_changes wc;
+
+    if (pShape != NULL)
+    {
+        wc.shape_nrects = REGION_NUM_RECTS(pShape);
+        wc.shape_rects = REGION_RECTS(pShape);
+    }
+    else
+    {
+        wc.shape_nrects = -1;
+        wc.shape_rects = NULL;
+    }
+
+    wc.shape_tx = wc.shape_ty = 0;
+
+    xprConfigureWindow((xp_window_id) wid, XP_SHAPE, &wc);
+}
+
+
+/*
+ * Unmap a frame.
+ */
+void
+xprUnmapFrame(RootlessFrameID wid)
+{
+    xp_window_changes wc;
+
+    wc.stack_mode = XP_UNMAPPED;
+    wc.sibling = 0;
+
+    xprConfigureWindow((xp_window_id) wid, XP_STACKING, &wc);
+}
+
+
+/*
+ * Start drawing to a frame.
+ *  Prepare for direct access to its backing buffer.
+ */
+void
+xprStartDrawing(RootlessFrameID wid, char **pixelData, int *bytesPerRow)
+{
+    void *data[2];
+    unsigned int rowbytes[2];
+    xp_error err;
+
+    err = xp_lock_window((xp_window_id) wid, NULL, NULL, data, rowbytes, NULL);
+    if (err != Success)
+        FatalError("Could not lock window %i for drawing.", (int) wid);
+
+    *pixelData = data[0];
+    *bytesPerRow = rowbytes[0];
+}
+
+
+/*
+ * Stop drawing to a frame.
+ */
+void
+xprStopDrawing(RootlessFrameID wid, Bool flush)
+{
+    xp_unlock_window((xp_window_id) wid, flush);
+}
+
+
+/*
+ * Flush drawing updates to the screen.
+ */
+void
+xprUpdateRegion(RootlessFrameID wid, RegionPtr pDamage)
+{
+    xp_flush_window((xp_window_id) wid);
+}
+
+
+/*
+ * Mark damaged rectangles as requiring redisplay to screen.
+ */
+void
+xprDamageRects(RootlessFrameID wid, int nrects, const BoxRec *rects,
+               int shift_x, int shift_y)
+{
+    xp_mark_window((xp_window_id) wid, nrects, rects, shift_x, shift_y);
+}
+
+
+/*
+ * Called after the window associated with a frame has been switched
+ * to a new top-level parent.
+ */
+void
+xprSwitchWindow(RootlessWindowPtr pFrame, WindowPtr oldWin)
+{
+    DeleteProperty(oldWin, xa_native_window_id());
+
+    xprSetNativeProperty(pFrame);
+}
+
+
+/*
+ * Copy area in frame to another part of frame.
+ *  Used to accelerate scrolling.
+ */
+void
+xprCopyWindow(RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
+              int dx, int dy)
+{
+    xp_copy_window((xp_window_id) wid, (xp_window_id) wid,
+                   dstNrects, dstRects, dx, dy);
+}
+
+
+static RootlessFrameProcsRec xprRootlessProcs = {
+    xprCreateFrame,
+    xprDestroyFrame,
+    xprMoveFrame,
+    xprResizeFrame,
+    xprRestackFrame,
+    xprReshapeFrame,
+    xprUnmapFrame,
+    xprStartDrawing,
+    xprStopDrawing,
+    xprUpdateRegion,
+    xprDamageRects,
+    xprSwitchWindow,
+    xp_copy_bytes,
+    xp_fill_bytes,
+    xp_composite_pixels,
+    xprCopyWindow
+};
+
+
+/*
+ * Initialize XPR implementation
+ */
+Bool
+xprInit(ScreenPtr pScreen)
+{
+    RootlessInit(pScreen, &xprRootlessProcs);
+
+    rootless_CopyBytes_threshold = xp_copy_bytes_threshold;
+    rootless_FillBytes_threshold = xp_fill_bytes_threshold;
+    rootless_CompositePixels_threshold = xp_composite_area_threshold;
+    rootless_CopyWindow_threshold = xp_scroll_area_threshold;
+
+    no_configure_window = FALSE;
+
+    return TRUE;
+}
+
+
+/*
+ * Given the id of a physical window, try to find the top-level (or root)
+ * X window that it represents.
+ */
+static WindowPtr
+xprGetXWindow(xp_window_id wid)
+{
+    RootlessWindowRec *winRec;
+
+    if (window_hash == NULL)
+        return NULL;
+
+    winRec = x_hash_table_lookup(window_hash, (void *) wid, NULL);
+
+    return winRec != NULL ? winRec->win : NULL;
+}
+
+
+/*
+ * The windowNumber is an AppKit window number. Returns TRUE if xpr is
+ * displaying a window with that number.
+ */
+Bool
+xprIsX11Window(void *nsWindow, int windowNumber)
+{
+    Bool ret;
+    xp_window_id wid;
+
+    if (window_hash == NULL)
+        return FALSE;
+
+    /* need to lock, since this function can be called by any thread */
+
+    pthread_mutex_lock(&window_hash_mutex);
+
+    if (xp_lookup_native_window(windowNumber, &wid))
+        ret = xprGetXWindow(wid) != NULL;
+    else
+        ret = FALSE;
+
+    pthread_mutex_unlock(&window_hash_mutex);
+
+    return ret;
+}
diff --git a/hw/darwin/quartz/xpr/xprScreen.c b/hw/darwin/quartz/xpr/xprScreen.c
new file mode 100644
index 000000000..8090a27b1
--- /dev/null
+++ b/hw/darwin/quartz/xpr/xprScreen.c
@@ -0,0 +1,378 @@
+/*
+ * Xplugin rootless implementation screen functions
+ */
+/*
+ * Copyright (c) 2002 Apple Computer, Inc. All Rights Reserved.
+ * Copyright (c) 2003 Torrey T. Lyons. 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/xpr/xprScreen.c,v 1.8 2003/11/12 20:21:52 torrey Exp $ */
+
+#include "quartzCommon.h"
+#include "quartz.h"
+#include "xpr.h"
+#include "pseudoramiX.h"
+#include "darwin.h"
+#include "rootless.h"
+#include "safeAlpha.h"
+#include "dri.h"
+#include "globals.h"
+#include "Xplugin.h"
+#include "applewmExt.h"
+
+// Name of GLX bundle for native OpenGL
+static const char *xprOpenGLBundle = "glxCGL.bundle";
+
+
+/*
+ * eventHandler
+ *  Callback handler for Xplugin events.
+ */
+static void
+eventHandler(unsigned int type, const void *arg,
+             unsigned int arg_size, void *data)
+{
+    switch (type)
+    {
+    case XP_EVENT_DISPLAY_CHANGED:
+	QuartzMessageServerThread(kXDarwinDisplayChanged, 0);
+	break;
+
+    case XP_EVENT_WINDOW_STATE_CHANGED:
+	if (arg_size >= sizeof(xp_window_state_event))
+        {
+	    const xp_window_state_event *ws_arg = arg;
+	    QuartzMessageServerThread(kXDarwinWindowState, 2,
+                                      ws_arg->id, ws_arg->state);
+	}
+	break;
+
+    case XP_EVENT_WINDOW_MOVED:
+	if (arg_size == sizeof(xp_window_id))
+	{
+	    xp_window_id id = * (xp_window_id *) arg;
+
+	    QuartzMessageServerThread(kXDarwinWindowMoved, 1, id);
+	}
+	break;
+
+    case XP_EVENT_SURFACE_DESTROYED:
+    case XP_EVENT_SURFACE_CHANGED:
+	if (arg_size == sizeof(xp_surface_id))
+	{
+	    int kind;
+
+	    if (type == XP_EVENT_SURFACE_DESTROYED)
+		kind = AppleDRISurfaceNotifyDestroyed;
+	    else
+		kind = AppleDRISurfaceNotifyChanged;
+
+	    DRISurfaceNotify(*(xp_surface_id *) arg, kind);
+	}
+	break;
+    }
+}
+
+
+/*
+ * displayScreenBounds
+ *  Return the display ID for a particular display index.
+ */
+static CGDirectDisplayID
+displayAtIndex(int index)
+{
+    CGError err;
+    CGDisplayCount cnt;
+    CGDirectDisplayID dpy[index+1];
+
+    err = CGGetActiveDisplayList(index + 1, dpy, &cnt);
+    if (err == kCGErrorSuccess && cnt == index + 1)
+        return dpy[index];
+    else
+        return kCGNullDirectDisplay;
+}
+
+
+/*
+ * displayScreenBounds
+ *  Return the bounds of a particular display.
+ */
+static CGRect
+displayScreenBounds(CGDirectDisplayID id)
+{
+    CGRect frame;
+
+    frame = CGDisplayBounds(id);
+
+    /* Remove menubar to help standard X11 window managers. */
+
+    if (frame.origin.x == 0 && frame.origin.y == 0)
+    {
+        frame.origin.y += aquaMenuBarHeight;
+        frame.size.height -= aquaMenuBarHeight;
+    }
+
+    return frame;
+}
+
+
+/*
+ * addPseudoramiXScreens
+ *  Add a physical screen with PseudoramiX.
+ */
+static void
+addPseudoramiXScreens(int *x, int *y, int *width, int *height)
+{
+    CGDisplayCount i, displayCount;
+    CGDirectDisplayID *displayList = NULL;
+    CGRect unionRect = CGRectNull, frame;
+
+    // Find all the CoreGraphics displays
+    CGGetActiveDisplayList(0, NULL, &displayCount);
+    displayList = xalloc(displayCount * sizeof(CGDirectDisplayID));
+    CGGetActiveDisplayList(displayCount, displayList, &displayCount);
+
+    /* Get the union of all screens */
+    for (i = 0; i < displayCount; i++)
+    {
+        CGDirectDisplayID dpy = displayList[i];
+        frame = displayScreenBounds(dpy);
+        unionRect = CGRectUnion(unionRect, frame);
+    }
+
+    /* Use unionRect as the screen size for the X server. */
+    *x = unionRect.origin.x;
+    *y = unionRect.origin.y;
+    *width = unionRect.size.width;
+    *height = unionRect.size.height;
+
+    /* Tell PseudoramiX about the real screens. */
+    for (i = 0; i < displayCount; i++)
+    {
+        CGDirectDisplayID dpy = displayList[i];
+
+        frame = displayScreenBounds(dpy);
+
+        ErrorF("PseudoramiX screen %d added: %dx%d @ (%d,%d).\n", i,
+               (int)frame.size.width, (int)frame.size.height,
+               (int)frame.origin.x, (int)frame.origin.y);
+
+        frame.origin.x -= unionRect.origin.x;
+        frame.origin.y -= unionRect.origin.y;
+
+        ErrorF("PseudoramiX screen %d placed at X11 coordinate (%d,%d).\n",
+               i, (int)frame.origin.x, (int)frame.origin.y);
+
+        PseudoramiXAddScreen(frame.origin.x, frame.origin.y,
+                             frame.size.width, frame.size.height);
+    }
+
+    xfree(displayList);
+}
+
+
+/*
+ * xprDisplayInit
+ *  Find number of CoreGraphics displays and initialize Xplugin.
+ */
+static void
+xprDisplayInit(void)
+{
+    CGDisplayCount displayCount;
+
+    ErrorF("Display mode: Rootless Quartz -- Xplugin implementation\n");
+
+    CGGetActiveDisplayList(0, NULL, &displayCount);
+
+    /* With PseudoramiX, the X server only sees one screen; only PseudoramiX
+       itself knows about all of the screens. */
+
+    if (noPseudoramiXExtension)
+        darwinScreensFound = displayCount;
+    else
+        darwinScreensFound =  1;
+
+    if (xp_init(XP_IN_BACKGROUND) != Success)
+    {
+        FatalError("Could not initialize the Xplugin library.");
+    }
+
+    xp_select_events(XP_EVENT_DISPLAY_CHANGED
+                     | XP_EVENT_WINDOW_STATE_CHANGED
+                     | XP_EVENT_WINDOW_MOVED
+                     | XP_EVENT_SURFACE_CHANGED
+                     | XP_EVENT_SURFACE_DESTROYED,
+                     eventHandler, NULL);
+
+    AppleDRIExtensionInit();
+    xprAppleWMInit();
+}
+
+
+/*
+ * xprAddScreen
+ *  Init the framebuffer and record pixmap parameters for the screen.
+ */
+static Bool
+xprAddScreen(int index, ScreenPtr pScreen)
+{
+    DarwinFramebufferPtr dfb = SCREEN_PRIV(pScreen);
+
+    /* If no specific depth chosen, look for the depth of the main display.
+       Else if 16bpp specified, use that. Else use 32bpp. */
+
+    dfb->colorType = TrueColor;
+    dfb->bitsPerComponent = 8;
+    dfb->bitsPerPixel = 32;
+    dfb->colorBitsPerPixel = 24;
+
+    if (darwinDesiredDepth == -1)
+    {
+        dfb->bitsPerComponent = CGDisplayBitsPerSample(kCGDirectMainDisplay);
+        dfb->bitsPerPixel = CGDisplayBitsPerPixel(kCGDirectMainDisplay);
+        dfb->colorBitsPerPixel =
+                CGDisplaySamplesPerPixel(kCGDirectMainDisplay) *
+                dfb->bitsPerComponent;
+    }
+    else if (darwinDesiredDepth == 15)
+    {
+        dfb->bitsPerComponent = 5;
+        dfb->bitsPerPixel = 16;
+        dfb->colorBitsPerPixel = 15;
+    }
+    else if (darwinDesiredDepth == 8)
+    {
+        dfb->colorType = PseudoColor;
+        dfb->bitsPerComponent = 8;
+        dfb->bitsPerPixel = 8;
+        dfb->colorBitsPerPixel = 8;
+    }
+
+    if (noPseudoramiXExtension)
+    {
+        CGDirectDisplayID dpy;
+        CGRect frame;
+
+        dpy = displayAtIndex(index);
+
+        frame = displayScreenBounds(dpy);
+
+        dfb->x = frame.origin.x;
+        dfb->y = frame.origin.y;
+        dfb->width =  frame.size.width;
+        dfb->height = frame.size.height;
+    }
+    else
+    {
+        addPseudoramiXScreens(&dfb->x, &dfb->y, &dfb->width, &dfb->height);
+    }
+
+    /* Passing zero width (pitch) makes miCreateScreenResources set the
+       screen pixmap to the framebuffer pointer, i.e. NULL. The generic
+       rootless code takes care of making this work. */
+    dfb->pitch = 0;
+    dfb->framebuffer = NULL;
+
+    DRIScreenInit(pScreen);
+
+    return TRUE;
+}
+
+
+/*
+ * xprSetupScreen
+ *  Setup the screen for rootless access.
+ */
+static Bool
+xprSetupScreen(int index, ScreenPtr pScreen)
+{
+    // Add alpha protecting replacements for fb screen functions
+    pScreen->PaintWindowBackground = SafeAlphaPaintWindow;
+    pScreen->PaintWindowBorder = SafeAlphaPaintWindow;
+
+#ifdef RENDER
+    {
+        PictureScreenPtr ps = GetPictureScreen(pScreen);
+        ps->Composite = SafeAlphaComposite;
+    }
+#endif /* RENDER */
+
+    // Initialize generic rootless code
+    if (!xprInit(pScreen))
+        return FALSE;
+
+    return DRIFinishScreenInit(pScreen);
+}
+
+
+/*
+ * xprInitInput
+ *  Finalize xpr specific setup.
+ */
+static void
+xprInitInput(int argc, char **argv)
+{
+    int i;
+
+    rootlessGlobalOffsetX = darwinMainScreenX;
+    rootlessGlobalOffsetY = darwinMainScreenY;
+
+    for (i = 0; i < screenInfo.numScreens; i++)
+        AppleWMSetScreenOrigin(WindowTable[i]);
+}
+
+
+/*
+ * Quartz display mode function list.
+ */
+static QuartzModeProcsRec xprModeProcs = {
+    xprDisplayInit,
+    xprAddScreen,
+    xprSetupScreen,
+    xprInitInput,
+    QuartzInitCursor,
+    NULL,               // No need to update cursor
+    QuartzSuspendXCursor,
+    QuartzResumeXCursor,
+    NULL,               // No capture or release in rootless mode
+    NULL,
+    xprIsX11Window,
+    RootlessFrameForWindow,
+    TopLevelParent,
+    DRICreateSurface,
+    DRIDestroySurface
+};
+
+
+/*
+ * QuartzModeBundleInit
+ *  Initialize the display mode bundle after loading.
+ */
+Bool
+QuartzModeBundleInit(void)
+{
+    quartzProcs = &xprModeProcs;
+    quartzOpenGLBundle = xprOpenGLBundle;
+    return TRUE;
+}
diff --git a/hw/xfree86/common/xf86AutoConfig.c b/hw/xfree86/common/xf86AutoConfig.c
new file mode 100644
index 000000000..7c773fee6
--- /dev/null
+++ b/hw/xfree86/common/xf86AutoConfig.c
@@ -0,0 +1,354 @@
+/* $DHD: xc/programs/Xserver/hw/xfree86/common/xf86AutoConfig.c,v 1.15 2003/09/24 19:39:36 dawes Exp $ */
+
+/*
+ * Copyright 2003 by David H. Dawes.
+ * Copyright 2003 by X-Oz Technologies.
+ * 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
+ * and author(s) 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 copyright holder(s) and author(s).
+ * 
+ * Author: David Dawes <dawes@XFree86.Org>.
+ */
+
+/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86AutoConfig.c,v 1.2 2003/11/03 05:11:01 tsi Exp $ */
+
+#include "xf86.h"
+#include "xf86Parser.h"
+#include "xf86tokens.h"
+#include "xf86Config.h"
+#include "xf86Priv.h"
+#include "xf86_OSlib.h"
+
+/*
+ * Sections for the default built-in configuration.
+ */
+
+#define BUILTIN_MODULE_SECTION \
+	"Section \"Module\"\n" \
+	"\tLoad\t\"extmod\"\n" \
+	"\tLoad\t\"dbe\"\n" \
+	"\tLoad\t\"glx\"\n" \
+	"\tLoad\t\"freetype\"\n" \
+	"EndSection\n\n"
+
+#define BUILTIN_DEVICE_NAME \
+	"\"Builtin Default %s Device %d\""
+
+#define BUILTIN_DEVICE_SECTION_PRE \
+	"Section \"Device\"\n" \
+	"\tIdentifier\t" BUILTIN_DEVICE_NAME "\n" \
+	"\tDriver\t\"%s\"\n"
+
+#define BUILTIN_DEVICE_SECTION_POST \
+	"EndSection\n\n"
+
+#define BUILTIN_DEVICE_SECTION \
+	BUILTIN_DEVICE_SECTION_PRE \
+	BUILTIN_DEVICE_SECTION_POST
+
+#define BUILTIN_MONITOR_NAME \
+	"\"Builtin Default Monitor\""
+
+#define BUILTIN_MONITOR_SECTION \
+	"Section \"Monitor\"\n" \
+	"\tIdentifier\t" BUILTIN_MONITOR_NAME "\n" \
+	"\tOption\t\"TargetRefresh\"\t\"75.0\"\n" \
+	"EndSection\n\n"
+
+#define BUILTIN_SCREEN_NAME \
+	"\"Builtin Default %s Screen %d\""
+
+#define BUILTIN_SCREEN_SECTION \
+	"Section \"Screen\"\n" \
+	"\tIdentifier\t" BUILTIN_SCREEN_NAME "\n" \
+	"\tDevice\t" BUILTIN_DEVICE_NAME "\n" \
+	"\tMonitor\t" BUILTIN_MONITOR_NAME "\n" \
+	"EndSection\n\n"
+
+#define BUILTIN_LAYOUT_SECTION_PRE \
+	"Section \"ServerLayout\"\n" \
+	"\tIdentifier\t\"Builtin Default Layout\"\n"
+
+#define BUILTIN_LAYOUT_SCREEN_LINE \
+	"\tScreen\t" BUILTIN_SCREEN_NAME "\n"
+
+#define BUILTIN_LAYOUT_SECTION_POST \
+	"EndSection\n\n"
+
+
+#ifndef GET_CONFIG_CMD
+#define GET_CONFIG_CMD			"getconfig"
+#endif
+
+#ifndef GETCONFIG_DIR
+#define GETCONFIG_DIR			PROJECTROOT "/lib/X11/getconfig"
+#endif
+
+#define GETCONFIG_WHITESPACE		" \t\n"
+
+static const char **builtinConfig = NULL;
+static int builtinLines = 0;
+static const char *deviceList[] = {
+	"fbdev",
+	"vesa",
+	"vga",
+	NULL
+};
+
+/*
+ * A built-in config file is stored as an array of strings, with each string
+ * representing a single line.  AppendToConfig() breaks up the string "s"
+ * into lines, and appends those lines it to builtinConfig.
+ */
+
+static void
+AppendToList(const char *s, const char ***list, int *lines)
+{
+    char *str, *newstr, *p;
+
+    str = xnfstrdup(s);
+    for (p = strtok(str, "\n"); p; p = strtok(NULL, "\n")) {
+	(*lines)++;
+	*list = xnfrealloc(*list, (*lines + 1) * sizeof(**list));
+	newstr = xnfalloc(strlen(p) + 2);
+	strcpy(newstr, p);
+	strcat(newstr, "\n");
+	(*list)[*lines - 1] = newstr;
+	(*list)[*lines] = NULL;
+    }
+    xfree(str);
+}
+
+static void
+FreeList(const char ***list, int *lines)
+{
+    int i;
+
+    for (i = 0; i < *lines; i++) {
+	if ((*list)[i])
+	    xfree((*list)[i]);
+    }
+    xfree(*list);
+    *list = NULL;
+    *lines = 0;
+}
+
+static void
+FreeConfig(void)
+{
+    FreeList(&builtinConfig, &builtinLines);
+}
+
+static void
+AppendToConfig(const char *s)
+{
+    AppendToList(s, &builtinConfig, &builtinLines);
+}
+
+Bool
+xf86AutoConfig(void)
+{
+    const char **p;
+    char buf[1024];
+    pciVideoPtr *pciptr, info = NULL;
+    char *driver = NULL;
+    FILE *gp = NULL;
+    ConfigStatus ret;
+
+    /* Find the primary device, and get some information about it. */
+    if (xf86PciVideoInfo) {
+	for (pciptr = xf86PciVideoInfo; (info = *pciptr); pciptr++) {
+	    if (xf86IsPrimaryPci(info)) {
+		break;
+	    }
+	}
+	if (!info) {
+	    ErrorF("Primary device is not PCI\n");
+	}
+    } else {
+	ErrorF("xf86PciVideoInfo is not set\n");
+    }
+
+    if (info) {
+	char *tmp;
+	char *path = NULL, *a, *b;
+	char *searchPath = NULL;
+
+	/*
+	 * Look for the getconfig program first in the xf86ModulePath
+	 * directories, then in BINDIR.  If it isn't found in any of those
+	 * locations, just use the normal search path.
+	 */
+
+	if (xf86ModulePath) {
+	    a = xnfstrdup(xf86ModulePath);
+	    b = strtok(a, ",");
+	    while (b) {
+		path = xnfrealloc(path,
+				  strlen(b) + 1 + strlen(GET_CONFIG_CMD) + 1);
+		sprintf(path, "%s/%s", b, GET_CONFIG_CMD);
+		if (access(path, X_OK) == 0)
+		    break;
+		b = strtok(NULL, ",");
+	    }
+	    if (!b) {
+		xfree(path);
+		path = NULL;
+	    }
+	    xfree(a);
+	}
+
+#ifdef BINDIR
+	if (!path) {
+	    path = xnfstrdup(BINDIR "/" GET_CONFIG_CMD);
+	    if (access(path, X_OK) != 0) {
+		xfree(path);
+		path = NULL;
+	    }
+	}
+#endif
+
+	if (!path)
+	    path = xnfstrdup(GET_CONFIG_CMD);
+
+	/*
+	 * Build up the config file directory search path:
+	 *
+	 * /etc/X11
+	 * PROJECTROOT/etc/X11
+	 * xf86ModulePath
+	 * PROJECTROOT/lib/X11/getconfig  (GETCONFIG_DIR)
+	 */
+
+	searchPath = xnfalloc(strlen("/etc/X11") + 1 +
+			      strlen(PROJECTROOT "/etc/X11") + 1 +
+			      (xf86ModulePath ? strlen(xf86ModulePath) : 0)
+				+ 1 +
+			      strlen(GETCONFIG_DIR) + 1);
+	strcpy(searchPath, "/etc/X11," PROJECTROOT "/etc/X11,");
+	if (xf86ModulePath && *xf86ModulePath) {
+	    strcat(searchPath, xf86ModulePath);
+	    strcat(searchPath, ",");
+	}
+	strcat(searchPath, GETCONFIG_DIR);
+
+	ErrorF("xf86AutoConfig: Primary PCI is %d:%d:%d\n",
+	       info->bus, info->device, info->func);
+
+	snprintf(buf, sizeof(buf), "%s"
+#ifdef DEBUG
+		 " -D"
+#endif
+		 " -X %d"
+		 " -I %s"
+		 " -v 0x%04x -d 0x%04x -r 0x%02x -s 0x%04x"
+		 " -b 0x%04x -c 0x%04x",
+		 path,
+		 (unsigned int)xf86GetVersion(),
+		 searchPath,
+		 info->vendor, info->chipType, info->chipRev,
+		 info->subsysVendor, info->subsysCard,
+		 info->class << 8 | info->subclass);
+	ErrorF("Running \"%s\"\n", buf);
+	gp = Popen(buf, "r");
+	if (gp) {
+	    if (fgets(buf, sizeof(buf) - 1, gp)) {
+		buf[strlen(buf) - 1] = '\0';
+		tmp = strtok(buf, GETCONFIG_WHITESPACE);
+		if (tmp)
+		    driver = xnfstrdup(tmp);
+	    }
+	}
+	xfree(path);
+	xfree(searchPath);
+    }
+
+    AppendToConfig(BUILTIN_MODULE_SECTION);
+    AppendToConfig(BUILTIN_MONITOR_SECTION);
+
+    if (driver) {
+	snprintf(buf, sizeof(buf), BUILTIN_DEVICE_SECTION_PRE,
+		 driver, 0, driver);
+	AppendToConfig(buf);
+	ErrorF("New driver is \"%s\"\n", driver);
+	buf[0] = '\t';
+	while (fgets(buf + 1, sizeof(buf) - 2, gp)) {
+	    AppendToConfig(buf);
+	    ErrorF("Extra line: %s", buf);
+	}
+	AppendToConfig(BUILTIN_DEVICE_SECTION_POST);
+	snprintf(buf, sizeof(buf), BUILTIN_SCREEN_SECTION,
+		 driver, 0, driver, 0);
+	AppendToConfig(buf);
+    }
+
+    if (gp)
+	Pclose(gp);
+
+    for (p = deviceList; *p; p++) {
+	snprintf(buf, sizeof(buf), BUILTIN_DEVICE_SECTION, *p, 0, *p);
+	AppendToConfig(buf);
+	snprintf(buf, sizeof(buf), BUILTIN_SCREEN_SECTION, *p, 0, *p, 0);
+	AppendToConfig(buf);
+    }
+
+    AppendToConfig(BUILTIN_LAYOUT_SECTION_PRE);
+    if (driver) {
+	snprintf(buf, sizeof(buf), BUILTIN_LAYOUT_SCREEN_LINE, driver, 0);
+	AppendToConfig(buf);
+    }
+    for (p = deviceList; *p; p++) {
+	snprintf(buf, sizeof(buf), BUILTIN_LAYOUT_SCREEN_LINE, *p, 0);
+	AppendToConfig(buf);
+    }
+    AppendToConfig(BUILTIN_LAYOUT_SECTION_POST);
+
+#ifdef BUILTIN_EXTRA
+    AppendToConfig(BUILTIN_EXTRA);
+#endif
+
+    if (driver)
+	xfree(driver);
+
+    xf86MsgVerb(X_DEFAULT, 0,
+		"Using default built-in configuration (%d lines)\n",
+		builtinLines);
+
+    xf86MsgVerb(X_DEFAULT, 3, "--- Start of built-in configuration ---\n");
+    for (p = builtinConfig; *p; p++)
+	xf86ErrorFVerb(3, "\t%s", *p);
+    xf86MsgVerb(X_DEFAULT, 3, "--- End of built-in configuration ---\n");
+    
+    xf86setBuiltinConfig(builtinConfig);
+    ret = xf86HandleConfigFile(TRUE);
+    FreeConfig();
+    switch(ret) {
+    case CONFIG_OK:
+	return TRUE;
+    default:
+	xf86Msg(X_ERROR, "Error parsing the built-in default configuration.\n");
+	return FALSE;
+    }
+}
+
diff --git a/hw/xfree86/common/xf86Versions.c b/hw/xfree86/common/xf86Versions.c
new file mode 100644
index 000000000..7b20ef9ab
--- /dev/null
+++ b/hw/xfree86/common/xf86Versions.c
@@ -0,0 +1,77 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Versions.c,v 1.2 2003/08/24 20:01:19 dawes Exp $ */
+/*
+ * Copyright (c) 2003 by The XFree86 Project, Inc.
+ *
+ * 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
+ * and author(s) 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 copyright holder(s) and author(s).
+ */
+
+#include "xf86.h"
+#include "xf86OSmouse.h"
+#include "xf86OSKbd.h"
+
+static CARD32 registeredVersions[NUM_BUILTIN_IFS];
+
+CARD32
+xf86GetBuiltinInterfaceVersion(BuiltinInterface iface, int flags)
+{
+    if (iface < 0 || iface >= NUM_BUILTIN_IFS) {
+	xf86Msg(X_ERROR, "xf86GetBuiltinInterfaceVersion: Unexpected interface"
+		"query: %d\n", iface);
+	return 0;
+    }
+
+    if (registeredVersions[iface])
+	return registeredVersions[iface];
+
+    /* Most built-in interfaces are handled this way. */
+    switch (iface) {
+    case BUILTIN_IF_OSMOUSE:
+	return OS_MOUSE_VERSION_CURRENT;
+    case BUILTIN_IF_OSKBD:
+	return OS_KBD_VERSION_CURRENT;
+    default:
+	xf86Msg(X_ERROR, "xf86GetBuiltinInterfaceVersion: internal error: "
+		"interface %d not handled\n", iface);
+	return 0;
+    }
+}
+
+Bool
+xf86RegisterBuiltinInterfaceVersion(BuiltinInterface iface, CARD32 version,
+				    int flags)
+{
+    if (iface < 0 || iface >= NUM_BUILTIN_IFS) {
+	xf86Msg(X_ERROR, "xf86RegisterBuiltinInterfaceVersion: "
+		"unexpected interface number: %d\n", iface);
+	return FALSE;
+    }
+    if (version == 0) {
+	xf86Msg(X_ERROR, "xf86RegisterBuiltinInterfaceVersion: "
+		"versions must be greater than zero\n");
+	return FALSE;
+    }
+    registeredVersions[iface] = version;
+    return TRUE;
+}
+
diff --git a/hw/xfree86/common/xf86xvpriv.h b/hw/xfree86/common/xf86xvpriv.h
new file mode 100644
index 000000000..0d1efdafb
--- /dev/null
+++ b/hw/xfree86/common/xf86xvpriv.h
@@ -0,0 +1,86 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86xvpriv.h,v 1.2 2003/08/24 17:36:56 dawes Exp $ */
+
+/*
+ * Copyright (c) 2003 by The XFree86 Project, Inc.
+ *
+ * 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
+ * and author(s) 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 copyright holder(s) and author(s).
+ */
+
+#ifndef _XF86XVPRIV_H_
+#define _XF86XVPRIV_H_
+
+#include "xf86xv.h"
+
+/*** These are DDX layer privates ***/
+
+extern int XF86XvScreenIndex;
+
+typedef struct {
+   DestroyWindowProcPtr		DestroyWindow;
+   ClipNotifyProcPtr		ClipNotify;
+   WindowExposuresProcPtr	WindowExposures;
+   void                         (*AdjustFrame)(int, int, int, int);
+   Bool                         (*EnterVT)(int, int);
+   void                         (*LeaveVT)(int, int);
+   GCPtr			videoGC;
+} XF86XVScreenRec, *XF86XVScreenPtr;
+
+typedef struct {
+  int flags;  
+  PutVideoFuncPtr PutVideo;
+  PutStillFuncPtr PutStill;
+  GetVideoFuncPtr GetVideo;
+  GetStillFuncPtr GetStill;
+  StopVideoFuncPtr StopVideo;
+  SetPortAttributeFuncPtr SetPortAttribute;
+  GetPortAttributeFuncPtr GetPortAttribute;
+  QueryBestSizeFuncPtr QueryBestSize;
+  PutImageFuncPtr PutImage;
+  ReputImageFuncPtr ReputImage;
+  QueryImageAttributesFuncPtr QueryImageAttributes;
+} XvAdaptorRecPrivate, *XvAdaptorRecPrivatePtr;
+
+typedef struct {
+   ScrnInfoPtr pScrn;
+   DrawablePtr pDraw;
+   unsigned char type;
+   unsigned int subWindowMode;
+   DDXPointRec clipOrg;
+   RegionPtr clientClip;
+   RegionPtr pCompositeClip;
+   Bool FreeCompositeClip;
+   XvAdaptorRecPrivatePtr AdaptorRec;
+   XvStatus isOn;
+   Bool moved;
+   int vid_x, vid_y, vid_w, vid_h;
+   int drw_x, drw_y, drw_w, drw_h;
+   DevUnion DevPriv;
+} XvPortRecPrivate, *XvPortRecPrivatePtr;
+
+typedef struct _XF86XVWindowRec{
+   XvPortRecPrivatePtr PortRec;
+   struct _XF86XVWindowRec *next;
+} XF86XVWindowRec, *XF86XVWindowPtr;
+
+#endif  /* _XF86XVPRIV_H_ */
diff --git a/hw/xfree86/dixmods/extmod/modinit.h b/hw/xfree86/dixmods/extmod/modinit.h
new file mode 100644
index 000000000..cc717c31b
--- /dev/null
+++ b/hw/xfree86/dixmods/extmod/modinit.h
@@ -0,0 +1,144 @@
+/* $XFree86: xc/programs/Xserver/Xext/extmod/modinit.h,v 1.2 2003/09/13 21:33:04 dawes Exp $ */
+
+#ifndef INITARGS
+#define INITARGS void
+#endif
+
+#ifdef SHAPE
+extern void ShapeExtensionInit(INITARGS);
+#define _SHAPE_SERVER_  /* don't want Xlib structures */
+#include "shapestr.h"
+#endif
+
+#ifdef MULTIBUFFER
+extern void MultibufferExtensionInit(INITARGS);
+#define _MULTIBUF_SERVER_	/* don't want Xlib structures */
+#include "multibufst.h"
+#endif
+
+#ifdef MITMISC
+extern void MITMiscExtensionInit(INITARGS);
+#define _MITMISC_SERVER_
+#include "mitmiscstr.h"
+#endif
+
+#ifdef XTEST
+extern void XTestExtensionInit(INITARGS);
+#define _XTEST_SERVER_
+#include "XTest.h"
+#include "xteststr.h"
+#endif
+
+#if 1
+extern void XTestExtension1Init(INITARGS);
+#endif
+
+#ifdef BIGREQS
+extern void BigReqExtensionInit(INITARGS);
+#include "bigreqstr.h"
+#endif
+
+#ifdef XSYNC
+extern void SyncExtensionInit(INITARGS);
+#define _SYNC_SERVER
+#include "sync.h"
+#include "syncstr.h"
+#endif
+
+#ifdef SCREENSAVER
+extern void ScreenSaverExtensionInit (INITARGS);
+#include "saver.h"
+#endif
+
+#ifdef XCMISC
+extern void XCMiscExtensionInit(INITARGS);
+#include "xcmiscstr.h"
+#endif
+
+#ifdef XF86VIDMODE
+extern void	XFree86VidModeExtensionInit(INITARGS);
+#define _XF86VIDMODE_SERVER_
+#include "xf86vmstr.h"
+#endif
+
+#ifdef XF86MISC
+extern void XFree86MiscExtensionInit(INITARGS);
+#define _XF86MISC_SERVER_
+#define _XF86MISC_SAVER_COMPAT_
+#include "xf86mscstr.h"
+#endif
+
+#ifdef XFreeXDGA
+extern void XFree86DGAExtensionInit(INITARGS);
+extern void XFree86DGARegister(INITARGS);
+#define _XF86DGA_SERVER_
+#include "xf86dgastr.h"
+#endif
+
+#ifdef DPMSExtension
+extern void DPMSExtensionInit(INITARGS);
+#include "dpmsstr.h"
+#endif
+
+#ifdef FONTCACHE
+extern void FontCacheExtensionInit(INITARGS);
+#define _FONTCACHE_SERVER_
+#include "fontcacheP.h"
+#include "fontcachstr.h"
+#endif
+
+#ifdef TOGCUP
+extern void XcupExtensionInit(INITARGS);
+#define _XCUP_SERVER_
+#include "Xcupstr.h"
+#endif
+
+#ifdef EVI
+extern void EVIExtensionInit(INITARGS);
+#define _XEVI_SERVER_
+#include "XEVIstr.h"
+#endif
+
+#ifdef XV
+extern void XvExtensionInit(INITARGS);
+extern void XvMCExtensionInit(INITARGS);
+extern void XvRegister(INITARGS);
+#include "Xv.h"
+#include "XvMC.h"
+#endif
+
+#ifdef RES
+extern void ResExtensionInit(INITARGS);
+#include "XResproto.h"
+#endif
+
+#ifdef SHM
+extern void ShmExtensionInit(INITARGS);
+#include "shmstr.h"
+extern void ShmSetPixmapFormat(
+    ScreenPtr pScreen,
+    int format);
+extern void ShmRegisterFuncs(
+    ScreenPtr pScreen,
+    ShmFuncsPtr funcs);
+#endif
+
+#if 1
+extern void SecurityExtensionInit(INITARGS);
+#endif
+
+#if 1
+extern void XagExtensionInit(INITARGS);
+#endif
+
+#if 1
+extern void XpExtensionInit(INITARGS);
+#endif
+
+#if 1
+extern void PanoramiXExtensionInit(int argc, char *argv[]);
+#endif
+
+#if 1
+extern void XkbExtensionInit(INITARGS);
+#endif
diff --git a/hw/xfree86/dixmods/extmod/xf86dgaext.h b/hw/xfree86/dixmods/extmod/xf86dgaext.h
new file mode 100644
index 000000000..831108399
--- /dev/null
+++ b/hw/xfree86/dixmods/extmod/xf86dgaext.h
@@ -0,0 +1,8 @@
+/* $XFree86: xc/programs/Xserver/Xext/xf86dgaext.h,v 1.1 2003/07/16 01:38:30 dawes Exp $ */
+
+#ifndef _XF86DGAEXT_H_
+#define _XF86DGAEXT_H_
+
+extern DISPATCH_PROC(ProcXF86DGADispatch);
+
+#endif /* _XF86DGAEXT_H_ */
diff --git a/hw/xfree86/dummylib/logvwrite.c b/hw/xfree86/dummylib/logvwrite.c
new file mode 100644
index 000000000..75634d7f3
--- /dev/null
+++ b/hw/xfree86/dummylib/logvwrite.c
@@ -0,0 +1,18 @@
+/* $XFree86: xc/programs/Xserver/hw/xfree86/dummylib/logvwrite.c,v 1.1 2003/09/09 03:20:38 dawes Exp $ */
+
+#include "X.h"
+#include "os.h"
+#include "xf86.h"
+#include "xf86Priv.h"
+
+/*
+ * Utility functions required by libxf86_os. 
+ */
+
+void
+LogVWrite(int verb, const char *format, va_list ap)
+{
+    if (xf86Verbose >= verb)
+	vfprintf(stderr, format, ap);
+}
+
diff --git a/hw/xfree86/getconfig/cfg.man.pre b/hw/xfree86/getconfig/cfg.man.pre
new file mode 100644
index 000000000..fcf1a6161
--- /dev/null
+++ b/hw/xfree86/getconfig/cfg.man.pre
@@ -0,0 +1,138 @@
+.\" $XFree86: xc/programs/Xserver/hw/xfree86/getconfig/cfg.man,v 1.1 2003/11/12 04:52:15 dawes Exp $
+.TH getconfig __filemansuffix__  __vendorversion__
+.SH NAME
+getconfig - meta configuration files for getconfig(1)
+.SH SYNOPSIS
+.B \(**.cfg
+.SH DESCRIPTION
+.B getconfig
+is a programatic interface that is used by the
+.B XFree86
+server to get configuration information about video hardware when
+operating without an
+.B XF86Config
+file.
+.PP
+This implementation of
+.B getconfig
+is written in perl.  It processes rules from meta-configuration files.
+All meta-configuration files have a
+.I .cfg
+suffix.
+.PP
+Lines starting with a pound-sign (#) are comments, and are ignored.
+Blank lines that consist only of white space are also treated as comments
+and ignored.
+.PP
+The first non-comment line must be a signature string followed by
+the file format version number.  The signature string is
+.PP
+.RS 4
+.nf
+"XFree86 Project getconfig rules file.\ \ Version: "
+.fi
+.RE
+.PP
+The currently defined version is "1.0".  Files that do not have the
+correct signature string are ignored.
+.PP
+The remaining non-comment lines define rules.  The start of a new rule
+is indicated by a line with no leading white space.  Subsequent lines
+making up a rule must be indented with white space.  Logical lines within
+a rule may be split over multiple physical lines by using the usual
+continuation convention ('\e' at the end of the line).  The first logical
+line of each rule is a perl expression.  It may be any valid perl
+expression whose evaluated (with 'eval') result may be used as the
+argument to a perl 'if' statement.  The second logical line should be
+the name of the XFree86 video driver to use when the rule is true, and
+subsequent logical lines of each rule, if present, are additional
+configuration output for the video device's
+.B XF86Config
+.B Device
+section.  The driver name and additional lines of configuration information
+are written to standard output when the rule is chosen as the successful
+rule.
+.PP
+Pseudo rules consisting of perl expressions may be present in the file
+for the purpose of defining custom perl variables or setting the weight
+to use for the following rules.  Pseudo rules are rules that consist of
+a single logical line only, and the are never candidates themselves for the
+successful rule.
+.PP
+Several perl variables are pre-defined, and may be used within rules.
+They include:
+.PP
+.RS 4
+.nf
+.BR "$vendor                 " "PCI vendor ID"
+.BR "$device                 " "PCI device ID"
+.BR "$revision               " "PCI revision ID"
+.BR "$subsys                 " "PCI subsystem ID"
+.BR "$subsysVendor           " "PCI subsystem vendor ID"
+.BR "$class                  " "PCI class"
+.BR "$XFree86Version         " "XFree86 version, as a 'v' string"
+.BR "$XFree86VersionNumeric  " "XFree86 numeric version"
+.BR "$XFree86VersionMajor    " "XFree86 major version"
+.BR "$XFree86VersionMinor    " "XFree86 minor version"
+.BR "$XFree86VersionPatch    " "XFree86 patch version"
+.BR "$XFree86VersionSnap     " "XFree86 snap version"
+.BR "$weight                 " "current rule weight"
+.fi
+.RE
+.PP
+The
+.B $weight
+variable deterines the weight of the rules as they are processed.  The
+weight for subsequent rules may be set with a pseudo rule that sets or
+changes the value of
+.BR $weight .
+The default weight, and the weight used for built-in rules is 500.  The
+meta-configuration files are processed in an unpredictable order.  The
+weighting of the rules is used to determine their relative priority
+.PP
+After processing all of the rules, both built-in and those read from
+the meta-configration files, the
+.B getconfig
+program chooses as the successful rule the last and highest weighted
+rule that evaluates to true.
+.SH FILES
+.I .cfg
+files located in the search path.  The search path typically specified
+by the
+.B XFree86
+server is:
+.PP
+.RS 4
+.nf
+.I /etc/X11
+.I __projectroot__/etc/X11
+.I <modulepath>
+.I __projectroot__/lib/X11/getconfig
+.fi
+.RE
+.PP
+where
+.I <modulepath>
+is the
+.B XFree86
+server's module search path.
+.PP
+.TP 30
+.I __projectroot__/lib/X11/getconfig/xfree86.cfg
+Default rules file that gets installed.  This file doesn't contain any
+rules by default.
+.TP 30
+.I __projectroot__/lib/X11/getconfig/cfg.sample
+A sample rules file that gives some examples of what types of rules can
+appear in rules files.
+
+.SH "SEE ALSO"
+getconfig(1),
+XFree86(1),
+XF86Config(__filemansuffix__).
+
+.SH AUTHORS
+The XFree86 automatic configuration support and the
+.B getconfig
+interface was written by David H. Dawes, with the support of X-Oz
+Technologies.
diff --git a/hw/xfree86/getconfig/cfg.sample b/hw/xfree86/getconfig/cfg.sample
new file mode 100644
index 000000000..acf262d1a
--- /dev/null
+++ b/hw/xfree86/getconfig/cfg.sample
@@ -0,0 +1,111 @@
+# $DHD: xc/programs/Xserver/hw/xfree86/getconfig/cfg.sample,v 1.2 2003/09/23 05:12:07 dawes Exp $
+# $XFree86: xc/programs/Xserver/hw/xfree86/getconfig/cfg.sample,v 1.2 2003/11/12 04:52:15 dawes Exp $
+
+# Some sample XFree86 getconfig rules file.
+
+#
+# The line below is the getconfig rules file signature, and must be the
+# first non-blank, non-comment line.
+#
+
+XFree86 Project getconfig rules file.  Version: 1.0
+
+#
+# Set the weight for the following rules.  This should be set, otherwise
+# the previously set weight will get used, and you have no idea of knowing
+# what that might be.
+#
+
+$weight = 1000
+
+#
+# Rules.  Rules consist of a condition (in perl code) followed by
+# a driver name and optionally some additional strings.  The start of a
+# rule is indicated by a line with no leading white space.  Subsequent
+# lines making up a rule must be indented.  Logical lines may be split
+# over multiple physical lines by using the usual continuation '\'.
+#
+# Rules that are not followed by a driver name may be used to do other
+# things, like setting the weight as above.
+#
+
+#
+# Pre-defined variables include:
+#
+#   $vendor		PCI vendor ID
+#   $device		PCI device ID
+#   $revision		PCI revision ID
+#   $subsys		PCI subsystem ID
+#   $subsysVendor	PCI subsystem vendor ID
+#   $class		PCI class
+#   $XFree86Version	XFree86 version, as a 'v' string.
+#
+# The XFree86 version information is also available as the following:
+#
+#   $XFree86VersionNumeric
+#   $XFree86VersionMajor
+#   $XFree86VersionMinor
+#   $XFree86VersionPatch
+#   $XFree86VersionSnap
+#   
+
+# Define a fake vendor ID for some sample rules.
+
+$novendor = 0x10000
+$nodevice = 0x10000
+
+$vendor == $novendor
+	nodriver
+	Option "xx"
+	Videoram 1000
+
+# A rule with continued lines.
+
+$vendor == $novendor && \
+$device == $nodevice 
+	nodriver2
+	Option \
+	"yy"
+
+# Increase the weight of the following rules if the XFree86 version is 4.3 or
+# higher.
+
+$weight++ if ($XFree86Version ge v4.3)
+
+$vendor == $novendor
+	nodriver
+	Option "yy"
+
+#
+# The weight can be changed at any times, and applies to rules that follow
+# until changed again.
+#
+
+$weight = 100
+
+$vendor == $novendor && $XFree86Version eq v4.3.2.1
+	nodriver3
+
+$weight = 600
+
+#
+# The following two examples use some real values.
+#
+
+# Example: make the default depth 24 for Radeon R200 and RV200 cards.
+
+$vendor == 0x1002 && \
+    ($device >= 0x5148 && $device <= 0x514F || \
+     $device >= 0x5168 && $device <= 0x516C || \
+     $device == 0x4242 || \
+     $device >= 0x5157 && device <= 0x5158)
+	ati
+	Option "DefaultDepth" "24"
+
+
+# Example: enable DRI for MGA G400
+
+$vendor == 0x102b && $device == 0x0525
+	mga
+	Option "dri"
+
diff --git a/hw/xfree86/getconfig/getconfig b/hw/xfree86/getconfig/getconfig
new file mode 100644
index 000000000..d2acc9bb8
--- /dev/null
+++ b/hw/xfree86/getconfig/getconfig
@@ -0,0 +1,45 @@
+#!/bin/sh
+
+# $DHD: xc/programs/Xserver/hw/xfree86/getconfig/getconfig.sh,v 1.2 2003/09/20 01:45:57 dawes Exp $
+
+#
+# Copyright 2003 by David H. Dawes.
+# Copyright 2003 by X-Oz Technologies.
+# 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
+# and author(s) 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 copyright holder(s) and author(s).
+# 
+# Author: David Dawes <dawes@XFree86.Org>.
+#
+
+# $XFree86: xc/programs/Xserver/hw/xfree86/getconfig/getconfig.sh,v 1.1 2003/10/08 14:58:29 dawes Exp $
+
+# A simple wrapper to execute the real getconfig program.  So long as perl
+# is in $PATH, we don't need to know where it is this way.
+
+if echo $0 | grep / >/dev/null 2>&1; then
+	DIR=`dirname $0`/
+fi
+
+exec perl ${DIR}getconfig.pl "$@"
diff --git a/hw/xfree86/getconfig/getconfig.man.pre b/hw/xfree86/getconfig/getconfig.man.pre
new file mode 100644
index 000000000..16c472fc5
--- /dev/null
+++ b/hw/xfree86/getconfig/getconfig.man.pre
@@ -0,0 +1,98 @@
+.\" $XFree86: xc/programs/Xserver/hw/xfree86/getconfig/getconfig.man,v 1.1 2003/11/12 04:52:15 dawes Exp $
+.TH getconfig 1 __vendorversion__
+.SH NAME
+getconfig - get configuration information for the XFree86 server
+.SH SYNOPSIS
+.B getconfig
+.RI [ option
+.IR ... ]
+.SH DESCRIPTION
+.B getconfig
+is a programatic interface that is used by the
+.B XFree86
+server to get configuration information about video hardware when
+operating without an
+.B XF86Config
+file.
+.PP
+This implementation of
+.B getconfig
+is written in perl.  It processes a prioritized and ordered list of
+rules supplied internally and from meta-configuration files.  The rules
+are in the form of perl expressions.
+.B getconfig
+writes to standard output the XF86Config-style configuration data
+specified by the last highest priority rule that evaluates to true.
+Information about the format of the meta-configuration files can be
+found in the getconfig(__filemansuffix__) manual page.
+.SH OPTIONS
+.TP 8
+.BI \-I " search-path"
+Specify the search path to use for meta-config files.
+.I search-path
+is a comma-separated list of directories to search.  Each directory in
+the search path is searched for files with a
+.I .cfg
+suffix.  Each such file is opened and checked for a valid signature
+string.  Rules are read from files with a valid signature string and
+appended to the list of rules to evaluate.  If no search path is specified,
+only the internally supplied configuration rules will be used.
+.TP 8
+.B \-D
+Enable debugging output.
+.TP 8
+.B \-V
+Print out the version information and exit.
+.TP 8
+.BI \-X " XFree86-version"
+Specify the XFree86 version in numeric (integer) form.
+.TP 8
+.BI \-b " subsys-id"
+Specify the PCI subsystem ID of the video device.
+.TP 8
+.BI \-c " class"
+Specify the PCI class of the video device.
+.TP 8
+.BI \-d " device-id"
+Specify the PCI devide ID of the video device.
+.TP 8
+.BI \-r " revision"
+Specify the PCI revision of the video device.
+.TP 8
+.BI \-s " subsysvendor-id"
+Specify the PCI subsystem vendor ID of the video device.
+.TP 8
+.BI \-v " vendor-id"
+Specify the PCI vendor ID of the video device.
+.SH FILES
+.I .cfg
+files located in the search path.  The search path typically specified
+by the
+.B XFree86
+server is:
+.PP
+.RS 4
+.nf
+.I /etc/X11
+.I __projectroot__/etc/X11
+.I <modulepath>
+.I __projectroot__/lib/X11/getconfig
+.fi
+.RE
+.PP
+where
+.I <modulepath>
+is the
+.B XFree86
+server's module search path.
+
+.SH "SEE ALSO"
+getconfig(__filemansuffix__),
+XFree86(1),
+XF86Config(__filemansuffix__).
+
+.SH AUTHORS
+The XFree86 automatic configuration support and the
+.B getconfig
+interface was written by David H. Dawes, with the support of X-Oz
+Technologies.
diff --git a/hw/xfree86/getconfig/getconfig.pl b/hw/xfree86/getconfig/getconfig.pl
new file mode 100644
index 000000000..fcfd7d057
--- /dev/null
+++ b/hw/xfree86/getconfig/getconfig.pl
@@ -0,0 +1,429 @@
+#!/usr/bin/perl
+
+# $DHD: xc/programs/Xserver/hw/xfree86/getconfig/getconfig.pl,v 1.13 2003/09/23 05:12:07 dawes Exp $
+
+#
+# Copyright 2003 by David H. Dawes.
+# Copyright 2003 by X-Oz Technologies.
+# 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 COPYRIGHT HOLDER(S) OR AUTHOR(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 of the copyright holder(s)
+# and author(s) 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 copyright holder(s) and author(s).
+# 
+# Author: David Dawes <dawes@XFree86.Org>.
+#
+
+# $XFree86: xc/programs/Xserver/hw/xfree86/getconfig/getconfig.pl,v 1.1 2003/10/08 14:58:29 dawes Exp $
+
+#
+# This script takes PCI id information, compares it against an ordered list
+# of rules, and prints out the configuration information specified by the
+# last matching rule.
+#
+# This script is called by xf86AutoConfig().
+#
+
+# Command line processing.
+
+$GetconfigVersion = v1.0;
+
+$debug = 0;
+
+$myname = $0;
+$myname =~ s/.*\///;
+
+$signature = "XFree86 Project getconfig rules file.  Version: ";
+
+while (@ARGV[0] =~ /^-[A-Za-z]$/) {
+    $f = shift;
+    SWITCH: {
+	if ($f eq "-D") {
+	    $debug = 1;
+	    last SWITCH;
+	}
+	if ($f eq "-I") {
+	    push(@searchPaths, split(/,/, shift));
+	    last SWITCH;
+	}
+	if ($f eq "-V") {
+	    printf STDERR "$myname: Version %vd.\n", $GetconfigVersion;
+	    exit 0;
+	}
+	if ($f eq "-X") {
+	    $XFree86VersionNumeric = shift;
+	    if (!defined($XFree86VersionNumeric)) {
+		print STDERR "$myname: -X requires the XFree86 version.\n";
+		exit 1;
+	    }
+	}
+	if ($f eq "-b") {
+	    $subsys = oct(shift);
+	    if (!defined($subsys)) {
+		print STDERR "$myname: -b requires the subsys id.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+	if ($f eq "-c") {
+	    $class = oct(shift);
+	    if (!defined($class)) {
+		print STDERR "$myname: -c requires the class value.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+	if ($f eq "-d") {
+	    $device = oct(shift);
+	    if (!defined($device)) {
+		print STDERR "$myname: -d requires the device id.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+	if ($f eq "-r") {
+	    $revision = oct(shift);
+	    if (!defined($revision)) {
+		print STDERR "$myname: -r requires the device revision.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+	if ($f eq "-s") {
+	    $subsysVendor = oct(shift);
+	    if (!defined($subsysVendor)) {
+		print STDERR "$myname: -s requires the subsysVendor id.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+	if ($f eq "-v") {
+	    $vendor = oct(shift);
+	    if (!defined($vendor)) {
+		print STDERR "$myname: -v requires the vendor id.\n";
+		exit 1;
+	    }
+	    last SWITCH;
+	}
+    }
+}
+
+printf STDERR "$myname: Version %vd.\n", $GetconfigVersion;
+
+if (defined($XFree86VersionNumeric)) {
+    $XFree86VersionMajor = $XFree86VersionNumeric / 10000000;
+    $XFree86VersionMinor = ($XFree86VersionNumeric % 10000000) / 100000;
+    $XFree86VersionPatch = ($XFree86VersionNumeric % 100000) / 1000;
+    $XFree86VersionSnapshot = $XFree86VersionNumeric % 1000;
+    $XFree86Version = chr($XFree86VersionMajor) . chr($XFree86VersionMinor) .
+		chr($XFree86VersionPatch) . chr($XFree86VersionSnapshot);
+}
+
+if ($debug) {
+    printf STDERR "$myname: XFree86 Version: %d, %d.%d.%d.%d, %vd.\n",
+	$XFree86VersionNumeric, $XFree86VersionMajor, $XFree86VersionMinor,
+	$XFree86VersionPatch, $XFree86VersionSnapshot, $XFree86Version;
+} else {
+    printf STDERR "$myname: XFree86 Version: %vd.\n", $XFree86Version;
+}
+  
+
+# The rules here are just basic vendor ID to driver mappings.
+# Ideally this is all that would be required.  More complicated configuration
+# rules will be provided in external files.
+
+# XXX This set of basic rules isn't complete yet.
+
+@rules = (
+
+# Set the weight for the built-in rules.
+['$weight = 500'],
+
+# APM
+['$vendor == 0x1142',
+	'apm'],
+
+# ARK
+['$vendor == 0xedd8',
+	'apm'],
+
+# ATI
+['$vendor == 0x1002',
+	'ati'],
+
+# Chips & Technologies
+['$vendor == 0x102c',
+	'chips'],
+
+# Cirrus
+['$vendor == 0x1013',
+	'cirrus'],
+
+# Intel
+['$vendor == 0x8086',
+	'i810'],
+['$vendor == 0x8086 && ($chipType == 0x00d1 || $chipType == 0x7800)',
+	'i740'],
+
+# Matrox
+['$vendor == 0x102b',
+	'mga'],
+
+# Neomagic
+['$vendor == 0x10c8',
+	'neomagic'],
+
+# Number Nine
+['$vendor == 0x105d',
+	'i128'],
+
+# NVIDIA
+['$vendor == 0x10de || $vendor == 0x12d2',
+	'nv'],
+
+# S3
+['$vendor == 0x5333 && ($device == 0x88d0 ||' .
+			'$device == 0x88d1 ||' .
+			'$device == 0x88f0 ||' .
+			'$device == 0x8811 ||' .
+			'$device == 0x8812 ||' .
+			'$device == 0x8814 ||' .
+			'$device == 0x8901)',
+	's3'],
+
+# S3 virge
+['$vendor == 0x5333 && ($device == 0x5631 ||' .
+			'$device == 0x883d ||' .
+			'$device == 0x8a01 ||' .
+			'$device == 0x8a10 ||' .
+			'$device == 0x8c01 ||' .
+			'$device == 0x8c03 ||' .
+			'$device == 0x8904 ||' .
+			'$device == 0x8a13)',
+	's3virge'],
+
+# S3 Savage
+['$vendor == 0x5333 && ($device >= 0x8a20 && $device <= 0x8a22 ||' .
+			'$device == 0x9102 ||' .
+			'$device >= 0x8c10 && $device <= 0x8c13 ||' .
+			'$device == 0x8a25 ||' .
+			'$device == 0x8a26 ||' .
+			'$device >= 0x8d01 && $device <= 0x8d04 ||' .
+			'$device >= 0x8c2a && $device <= 0x8c2f ||' .
+			'$device == 0x8c22 ||' .
+			'$device == 0x8c24 ||' .
+			'$device == 0x8c26)',
+	'savage'],
+
+# SIS
+['$vendor == 0x1039',
+	'sis'],
+
+# SMI
+['$vendor == 0x126f',
+	'siliconmotion'],
+
+# 3Dfx
+['$vendor == 0x121a',
+	'tdfx'],
+
+# 3Dlabs
+['$vendor == 0x3d3d',
+	'glint'],
+
+# Trident
+['$vendor == 0x1023',
+	'trident'],
+
+# Tseng Labs
+['$vendor == 0x100c',
+	'tseng'],
+
+# VIA
+['$vendor == 0x1106',
+	'via'],
+
+# VMware
+['$vendor == 0x15ad',
+	'vmware'],
+
+);
+
+# Reverse the search path list, since the later rules have higher priority
+# than earlier ones (weighting being equal).
+
+@searchPaths = reverse(@searchPaths);
+
+if ($debug) {
+    $i = 0;
+    for $path (@searchPaths) {
+	print STDERR "$myname: Search path $i is: \"$path\".\n";
+	$i++;
+    }
+}
+
+print STDERR "$myname: ", $#rules + 1, " built-in rule", plural($#rules + 1),
+			".\n";
+
+for $path (@searchPaths) {
+    while (<$path/*.cfg>) {
+	@tmp = readRulesFile($_);
+	if (defined(@tmp[0])) {
+	    push @rules, @tmp;
+	}
+    }
+}
+
+if ($debug) {
+    $i = 0;
+    for $r (@rules) {
+	print STDERR "$myname: rule $i is: \'@$r\'.\n";
+	$i++
+    }
+}
+
+$i = 0;
+$e = 0;
+$weight = 0;
+$w = 0;
+for $r (@rules) {
+    ($cond, $d, @o) = @$r;
+    $result = eval $cond;
+    if ($@) {
+	print STDERR "$myname: Error evaluating rule $i \'$cond\': $@";
+	$e++;
+    }
+    if ($debug) {
+	print STDERR "$myname: rule $i \'$cond\' evaluates to \'$result\'.\n";
+    }
+    if ($result && defined($d) && $weight >= $w) {
+	$driver = $d;
+	@opts = @o;
+	$w = $weight;
+    }
+    $i++;
+}
+
+print STDERR "$myname: Evaluated $i rule", plural($i),
+		" with $e error", plural($e), ".\n";
+
+print STDERR "$myname: Weight of result is $w.\n";
+
+if ($debug) {
+    if (defined($driver)) {
+	print STDERR "$myname: Driver is \'$driver\'.\n";
+    } else {
+	print STDERR "$myname: No driver.\n";
+    }
+    if (defined(@opts)) {
+	print STDERR "$myname: options are:\n";
+	for $opt (@opts) {
+	    print STDERR "\t$opt\n";
+	}
+    } else {
+	print STDERR "$myname: No options.\n";
+    }
+}
+
+print "$driver\n";
+for $opt (@opts) {
+    print "$opt\n";
+}
+
+exit 0;
+
+# Subroutines.
+
+sub readRulesFile {
+    my ($file) = @_;
+    my $signatureOK = 0;
+    my @r, @tmp;
+    my $line, $cont, $prevcont, $fileversion;
+
+    undef @tmp;
+    undef @r;
+
+    if (open(RF, "<$file")) {
+	$prevcont = 0;
+	while (<RF>) {
+	    chop;
+	    $line = $_;
+	    next if ($line =~ /^#/);
+	    next if ($line =~ /^\s*$/);
+	    if (!$signatureOK) {
+		if ($line  =~ /^$signature(.*)$/) {
+		    $fileversion = $1;
+		    $signatureOK = 1;
+		    print STDERR
+			"$myname: rules file \'$file\' has version $fileversion.\n";
+		    next;
+		}
+	    }
+	    if (!$signatureOK) {
+		print STDERR "$myname: file \'$file\' has bad signature.\n";
+		close(RF);
+		last;
+	    }
+	    $cont = 0;
+	    if ($line =~ s/\\\s*$//) {
+		$cont = 1;
+	    }
+	    if (!$prevcont && $line =~ /^\S+/) {
+		if (defined(@tmp[0])) {
+		    push(@r,[@tmp]);
+		}
+		undef @tmp;
+	    }
+	    if ($prevcont) {
+		push(@tmp, pop(@tmp) . $line);
+	    } else {
+		push(@tmp, $line);
+	    }
+	    $prevcont = $cont;
+	}
+	if (defined(@tmp[0])) {
+	    push(@r,[@tmp]);
+	}
+	if (!defined(@r[0])) {
+	    print STDERR "$myname: no rules in file \'$file\'.\n";
+	} else {
+	    print STDERR "$myname: ", $#r + 1,
+			" rule", plural($#r + 1),
+			" added from file \'$file\'.\n";
+	}
+    } else {
+	print STDERR "$myname: cannot open file \'$file\'.\n";
+    }
+
+    return @r;
+}
+
+sub plural {
+    my ($count) = @_;
+
+    if ($count != 1) {
+	return "s";
+    } else {
+	return "";
+    }
+}
+
diff --git a/hw/xwin/_usr_X11R6_lib_X11_system.XWinrc b/hw/xwin/_usr_X11R6_lib_X11_system.XWinrc
new file mode 100644
index 000000000..dbd79f2bf
--- /dev/null
+++ b/hw/xwin/_usr_X11R6_lib_X11_system.XWinrc
@@ -0,0 +1,105 @@
+# XWin Server Resource File - EXAMPLE
+# Earle F. Philhower, III
+
+# Place in ~/.XWinrc or in /usr/X11R6/lib/X11/system.XWinrc
+
+# Keywords are case insensitive, comments legal pretty much anywhere
+# you can have an end-of-line
+
+# Comments begin with "#" or "//" and go to the end-of-line
+
+# Paths to commands are **cygwin** based (i.e. /usr/local/bin/xcalc)
+
+# Paths to icons are **WINDOWS** based (i.e. c:\windows\icons)
+
+# Menus are defined as...
+# MENU <name> {
+#	<Menu Text>	EXEC	<command>
+#                               ^^ This command will have any "%display%"
+#                                  string replaced with the proper display
+#                                  variable (i.e. 127.0.0.1:<display>.0)
+#  or	<Menu Text>	MENU	<name-of-some-prior-defined-menu>
+#  or	<Menu Text>	ALWAYSONTOP
+#                         ^^ Sets the window to display above all others
+#  or   <Menu Text>	RELOAD
+#                         ^^ Causes ~/.XWinrc or the system.XWinrc file
+#                            to be reloaded and icons and menus regenerated
+#  or	SEPARATOR
+#       ...
+# }
+
+# Set the taskmar menu with
+# ROOTMENU <name-of-some-prior-defined-menu>
+
+# If you want a menu to be applied to all popup window's system menu
+# DEFAULTSYSMENU <name-of-some-prior-defined-menu> <atstart|atend>
+
+# To choose a specific menu for a specific WM_CLASS or WM_NAME use ...
+# SYSMENU {
+#	<class-or-name-of-window> <name-of-prior-defined-menu> <atstart|atend>
+#	...
+# }
+
+# To define where ICO files live (** Windows path**)
+# ICONDIRECTORY	<windows-path i.e. c:\cygwin\usr\icons>
+
+# To define a replacement for the standard X icon for apps w/o specified icons
+# DEFAULTICON	<name-of-windows-ico-file-in-icondirectory>
+
+# To define substitute icons on a per-window basis use...
+# ICONS {
+#	<class-or-name-of-window> <icon-file-name.ico>
+#	...
+# }
+# In the case where multiple matches occur, the first listed in the ICONS
+# section will be chosen.
+
+# DEBUG <string> prints out the string to the XWin.log file
+
+// Below are just some silly menus to demonstrate writing your
+// own configuration file.
+
+// Make some menus...
+menu apps {
+	xterm	exec	"xterm"
+	"Emacs"		exec	"emacs"
+	notepad	exec	notepad
+	xload	exec	"xload -display %display%"  # Comment
+}
+
+menu root {
+// Comments fit here, too...
+	"Reload .XWinrc"	RELOAD
+	"Applications"	menu	apps
+	SEParATOR
+}
+
+menu aot {
+	Separator
+	"Always on Top"	alwaysontop
+}
+
+menu xtermspecial {
+	"Emacs"		exec	"emacs"
+	"Always on Top"	alwaysontop
+	SepArAtor
+}
+
+RootMenu root
+
+DefaultSysMenu aot atend
+
+SysMenu {
+	"xterm"	xtermspecial atstart
+}
+
+# IconDirectory	"c:\winnt\"
+
+# DefaultIcon	"reinstall.ico"
+
+# Icons {
+# 	"xterm"	"uninstall.ico"
+# }
+
+DEBUG "Done parsing the configuration file..."
+
diff --git a/hw/xwin/windialogs.c b/hw/xwin/windialogs.c
new file mode 100755
index 000000000..d905ad81c
--- /dev/null
+++ b/hw/xwin/windialogs.c
@@ -0,0 +1,320 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Harold L Hunt II
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/windialogs.c,v 1.1 2003/07/29 21:25:17 dawes Exp $ */
+
+#include "win.h"
+
+extern Bool			g_fCursor;
+
+BOOL CALLBACK
+winExitDlgProc (HWND hDialog, UINT message,
+		WPARAM wParam, LPARAM lParam);
+
+BOOL CALLBACK
+winChangeDepthDlgProc (HWND hDialog, UINT message,
+		       WPARAM wParam, LPARAM lParam);
+
+
+/*
+ * Display the Exit dialog box
+ */
+
+void
+winDisplayExitDialog (winPrivScreenPtr pScreenPriv)
+{
+  /* Check if dialog already exists */
+  if (g_hDlgExit != NULL)
+    {
+      /* Dialog box already exists, display it */
+      ShowWindow (g_hDlgExit, SW_SHOWDEFAULT);
+
+      /* User has lost the dialog.  Show them where it is. */
+      SetForegroundWindow (g_hDlgExit);
+
+      return;
+    }
+
+  /* Create dialog box */
+  g_hDlgExit = CreateDialogParam (g_hInstance,
+				  "EXIT_DIALOG",
+				  pScreenPriv->hwndScreen,
+				  winExitDlgProc,
+				  (int) pScreenPriv);
+
+  /* Drop minimize and maximize buttons */
+  SetWindowLong (g_hDlgExit, GWL_STYLE,
+		 GetWindowLong (g_hDlgExit, GWL_STYLE)
+		 & ~(WS_MAXIMIZEBOX | WS_MINIMIZEBOX));
+  SetWindowLong (g_hDlgExit, GWL_EXSTYLE,
+		 GetWindowLong (g_hDlgExit, GWL_EXSTYLE) & ~WS_EX_APPWINDOW );
+  SetWindowPos (g_hDlgExit, 0, 0, 0, 0, 0,
+		SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOSIZE); 
+ 
+  /* Show the dialog box */
+  ShowWindow (g_hDlgExit, SW_SHOW);
+  
+  /* Needed to get keyboard controls (tab, arrows, enter, esc) to work */
+  SetForegroundWindow (g_hDlgExit);
+  
+  /* Set focus to the Cancel buton */
+  PostMessage (g_hDlgExit, WM_NEXTDLGCTL,
+	       (int) GetDlgItem (g_hDlgExit, IDCANCEL), TRUE);
+}
+
+
+/*
+ * Exit dialog window procedure
+ */
+
+BOOL CALLBACK
+winExitDlgProc (HWND hDialog, UINT message,
+		WPARAM wParam, LPARAM lParam)
+{
+  static winPrivScreenPtr	s_pScreenPriv = NULL;
+  static winScreenInfo		*s_pScreenInfo = NULL;
+  static ScreenPtr		s_pScreen = NULL;
+
+  /* Branch on message type */
+  switch (message)
+    {
+    case WM_INITDIALOG:
+      /* Store pointers to private structures for future use */
+      s_pScreenPriv = (winPrivScreenPtr) lParam;
+      s_pScreenInfo = s_pScreenPriv->pScreenInfo;
+      s_pScreen = s_pScreenInfo->pScreen;
+
+      /* Set icon to standard app icon */
+      PostMessage (hDialog,
+		   WM_SETICON,
+		   ICON_SMALL,
+		   (LPARAM) LoadIcon (g_hInstance, MAKEINTRESOURCE(IDI_XWIN)));
+      return TRUE;
+
+    case WM_COMMAND:
+      switch (LOWORD (wParam))
+	{
+	case IDOK:
+	  /* Send message to call the GiveUp function */
+	  PostMessage (s_pScreenPriv->hwndScreen, WM_GIVEUP, 0, 0);
+	  DestroyWindow (g_hDlgExit);
+	  g_hDlgExit = NULL;
+
+	  /* Fix to make sure keyboard focus isn't trapped */
+	  PostMessage (s_pScreenPriv->hwndScreen, WM_NULL, 0, 0);
+	  return TRUE;
+
+	case IDCANCEL:
+	  DestroyWindow (g_hDlgExit);
+	  g_hDlgExit = NULL;
+
+	  /* Fix to make sure keyboard focus isn't trapped */
+	  PostMessage (s_pScreenPriv->hwndScreen, WM_NULL, 0, 0);
+	  return TRUE;
+	}
+      break;
+
+    case WM_MOUSEMOVE:
+    case WM_NCMOUSEMOVE:
+      /* Show the cursor if it is hidden */
+      if (!g_fCursor)
+	{
+	  g_fCursor = TRUE;
+	  ShowCursor (TRUE);
+	}
+      return TRUE;
+
+    case WM_CLOSE:
+      DestroyWindow (g_hDlgExit);
+      g_hDlgExit = NULL;
+
+      /* Fix to make sure keyboard focus isn't trapped */
+      PostMessage (s_pScreenPriv->hwndScreen, WM_NULL, 0, 0);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+
+/*
+ * Display the Depth Change dialog box
+ */
+
+void
+winDisplayDepthChangeDialog (winPrivScreenPtr pScreenPriv)
+{
+  /* Check if dialog already exists */
+  if (g_hDlgDepthChange != NULL)
+    {
+      /* Dialog box already exists, display it */
+      ShowWindow (g_hDlgDepthChange, SW_SHOWDEFAULT);
+
+      /* User has lost the dialog.  Show them where it is. */
+      SetForegroundWindow (g_hDlgDepthChange);
+
+      return;
+    }
+
+  /*
+   * Display a notification to the user that the visual 
+   * will not be displayed until the Windows display depth 
+   * is restored to the original value.
+   */
+  g_hDlgDepthChange = CreateDialogParam (g_hInstance,
+					 "DEPTH_CHANGE_BOX",
+					 pScreenPriv->hwndScreen,
+					 winChangeDepthDlgProc,
+					 (int) pScreenPriv);
+ 
+  /* Drop minimize and maximize buttons */
+  SetWindowLong (g_hDlgDepthChange, GWL_STYLE,
+		 GetWindowLong (g_hDlgDepthChange, GWL_STYLE)
+		 & ~(WS_MAXIMIZEBOX | WS_MINIMIZEBOX));
+  SetWindowLong (g_hDlgDepthChange, GWL_EXSTYLE,
+		 GetWindowLong (g_hDlgDepthChange, GWL_EXSTYLE)
+		 & ~WS_EX_APPWINDOW );
+  SetWindowPos (g_hDlgDepthChange, 0, 0, 0, 0, 0,
+		SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER | SWP_NOSIZE); 
+
+  /* Show the dialog box */
+  ShowWindow (g_hDlgDepthChange, SW_SHOW);
+  
+  ErrorF ("winDisplayDepthChangeDialog - DialogBox returned: %d\n",
+	  g_hDlgDepthChange);
+  ErrorF ("winDisplayDepthChangeDialog - GetLastError: %d\n", GetLastError ());
+	      
+  /* Minimize the display window */
+  ShowWindow (pScreenPriv->hwndScreen, SW_MINIMIZE);
+}
+
+
+/*
+ * Process messages for the dialog that is displayed for
+ * disruptive screen depth changes. 
+ */
+
+BOOL CALLBACK
+winChangeDepthDlgProc (HWND hwndDialog, UINT message,
+		       WPARAM wParam, LPARAM lParam)
+{
+  static winPrivScreenPtr	s_pScreenPriv = NULL;
+  static winScreenInfo		*s_pScreenInfo = NULL;
+  static ScreenPtr		s_pScreen = NULL;
+
+#if CYGDEBUG
+  ErrorF ("winChangeDepthDlgProc\n");
+#endif
+
+  /* Branch on message type */
+  switch (message)
+    {
+    case WM_INITDIALOG:
+#if CYGDEBUG
+      ErrorF ("winChangeDepthDlgProc - WM_INITDIALOG\n");
+#endif
+
+      /* Store pointers to private structures for future use */
+      s_pScreenPriv = (winPrivScreenPtr) lParam;
+      s_pScreenInfo = s_pScreenPriv->pScreenInfo;
+      s_pScreen = s_pScreenInfo->pScreen;
+
+#if CYGDEBUG
+      ErrorF ("winChangeDepthDlgProc - WM_INITDIALG - s_pScreenPriv: %08x, "
+	      "s_pScreenInfo: %08x, s_pScreen: %08x\n",
+	      s_pScreenPriv, s_pScreenInfo, s_pScreen);
+#endif
+
+#if CYGDEBUG
+      ErrorF ("winChangeDepthDlgProc - WM_INITDIALOG - orig bpp: %d, "
+	      "last bpp: %d\n",
+	      s_pScreenInfo->dwBPP,
+	      s_pScreenPriv->dwLastWindowsBitsPixel);
+#endif
+
+      /* Set icon to standard app icon */
+      PostMessage (hwndDialog,
+		   WM_SETICON,
+		   ICON_SMALL,
+		   (LPARAM) LoadIcon (g_hInstance, MAKEINTRESOURCE(IDI_XWIN)));
+
+      return TRUE;
+
+    case WM_DISPLAYCHANGE:
+#if CYGDEBUG
+      ErrorF ("winChangeDepthDlgProc - WM_DISPLAYCHANGE - orig bpp: %d, "
+	      "last bpp: %d, new bpp: %d\n",
+	      s_pScreenInfo->dwBPP,
+	      s_pScreenPriv->dwLastWindowsBitsPixel,
+	      wParam);
+#endif
+
+      /* Dismiss the dialog if the display returns to the original depth */
+      if (wParam == s_pScreenInfo->dwBPP)
+	{
+	  ErrorF ("winChangeDelthDlgProc - wParam == s_pScreenInfo->dwBPP\n");
+
+	  /* Depth has been restored, dismiss dialog */
+	  DestroyWindow (g_hDlgDepthChange);
+	  g_hDlgDepthChange = NULL;
+
+	  /* Flag that we have a valid screen depth */
+	  s_pScreenPriv->fBadDepth = FALSE;
+	}
+      return TRUE;
+
+    case WM_COMMAND:
+      switch (LOWORD (wParam))
+	{
+	case IDOK:
+	case IDCANCEL:
+	  ErrorF ("winChangeDepthDlgProc - WM_COMMAND - IDOK or IDCANCEL\n");
+
+	  /* 
+	   * User dismissed the dialog, hide it until the
+	   * display mode is restored.
+	   */
+	  ShowWindow (g_hDlgDepthChange, SW_HIDE);
+	  return TRUE;
+	}
+      break;
+
+    case WM_CLOSE:
+      ErrorF ("winChangeDepthDlgProc - WM_CLOSE\n");
+
+      /* 
+       * User dismissed the dialog, hide it until the
+       * display mode is restored.
+       */
+      ShowWindow (g_hDlgDepthChange, SW_HIDE);
+      return TRUE;
+    }
+
+  return FALSE;
+}
diff --git a/hw/xwin/winmultiwindowclass.c b/hw/xwin/winmultiwindowclass.c
new file mode 100755
index 000000000..21be64977
--- /dev/null
+++ b/hw/xwin/winmultiwindowclass.c
@@ -0,0 +1,284 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winmultiwindowclass.c,v 1.2 2003/10/02 13:30:10 eich Exp $ */
+
+#include <Xatom.h>
+#include "propertyst.h"
+#include "windowstr.h"
+#include "winmultiwindowclass.h"
+
+int
+winMultiWindowGetClassHint (WindowPtr pWin, char **res_name, char **res_class)
+{
+  struct _Window	*pwin;
+  struct _Property	*prop;
+  int			len_name, len_class;
+
+  if (!pWin || !res_name || !res_class)
+    {
+      ErrorF ("winMultiWindowGetClassHint - pWin, res_name, or res_class was "
+	      "NULL\n");
+      return 0;  
+    }
+  
+  pwin = (struct _Window*) pWin;
+
+  if (pwin->optional)
+    prop = (struct _Property *) pwin->optional->userProps;
+  else
+    prop = NULL;
+  
+  *res_name = *res_class = NULL;
+
+  while (prop)
+    {
+      if (prop->propertyName == XA_WM_CLASS
+	  && prop->type == XA_STRING
+	  && prop->format == 8
+	  && prop->data)
+	{
+	  len_name = strlen ((char *) prop->data);
+
+	  (*res_name) = malloc (len_name + 1);
+	  
+	  if (!*res_name)
+	    {
+	      ErrorF ("winMultiWindowGetClassHint - *res_name was NULL\n");
+	      return 0;
+	    }
+
+	  /* Add one to len_name to allow copying of trailing 0 */
+	  strncpy ((*res_name), prop->data, len_name + 1);
+
+	  if (len_name == prop->size)
+	    len_name--;
+
+	  len_class = strlen (((char *)prop->data) + 1 + len_name);
+
+	  (*res_class) = malloc (len_class + 1);
+
+	  if (!*res_class)
+	    {
+	      ErrorF ("winMultiWindowGetClassHint - *res_class was NULL\n");
+	      
+	      /* Free the previously allocated res_name */
+	      free (*res_name);
+	      return 0;
+	    }
+
+	  strcpy ((*res_class), ((char *)prop->data) + 1 + len_name);
+
+	  return 1;
+	}
+      else
+	prop = prop->next;
+    }
+  
+  return 0;
+}
+
+
+int
+winMultiWindowGetWMHints (WindowPtr pWin, WinXWMHints *hints)
+{
+  struct _Window	*pwin;
+  struct _Property	*prop;
+
+  if (!pWin || !hints)
+    {
+      ErrorF ("winMultiWindowGetWMHints - pWin or hints was NULL\n");
+      return 0; 
+    }
+
+  pwin = (struct _Window*) pWin;
+
+  if (pwin->optional)
+    prop = (struct _Property *) pwin->optional->userProps;
+  else
+    prop = NULL;
+  
+  memset (hints, 0, sizeof (WinXWMHints));
+
+  while (prop)
+    {
+      if (prop->propertyName == XA_WM_HINTS
+	  && prop->data)
+	{
+	  memcpy (hints, prop->data, sizeof (WinXWMHints));
+	  return 1;
+	}
+      else
+	prop = prop->next;
+    }
+  
+  return 0;
+}
+
+
+int
+winMultiWindowGetWindowRole (WindowPtr pWin, char **res_role)
+{
+  struct _Window	*pwin;
+  struct _Property	*prop;
+  int			len_role;
+  static Atom		atmWmWindowRole = 0;
+
+  if (!pWin || !res_role) 
+    return 0; 
+
+  /* Initialize the window role atom, not in XAtom.h */
+  if (!atmWmWindowRole)
+    atmWmWindowRole = MakeAtom ("WM_WINDOW_ROLE", 14, 1);
+
+  pwin = (struct _Window*) pWin;
+  
+  if (pwin->optional)
+    prop = (struct _Property *) pwin->optional->userProps;
+  else
+    prop = NULL;
+  
+  *res_role = NULL;
+  while (prop)
+    {
+      if (prop->propertyName == atmWmWindowRole
+	  && prop->type == XA_STRING
+	  && prop->format == 8
+	  && prop->data)
+	{
+	  len_role= strlen ((char *) prop->data);
+
+	  (*res_role) = malloc (len_role + 1);
+
+	  if (!*res_role)
+	    {
+	      ErrorF ("winMultiWindowGetWindowRole - *res_role was NULL\n");
+	      return 0; 
+	    }
+
+	  strcpy ((*res_role), prop->data);
+
+	  return 1;
+	}
+      else
+	prop = prop->next;
+    }
+  
+  return 0;
+}
+
+
+int
+winMultiWindowGetWMNormalHints (WindowPtr pWin, WinXSizeHints *hints)
+{
+  struct _Window	*pwin;
+  struct _Property	*prop;
+
+  if (!pWin || !hints)
+    {
+      ErrorF ("winMultiWindowGetWMNormalHints - pWin or hints was NULL\n");
+      return 0; 
+    }
+
+  pwin = (struct _Window*) pWin;
+
+  if (pwin->optional)
+    prop = (struct _Property *) pwin->optional->userProps;
+  else
+    prop = NULL;
+  
+  memset (hints, 0, sizeof (WinXSizeHints));
+
+  while (prop)
+    {
+      if (prop->propertyName == XA_WM_NORMAL_HINTS
+	  && prop->data)
+	{
+	  memcpy (hints, prop->data, sizeof (WinXSizeHints));
+	  return 1;
+	}
+      else
+	prop = prop->next;
+    }
+  
+  return 0;
+}
+
+
+int
+winMultiWindowGetWMName (WindowPtr pWin, char **wmName)
+{
+  struct _Window	*pwin;
+  struct _Property	*prop;
+  int			len_name;
+
+  if (!pWin || !wmName)
+    {
+      ErrorF ("winMultiWindowGetClassHint - pWin, res_name, or res_class was "
+	      "NULL\n");
+      return 0;  
+    }
+  
+  pwin = (struct _Window*) pWin;
+
+  if (pwin->optional)
+    prop = (struct _Property *) pwin->optional->userProps;
+  else
+    prop = NULL;
+  
+  *wmName = NULL;
+
+  while (prop)
+    {
+      if (prop->propertyName == XA_WM_NAME
+	  && prop->type == XA_STRING
+	  && prop->data)
+	{
+	  len_name = strlen ((char *) prop->data);
+
+	  (*wmName) = malloc (len_name + 1);
+	  
+	  if (!*wmName)
+	    {
+	      ErrorF ("winMultiWindowGetWMName - *wmName was NULL\n");
+	      return 0;
+	    }
+
+	  /* Add one to len_name to allow copying of trailing 0 */
+	  strncpy ((*wmName), prop->data, len_name+1);
+
+	  return 1;
+	}
+      else
+	prop = prop->next;
+    }
+  
+  return 0;
+}
+
diff --git a/hw/xwin/winmultiwindowclass.h b/hw/xwin/winmultiwindowclass.h
new file mode 100755
index 000000000..b6ad55d8b
--- /dev/null
+++ b/hw/xwin/winmultiwindowclass.h
@@ -0,0 +1,110 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winmultiwindowclass.h,v 1.2 2003/10/02 13:30:10 eich Exp $ */
+
+
+/*
+ * Structures
+ */
+
+typedef struct {
+  long		flags;	/* marks which fields in this structure are defined */
+  Bool		input;	/* does this application rely on the window manager to
+		   get keyboard input? */
+  int		initial_state;	/* see below */
+  Pixmap	icon_pixmap;	/* pixmap to be used as icon */
+  Window	icon_window; 	/* window to be used as icon */
+  int		icon_x, icon_y; 	/* initial position of icon */
+  Pixmap	icon_mask;	/* icon mask bitmap */
+  XID		window_group;	/* id of related window group */
+  /* this structure may be extended in the future */
+} WinXWMHints;
+
+
+/*
+ * new version containing base_width, base_height, and win_gravity fields;
+ * used with WM_NORMAL_HINTS.
+ */
+typedef struct {
+  long flags;     /* marks which fields in this structure are defined */
+  int x, y;               /* obsolete for new window mgrs, but clients */
+  int width, height;      /* should set so old wm's don't mess up */
+  int min_width, min_height;
+  int max_width, max_height;
+  int width_inc, height_inc;
+  struct {
+    int x;  /* numerator */
+    int y;  /* denominator */
+  } min_aspect, max_aspect;
+  int base_width, base_height;            /* added by ICCCM version 1 */
+  int win_gravity;                        /* added by ICCCM version 1 */
+} WinXSizeHints;
+
+/*
+ * The next block of definitions are for window manager properties that
+ * clients and applications use for communication.
+ */
+
+/* flags argument in size hints */
+#define USPosition      (1L << 0) /* user specified x, y */
+#define USSize          (1L << 1) /* user specified width, height */
+
+#define PPosition       (1L << 2) /* program specified position */
+#define PSize           (1L << 3) /* program specified size */
+#define PMinSize        (1L << 4) /* program specified minimum size */
+#define PMaxSize        (1L << 5) /* program specified maximum size */
+#define PResizeInc      (1L << 6) /* program specified resize increments */
+#define PAspect         (1L << 7) /* program specified min and max aspect ratios */
+#define PBaseSize       (1L << 8) /* program specified base for incrementing */
+#define PWinGravity     (1L << 9) /* program specified window gravity */
+
+/* obsolete */
+#define PAllHints (PPosition|PSize|PMinSize|PMaxSize|PResizeInc|PAspect)
+
+
+/*
+ * Function prototypes
+ */
+
+int
+winMultiWindowGetWMHints (WindowPtr pWin, WinXWMHints *hints);
+
+int
+winMultiWindowGetClassHint (WindowPtr pWin, char **res_name, char **res_class);
+
+int
+winMultiWindowGetWindowRole (WindowPtr pWin, char **res_role);
+
+int
+winMultiWindowGetWMNormalHints (WindowPtr pWin, WinXSizeHints *hints);
+
+int
+winMultiWindowGetWMName (WindowPtr pWin, char **wmName);
+
diff --git a/hw/xwin/winmultiwindowicons.c b/hw/xwin/winmultiwindowicons.c
new file mode 100755
index 000000000..dd56db6d6
--- /dev/null
+++ b/hw/xwin/winmultiwindowicons.c
@@ -0,0 +1,378 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winmultiwindowicons.c,v 1.2 2003/10/02 13:30:10 eich Exp $ */
+
+#include "win.h"
+#include "dixevents.h"
+#include "winmultiwindowclass.h"
+#include "winprefs.h"
+
+
+/*
+ * External global variables
+ */
+
+extern HICON		g_hiconX;
+
+
+/*
+ * Prototypes for local functions
+ */
+
+static void
+winScaleXBitmapToWindows (int iconSize, int effBPP,
+			  PixmapPtr pixmap, unsigned char *image);
+
+
+/*
+ * Scale an X icon bitmap into a Windoze icon bitmap
+ */
+
+static void
+winScaleXBitmapToWindows (int iconSize,
+			  int effBPP,
+			  PixmapPtr pixmap,
+			  unsigned char *image)
+{
+  int			row, column, effXBPP, effXDepth;
+  unsigned char		*outPtr;
+  unsigned char		*iconData = 0;
+  int			stride, xStride;
+  float			factX, factY;
+  int			posX, posY;
+  unsigned char		*ptr;
+  unsigned int		zero;
+  unsigned int		color;
+
+
+  if (pixmap->drawable.bitsPerPixel == 15)
+    effXBPP = 16;
+  else
+    effXBPP = pixmap->drawable.bitsPerPixel;
+  
+  if (pixmap->drawable.depth == 15)
+    effXDepth = 16;
+  else
+    effXDepth = pixmap->drawable.depth;
+
+  /* Need 32-bit aligned rows */
+  stride = ((iconSize * effBPP + 31) & (~31)) / 8;
+  xStride  = ((pixmap->drawable.width * effXBPP + 31) & (~31)) / 8;
+  
+  iconData = malloc (xStride * pixmap->drawable.height);
+  miGetImage ((DrawablePtr) &(pixmap->drawable), 0, 0,
+	      pixmap->drawable.width, pixmap->drawable.height,
+	      ZPixmap, 0xffffffff, iconData);
+  
+  /* Keep aspect ratio */
+  factX = ((float)pixmap->drawable.width) / ((float)iconSize);
+  factY = ((float)pixmap->drawable.height) / ((float)iconSize);
+  if (factX > factY)
+    factY = factX;
+  else
+    factX = factY;
+  
+  /* Out-of-bounds, fill icon with zero */
+  zero = 0;
+ 
+  for (row = 0; row < iconSize; row++)
+    {
+      outPtr = image + stride * row;
+      for (column = 0; column < iconSize; column++)
+	{
+	  posX = factX * column;
+	  posY = factY * row;
+	  
+	  ptr = iconData + posY*xStride;
+	  if (effXBPP == 1)
+	    {
+	      ptr += posX / 8;
+	      
+	      /* Out of X icon bounds, leave space blank */
+	      if (posX >= pixmap->drawable.width
+		  || posY >= pixmap->drawable.height)
+		ptr = (unsigned char *) &zero;
+	      
+	      if ((*ptr) & (1 << (posX & 7)))
+		switch (effBPP)
+		  {
+		  case 32:
+		    *(outPtr++) = 0;
+		  case 24:
+		    *(outPtr++) = 0;
+		  case 16:
+		    *(outPtr++) = 0;
+		  case 8:
+		    *(outPtr++) = 0;
+		    break;
+		  case 1:
+		    outPtr[column / 8] &= ~(1 << (7 - (column & 7)));
+		    break;
+		  }
+	      else
+		switch (effBPP)
+		  {
+		  case 32:
+		    *(outPtr++) = 255;
+		    *(outPtr++) = 255;
+		    *(outPtr++) = 255;
+		    *(outPtr++) = 0;
+		    break;
+		  case 24:
+		    *(outPtr++) = 255;
+		  case 16:
+		    *(outPtr++) = 255;
+		  case 8: 
+		    *(outPtr++) = 255;
+		    break;
+		  case 1:
+		    outPtr[column / 8] |= (1 << (7 - (column & 7)));
+		    break;
+		  }
+	    }
+	  else if (effXDepth == 24 || effXDepth == 32)
+	    {
+	      ptr += posX * (effXBPP / 8);
+
+	      /* Out of X icon bounds, leave space blank */
+	      if (posX >= pixmap->drawable.width
+		  || posY >= pixmap->drawable.height)
+		ptr = (unsigned char *) &zero;
+	      color = (((*ptr) << 16)
+		       + ((*(ptr + 1)) << 8)
+		       + ((*(ptr + 2)) << 0));
+	      switch (effBPP)
+		{
+		case 32:
+		  *(outPtr++) = *(ptr++); // b
+		  *(outPtr++) = *(ptr++); // g
+		  *(outPtr++) = *(ptr++); // r
+		  *(outPtr++) = 0; // resvd
+		  break;
+		case 24:
+		  *(outPtr++) = *(ptr++);
+		  *(outPtr++) = *(ptr++);
+		  *(outPtr++) = *(ptr++);
+		  break;
+		case 16:
+		  color = ((((*ptr) >> 2) << 10)
+			   + (((*(ptr + 1)) >> 2) << 5)
+			   + (((*(ptr + 2)) >> 2)));
+		  *(outPtr++) = (color >> 8);
+		  *(outPtr++) = (color & 255);
+		  break;
+		case 8:
+		  color = (((*ptr))) + (((*(ptr + 1)))) + (((*(ptr + 2))));
+		  color /= 3;
+		  *(outPtr++) = color;
+		  break;
+		case 1:
+		  if (color)
+		    outPtr[column / 8] |= (1 << (7 - (column & 7)));
+		  else
+		    outPtr[column / 8] &= ~(1 << (7 - (column & 7)));
+		}
+	    }
+	  else if (effXDepth == 16)
+	    {
+	      ptr += posX * (effXBPP / 8);
+	
+	      /* Out of X icon bounds, leave space blank */
+	      if (posX >= pixmap->drawable.width
+		  || posY >= pixmap->drawable.height)
+		ptr = (unsigned char *) &zero;
+	      color = ((*ptr) << 8) + (*(ptr + 1));
+	      switch (effBPP)
+		{
+		case 32:
+		  *(outPtr++) = (color & 31) << 2;
+		  *(outPtr++) = ((color >> 5) & 31) << 2;
+		  *(outPtr++) = ((color >> 10) & 31) << 2;
+		  *(outPtr++) = 0; // resvd
+		  break;
+		case 24:
+		  *(outPtr++) = (color & 31) << 2;
+		  *(outPtr++) = ((color >> 5) & 31) << 2;
+		  *(outPtr++) = ((color >> 10) & 31) << 2;
+		  break;
+		case 16:
+		  *(outPtr++) = *(ptr++);
+		  *(outPtr++) = *(ptr++);
+		  break;
+		case 8:
+		  *(outPtr++) = (((color & 31)
+				  + ((color >> 5) & 31)
+				  + ((color >> 10) & 31)) / 3) << 2;
+		  break;
+		case 1:
+		  if (color)
+		    outPtr[column / 8] |= (1 << (7 - (column & 7)));
+		  else
+		    outPtr[column / 8] &= ~(1 << (7 - (column & 7)));
+		  break;
+		} /* end switch(effbpp) */
+	    } /* end if effxbpp==16) */
+	} /* end for column */
+    } /* end for row */
+  free (iconData);
+}
+
+
+/*
+ * Attempt to create a custom icon from the WM_HINTS bitmaps
+ */
+
+HICON
+winXIconToHICON (WindowPtr pWin)
+{
+  unsigned char		*mask, *image, *imageMask;
+  unsigned char		*dst, *src;
+  PixmapPtr		iconPtr;
+  PixmapPtr		maskPtr;
+  int			iconSize, planes, bpp, effBPP, stride, maskStride, i;
+  HDC			hDC;
+  ICONINFO		ii;
+  WinXWMHints		hints;
+  HICON			hIcon;
+
+  winMultiWindowGetWMHints (pWin, &hints);
+  if (!hints.icon_pixmap) return NULL;
+
+  iconPtr = LookupIDByType (hints.icon_pixmap, RT_PIXMAP);
+  
+  if (!iconPtr) return NULL;
+  
+  iconSize = 32;
+  
+  hDC = GetDC (GetDesktopWindow ());
+  planes = GetDeviceCaps (hDC, PLANES);
+  bpp = GetDeviceCaps (hDC, BITSPIXEL);
+  ReleaseDC (GetDesktopWindow (), hDC);
+  
+  /* 15 BPP is really 16BPP as far as we care */
+  if (bpp == 15)
+    effBPP = 16;
+  else
+    effBPP = bpp;
+  
+  /* Need 32-bit aligned rows */
+  stride = ((iconSize * effBPP + 31) & (~31)) / 8;
+
+  /* Mask is 1-bit deep */
+  maskStride = ((iconSize * 1 + 31) & (~31)) / 8; 
+
+  image = (unsigned char * ) malloc (stride * iconSize);
+  imageMask = (unsigned char *) malloc (stride * iconSize);
+  mask = (unsigned char *) malloc (maskStride * iconSize);
+  
+  /* Default to a completely black mask */
+  memset (mask, 0, maskStride * iconSize);
+  
+  winScaleXBitmapToWindows (iconSize, effBPP, iconPtr, image);
+  maskPtr = LookupIDByType (hints.icon_mask, RT_PIXMAP);
+
+  if (maskPtr) 
+    {
+      winScaleXBitmapToWindows (iconSize, 1, maskPtr, mask);
+      
+      winScaleXBitmapToWindows (iconSize, effBPP, maskPtr, imageMask);
+      
+      /* Now we need to set all bits of the icon which are not masked */
+      /* on to 0 because Color is really an XOR, not an OR function */
+      dst = image;
+      src = imageMask;
+
+      for (i = 0; i < (stride * iconSize); i++)
+	if ((*(src++)))
+	  *(dst++) = 0;
+	else
+	  dst++;
+    }
+  
+  ii.fIcon = TRUE;
+  ii.xHotspot = 0; /* ignored */
+  ii.yHotspot = 0; /* ignored */
+  
+  /* Create Win32 mask from pixmap shape */
+  ii.hbmMask = CreateBitmap (iconSize, iconSize, planes, 1, mask);
+
+  /* Create Win32 bitmap from pixmap */
+  ii.hbmColor = CreateBitmap (iconSize, iconSize, planes, bpp, image);
+
+  /* Merge Win32 mask and bitmap into icon */
+  hIcon = CreateIconIndirect (&ii);
+
+  /* Release Win32 mask and bitmap */
+  DeleteObject (ii.hbmMask);
+  DeleteObject (ii.hbmColor);
+
+  /* Free X mask and bitmap */
+  free (mask);
+  free (image);
+  free (imageMask);
+
+  return hIcon;
+}
+
+
+
+/*
+ * Change the Windows window icon 
+ */
+
+void
+winUpdateIcon (Window id)
+{
+  WindowPtr		pWin;
+  HICON			hIcon, hiconOld;
+
+  pWin = LookupIDByType (id, RT_WINDOW);
+  hIcon = (HICON)winOverrideIcon ((unsigned long)pWin);
+
+  if (!hIcon)
+    hIcon = winXIconToHICON (pWin);
+
+  if (hIcon)
+    {
+      winWindowPriv(pWin);
+
+      if (pWinPriv->hWnd)
+	{
+	  hiconOld = (HICON) SetClassLong (pWinPriv->hWnd,
+					   GCL_HICON,
+					   (int) hIcon);
+	  
+	  /* Delete the icon if its not the default */
+	  if (hiconOld != g_hiconX &&
+	      !winIconIsOverride((unsigned long)hiconOld))
+	    DeleteObject (hiconOld);
+	}
+    }
+}
diff --git a/hw/xwin/winmultiwindowshape.c b/hw/xwin/winmultiwindowshape.c
new file mode 100755
index 000000000..5c623d14e
--- /dev/null
+++ b/hw/xwin/winmultiwindowshape.c
@@ -0,0 +1,212 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Kensuke Matsuzaki
+ *		Harold L Hunt II
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winmultiwindowshape.c,v 1.2 2003/11/10 18:22:44 tsi Exp $ */
+
+#ifdef SHAPE
+
+#include "win.h"
+
+
+/*
+ * External global variables
+ */
+
+extern HICON		g_hiconX;
+
+
+/*
+ * winSetShapeMultiWindow - See Porting Layer Definition - p. 42
+ */
+
+void
+winSetShapeMultiWindow (WindowPtr pWin)
+{
+#if CYGMULTIWINDOW_DEBUG
+  ErrorF ("winSetShapeMultiWindow - pWin: %08x\n", pWin);
+#endif
+  
+  /* Call any wrapped SetShape function */
+  if (winGetScreenPriv(pWin->drawable.pScreen)->SetShape)
+    winGetScreenPriv(pWin->drawable.pScreen)->SetShape (pWin);
+  
+  /* Update the Windows window's shape */
+  winReshapeMultiWindow (pWin);
+  winUpdateRgnMultiWindow (pWin);
+
+  return;
+}
+
+
+/*
+ * winUpdateRgnMultiWindow - Local function to update a Windows window region
+ */
+
+void
+winUpdateRgnMultiWindow (WindowPtr pWin)
+{
+  SetWindowRgn (winGetWindowPriv(pWin)->hWnd,
+		winGetWindowPriv(pWin)->hRgn, TRUE);
+}
+
+
+/*
+ * winReshapeMultiWindow - Computes the composite clipping region for a window
+ */
+
+void
+winReshapeMultiWindow (WindowPtr pWin)
+{
+  int		nRects;
+  RegionRec	rrNewShape;
+  BoxPtr	pShape, pRects, pEnd;
+  HRGN		hRgn, hRgnRect;
+  winWindowPriv(pWin);
+
+#if CYGDEBUG
+  ErrorF ("winReshape ()\n");
+#endif
+  
+  /* Bail if the window is the root window */
+  if (pWin->parent == NULL)
+    return;
+
+  /* Bail if the window is not top level */
+  if (pWin->parent->parent != NULL)
+    return;
+
+  /* Bail if Windows window handle is invalid */
+  if (pWinPriv->hWnd == NULL)
+    return;
+  
+  /* Free any existing window region stored in the window privates */
+  if (pWinPriv->hRgn != NULL)
+    {
+      DeleteObject (pWinPriv->hRgn);
+      pWinPriv->hRgn = NULL;
+    }
+  
+  /* Bail if the window has no bounding region defined */
+  if (!wBoundingShape (pWin))
+    return;
+
+  REGION_NULL(pScreen, &rrNewShape);
+  REGION_COPY(pScreen, &rrNewShape, wBoundingShape(pWin));
+  REGION_TRANSLATE(pScreen,
+		   &rrNewShape,
+		   pWin->borderWidth,
+                   pWin->borderWidth);
+  
+  nRects = REGION_NUM_RECTS(&rrNewShape);
+  pShape = REGION_RECTS(&rrNewShape);
+  
+  /* Don't do anything if there are no rectangles in the region */
+  if (nRects > 0)
+    {
+      RECT			rcClient;
+      RECT			rcWindow;
+      int			iOffsetX, iOffsetY;
+      
+      /* Get client rectangle */
+      if (!GetClientRect (pWinPriv->hWnd, &rcClient))
+	{
+	  ErrorF ("winReshape - GetClientRect failed, bailing: %d\n",
+		  GetLastError ());
+	  return;
+	}
+
+      /* Translate client rectangle coords to screen coords */
+      /* NOTE: Only transforms top and left members */
+      ClientToScreen (pWinPriv->hWnd, (LPPOINT) &rcClient);
+
+      /* Get window rectangle */
+      if (!GetWindowRect (pWinPriv->hWnd, &rcWindow))
+	{
+	  ErrorF ("winReshape - GetWindowRect failed, bailing: %d\n",
+		  GetLastError ());
+	  return;
+	}
+
+      /* Calculate offset from window upper-left to client upper-left */
+      iOffsetX = rcClient.left - rcWindow.left;
+      iOffsetY = rcClient.top - rcWindow.top;
+
+      /* Create initial Windows region for title bar */
+      /* FIXME: Mean, nasty, ugly hack!!! */
+      hRgn = CreateRectRgn (0, 0, rcWindow.right, iOffsetY);
+      if (hRgn == NULL)
+	{
+	  ErrorF ("winReshape - Initial CreateRectRgn (%d, %d, %d, %d) "
+		  "failed: %d\n",
+		  0, 0, rcWindow.right, iOffsetY, GetLastError ());
+	}
+
+      /* Loop through all rectangles in the X region */
+      for (pRects = pShape, pEnd = pShape + nRects; pRects < pEnd; pRects++)
+        {
+	  /* Create a Windows region for the X rectangle */
+	  hRgnRect = CreateRectRgn (pRects->x1 + iOffsetX - 1,
+				    pRects->y1 + iOffsetY - 1,
+				    pRects->x2 + iOffsetX - 1,
+				    pRects->y2 + iOffsetY - 1);
+	  if (hRgnRect == NULL)
+	    {
+	      ErrorF ("winReshape - Loop CreateRectRgn (%d, %d, %d, %d) "
+		      "failed: %d\n"
+		      "\tx1: %d x2: %d xOff: %d y1: %d y2: %d yOff: %d\n",
+		      pRects->x1 + iOffsetX - 1,
+		      pRects->y1 + iOffsetY - 1,
+		      pRects->x2 + iOffsetX - 1,
+		      pRects->y2 + iOffsetY - 1,
+		      GetLastError (),
+		      pRects->x1, pRects->x2, iOffsetX,
+		      pRects->y1, pRects->y2, iOffsetY);
+	    }
+
+	  /* Merge the Windows region with the accumulated region */
+	  if (CombineRgn (hRgn, hRgn, hRgnRect, RGN_OR) == ERROR)
+	    {
+	      ErrorF ("winReshape - CombineRgn () failed: %d\n",
+		      GetLastError ());
+	    }
+
+	  /* Delete the temporary Windows region */
+	  DeleteObject (hRgnRect);
+        }
+      
+      /* Save a handle to the composite region in the window privates */
+      pWinPriv->hRgn = hRgn;
+    }
+
+  REGION_UNINIT(pScreen, &rrNewShape);
+  
+  return;
+}
+#endif
diff --git a/hw/xwin/winmultiwindowwndproc.c b/hw/xwin/winmultiwindowwndproc.c
new file mode 100755
index 000000000..d90abb61f
--- /dev/null
+++ b/hw/xwin/winmultiwindowwndproc.c
@@ -0,0 +1,1005 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Kensuke Matsuzaki
+ *		Earle F. Philhower, III
+ *		Harold L Hunt II
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winmultiwindowwndproc.c,v 1.3 2003/10/08 11:13:03 eich Exp $ */
+
+#include "win.h"
+#include "dixevents.h"
+#include "winmultiwindowclass.h"
+#include "winprefs.h"
+
+/*
+ * External global variables
+ */
+
+extern Bool		g_fCursor;
+
+
+/*
+ * Global variables
+ */
+
+HICON			g_hiconX = NULL;
+
+
+/*
+ * Local globals
+ */
+
+static UINT_PTR		g_uipMousePollingTimerID = 0;
+
+
+/*
+ * Constant defines
+ */
+
+#define MOUSE_POLLING_INTERVAL		500
+#define WIN_MULTIWINDOW_SHAPE		YES
+
+
+
+/*
+ * ConstrainSize - Taken from TWM sources - Respects hints for sizing
+ */
+#define makemult(a,b) ((b==1) ? (a) : (((int)((a)/(b))) * (b)) )
+static void
+ConstrainSize (WinXSizeHints hints, int *widthp, int *heightp)
+{
+  int minWidth, minHeight, maxWidth, maxHeight, xinc, yinc, delta;
+  int baseWidth, baseHeight;
+  int dwidth = *widthp, dheight = *heightp;
+  
+  if (hints.flags & PMinSize)
+    {
+      minWidth = hints.min_width;
+      minHeight = hints.min_height;
+    }
+  else if (hints.flags & PBaseSize)
+    {
+      minWidth = hints.base_width;
+      minHeight = hints.base_height;
+    }
+  else
+    minWidth = minHeight = 1;
+  
+  if (hints.flags & PBaseSize)
+    {
+      baseWidth = hints.base_width;
+      baseHeight = hints.base_height;
+    } 
+  else if (hints.flags & PMinSize)
+    {
+      baseWidth = hints.min_width;
+      baseHeight = hints.min_height;
+    }
+  else
+    baseWidth = baseHeight = 0;
+
+  if (hints.flags & PMaxSize)
+    {
+      maxWidth = hints.max_width;
+      maxHeight = hints.max_height;
+    }
+  else
+    {
+      maxWidth = MAXINT;
+      maxHeight = MAXINT;
+    }
+
+  if (hints.flags & PResizeInc)
+    {
+      xinc = hints.width_inc;
+      yinc = hints.height_inc;
+    }
+  else
+    xinc = yinc = 1;
+
+  /*
+   * First, clamp to min and max values
+   */
+  if (dwidth < minWidth)
+    dwidth = minWidth;
+  if (dheight < minHeight)
+    dheight = minHeight;
+
+  if (dwidth > maxWidth)
+    dwidth = maxWidth;
+  if (dheight > maxHeight)
+    dheight = maxHeight;
+
+  /*
+   * Second, fit to base + N * inc
+   */
+  dwidth = ((dwidth - baseWidth) / xinc * xinc) + baseWidth;
+  dheight = ((dheight - baseHeight) / yinc * yinc) + baseHeight;
+  
+  /*
+   * Third, adjust for aspect ratio
+   */
+
+  /*
+   * The math looks like this:
+   *
+   * minAspectX    dwidth     maxAspectX
+   * ---------- <= ------- <= ----------
+   * minAspectY    dheight    maxAspectY
+   *
+   * If that is multiplied out, then the width and height are
+   * invalid in the following situations:
+   *
+   * minAspectX * dheight > minAspectY * dwidth
+   * maxAspectX * dheight < maxAspectY * dwidth
+   * 
+   */
+  
+  if (hints.flags & PAspect)
+    {
+      if (hints.min_aspect.x * dheight > hints.min_aspect.y * dwidth)
+        {
+	  delta = makemult(hints.min_aspect.x * dheight / hints.min_aspect.y - dwidth, xinc);
+	  if (dwidth + delta <= maxWidth)
+	    dwidth += delta;
+	  else
+            {
+	      delta = makemult(dheight - dwidth*hints.min_aspect.y/hints.min_aspect.x, yinc);
+	      if (dheight - delta >= minHeight)
+		dheight -= delta;
+            }
+        }
+      
+      if (hints.max_aspect.x * dheight < hints.max_aspect.y * dwidth)
+        {
+	  delta = makemult(dwidth * hints.max_aspect.y / hints.max_aspect.x - dheight, yinc);
+	  if (dheight + delta <= maxHeight)
+	    dheight += delta;
+	  else
+            {
+	      delta = makemult(dwidth - hints.max_aspect.x*dheight/hints.max_aspect.y, xinc);
+	      if (dwidth - delta >= minWidth)
+		dwidth -= delta;
+            }
+        }
+    }
+  
+  /* Return computed values */
+  *widthp = dwidth;
+  *heightp = dheight;
+}
+#undef makemult
+
+
+
+/*
+ * ValidateSizing - Ensures size request respects hints
+ */
+static int
+ValidateSizing (HWND hwnd, WindowPtr pWin,
+		WPARAM wParam, LPARAM lParam)
+{
+  WinXSizeHints sizeHints;
+  RECT *rect;
+  int iWidth, iHeight, iTopBorder;
+  POINT pt;
+
+  /* Invalid input checking */
+  if (pWin==NULL || lParam==0)
+    return FALSE;
+
+  /* No size hints, no checking */
+  if (!winMultiWindowGetWMNormalHints (pWin, &sizeHints))
+    return FALSE;
+  
+  /* Avoid divide-by-zero */
+  if (sizeHints.flags & PResizeInc)
+    {
+      if (sizeHints.width_inc == 0) sizeHints.width_inc = 1;
+      if (sizeHints.height_inc == 0) sizeHints.height_inc = 1;
+    }
+  
+  rect = (RECT*)lParam;
+  
+  iWidth = rect->right - rect->left;
+  iHeight = rect->bottom - rect->top;
+
+  /* Get title bar height, there must be an easier way?! */
+  pt.x = pt.y = 0;
+  ClientToScreen(hwnd, &pt);
+  iTopBorder = pt.y - rect->top;
+  
+  /* Now remove size of any borders */
+  iWidth -= 2 * GetSystemMetrics(SM_CXSIZEFRAME);
+  iHeight -= GetSystemMetrics(SM_CYSIZEFRAME) + iTopBorder;
+
+  /* Constrain the size to legal values */
+  ConstrainSize (sizeHints, &iWidth, &iHeight);
+
+  /* Add back the borders */
+  iWidth += 2 * GetSystemMetrics(SM_CXSIZEFRAME);
+  iHeight += GetSystemMetrics(SM_CYSIZEFRAME) + iTopBorder;
+
+  /* Adjust size according to where we're dragging from */
+  switch(wParam) {
+  case WMSZ_TOP:
+  case WMSZ_TOPRIGHT:
+  case WMSZ_BOTTOM:
+  case WMSZ_BOTTOMRIGHT:
+  case WMSZ_RIGHT:
+    rect->right = rect->left + iWidth;
+    break;
+  default:
+    rect->left = rect->right - iWidth;
+    break;
+  }
+  switch(wParam) {
+  case WMSZ_BOTTOM:
+  case WMSZ_BOTTOMRIGHT:
+  case WMSZ_BOTTOMLEFT:
+  case WMSZ_RIGHT:
+  case WMSZ_LEFT:
+    rect->bottom = rect->top + iHeight;
+    break;
+  default:
+    rect->top = rect->bottom - iHeight;
+    break;
+  }
+  return TRUE;
+}
+
+
+/*
+ * winTopLevelWindowProc - Window procedure for all top-level Windows windows.
+ */
+
+LRESULT CALLBACK
+winTopLevelWindowProc (HWND hwnd, UINT message, 
+		       WPARAM wParam, LPARAM lParam)
+{
+  POINT			ptMouse;
+  HDC			hdcUpdate;
+  PAINTSTRUCT		ps;
+  WindowPtr		pWin = NULL;
+  winPrivWinPtr	        pWinPriv = NULL;
+  ScreenPtr		s_pScreen = NULL;
+  winPrivScreenPtr	s_pScreenPriv = NULL;
+  winScreenInfo		*s_pScreenInfo = NULL;
+  HWND			hwndScreen = NULL;
+  DrawablePtr		pDraw = NULL;
+  int		        iX, iY, iWidth, iHeight, iBorder;
+  winWMMessageRec	wmMsg;
+  Bool                  fWMMsgInitialized = FALSE;
+  static Bool		s_fTracking = FALSE;
+  
+  /* Check if the Windows window property for our X window pointer is valid */
+  if ((pWin = GetProp (hwnd, WIN_WINDOW_PROP)) != NULL)
+    {
+      /* Our X window pointer is valid */
+
+      /* Get pointers to the drawable and the screen */
+      pDraw		= &pWin->drawable;
+      s_pScreen		= pWin->drawable.pScreen;
+
+      /* Get a pointer to our window privates */
+      pWinPriv		= winGetWindowPriv(pWin);
+
+      /* Get pointers to our screen privates and screen info */
+      s_pScreenPriv	= pWinPriv->pScreenPriv;
+      s_pScreenInfo	= s_pScreenPriv->pScreenInfo;
+
+      /* Get the handle for our screen-sized window */
+      hwndScreen	= s_pScreenPriv->hwndScreen;
+
+      /* */
+      wmMsg.msg		= 0;
+      wmMsg.hwndWindow	= hwnd;
+      wmMsg.iWindow	= (Window)GetProp (hwnd, WIN_WID_PROP);
+
+      wmMsg.iX		= pWinPriv->iX;
+      wmMsg.iY		= pWinPriv->iY;
+      wmMsg.iWidth	= pWinPriv->iWidth;
+      wmMsg.iHeight	= pWinPriv->iHeight;
+
+      fWMMsgInitialized = TRUE;
+
+#if 0
+      /*
+       * Print some debugging information
+       */
+
+      ErrorF ("hWnd %08X\n", hwnd);
+      ErrorF ("pWin %08X\n", pWin);
+      ErrorF ("pDraw %08X\n", pDraw);
+      ErrorF ("\ttype %08X\n", pWin->drawable.type);
+      ErrorF ("\tclass %08X\n", pWin->drawable.class);
+      ErrorF ("\tdepth %08X\n", pWin->drawable.depth);
+      ErrorF ("\tbitsPerPixel %08X\n", pWin->drawable.bitsPerPixel);
+      ErrorF ("\tid %08X\n", pWin->drawable.id);
+      ErrorF ("\tx %08X\n", pWin->drawable.x);
+      ErrorF ("\ty %08X\n", pWin->drawable.y);
+      ErrorF ("\twidth %08X\n", pWin->drawable.width);
+      ErrorF ("\thenght %08X\n", pWin->drawable.height);
+      ErrorF ("\tpScreen %08X\n", pWin->drawable.pScreen);
+      ErrorF ("\tserialNumber %08X\n", pWin->drawable.serialNumber);
+      ErrorF ("g_iWindowPrivateIndex %d\n", g_iWindowPrivateIndex);
+      ErrorF ("pWinPriv %08X\n", pWinPriv);
+      ErrorF ("s_pScreenPriv %08X\n", s_pScreenPriv);
+      ErrorF ("s_pScreenInfo %08X\n", s_pScreenInfo);
+      ErrorF ("hwndScreen %08X\n", hwndScreen);
+#endif
+    }
+
+  /* Branch on message type */
+  switch (message)
+    {
+    case WM_CREATE:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_CREATE\n");
+#endif
+
+      /* */
+      SetProp (hwnd,
+	       WIN_WINDOW_PROP,
+	       (HANDLE)((LPCREATESTRUCT) lParam)->lpCreateParams);
+      
+      /* */
+      SetProp (hwnd,
+	       WIN_WID_PROP,
+	       (HANDLE)winGetWindowID (((LPCREATESTRUCT) lParam)->lpCreateParams));
+
+      return 0;
+
+
+    case WM_INIT_SYS_MENU:
+      /*
+       * Add whatever the setup file wants to for this window
+       */
+      SetupSysMenu ((unsigned long)hwnd);
+      return 0;
+
+    case WM_SYSCOMMAND:
+      /*
+       * Any window menu items go through here
+       */
+      HandleCustomWM_COMMAND ((unsigned long)hwnd, LOWORD(wParam));
+      break;
+
+    case WM_INITMENU:
+      /* Checks/Unchecks any menu items before they are displayed */
+      HandleCustomWM_INITMENU ((unsigned long)hwnd, wParam);
+      break;
+
+    case WM_PAINT:
+      /* Only paint if our window handle is valid */
+      if (hwndScreen == NULL)
+	break;
+
+      /* BeginPaint gives us an hdc that clips to the invalidated region */
+      hdcUpdate = BeginPaint (hwnd, &ps);
+
+      /* Get the position and dimensions of the window */
+      iBorder = wBorderWidth (pWin);
+      iX = pWin->drawable.x;
+      iY = pWin->drawable.y;
+      iWidth = pWin->drawable.width;
+      iHeight = pWin->drawable.height;
+
+      /* Try to copy from the shadow buffer */
+      if (!BitBlt (hdcUpdate,
+		   0, 0,
+		   iWidth, iHeight,
+		   s_pScreenPriv->hdcShadow,
+		   iX, iY,
+		   SRCCOPY))
+	{
+	  LPVOID lpMsgBuf;
+	  
+	  /* Display a fancy error message */
+	  FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+			 FORMAT_MESSAGE_FROM_SYSTEM | 
+			 FORMAT_MESSAGE_IGNORE_INSERTS,
+			 NULL,
+			 GetLastError (),
+			 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			 (LPTSTR) &lpMsgBuf,
+			 0, NULL);
+
+	  ErrorF ("winTopLevelWindowProc - BitBlt failed: %s\n",
+		  (LPSTR)lpMsgBuf);
+	  LocalFree (lpMsgBuf);
+	}
+
+      /* EndPaint frees the DC */
+      EndPaint (hwndScreen, &ps);
+      return 0;
+
+    case WM_MOUSEMOVE:
+      /* Unpack the client area mouse coordinates */
+      ptMouse.x = GET_X_LPARAM(lParam);
+      ptMouse.y = GET_Y_LPARAM(lParam);
+
+      /* Translate the client area mouse coordinates to screen coordinates */
+      ClientToScreen (hwnd, &ptMouse);
+
+      /* Screen Coords from (-X, -Y) -> Root Window (0, 0) */
+      ptMouse.x -= GetSystemMetrics (SM_XVIRTUALSCREEN);
+      ptMouse.y -= GetSystemMetrics (SM_YVIRTUALSCREEN);
+
+      /* We can't do anything without privates */
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+
+      /* Has the mouse pointer crossed screens? */
+      if (s_pScreen != miPointerCurrentScreen ())
+	miPointerSetNewScreen (s_pScreenInfo->dwScreen,
+			       ptMouse.x - s_pScreenInfo->dwXOffset,
+			       ptMouse.y - s_pScreenInfo->dwYOffset);
+
+      /* Are we tracking yet? */
+      if (!s_fTracking)
+	{
+	  TRACKMOUSEEVENT		tme;
+	  
+	  /* Setup data structure */
+	  ZeroMemory (&tme, sizeof (tme));
+	  tme.cbSize = sizeof (tme);
+	  tme.dwFlags = TME_LEAVE;
+	  tme.hwndTrack = hwnd;
+
+	  /* Call the tracking function */
+	  if (!(*g_fpTrackMouseEvent) (&tme))
+	    ErrorF ("winTopLevelWindowProc - _TrackMouseEvent failed\n");
+
+	  /* Flag that we are tracking now */
+	  s_fTracking = TRUE;
+	}
+      
+      /* Hide or show the Windows mouse cursor */
+      if (g_fCursor)
+	{
+	  /* Hide Windows cursor */
+	  g_fCursor = FALSE;
+	  ShowCursor (FALSE);
+	}
+
+      /* Kill the timer used to poll mouse events */
+      if (g_uipMousePollingTimerID != 0)
+	{
+	  KillTimer (s_pScreenPriv->hwndScreen, WIN_POLLING_MOUSE_TIMER_ID);
+	  g_uipMousePollingTimerID = 0;
+	}
+
+      /* Deliver absolute cursor position to X Server */
+      miPointerAbsoluteCursor (ptMouse.x - s_pScreenInfo->dwXOffset,
+			       ptMouse.y - s_pScreenInfo->dwYOffset,
+			       g_c32LastInputEventTime = GetTickCount ());
+      return 0;
+      
+    case WM_NCMOUSEMOVE:
+      /*
+       * We break instead of returning 0 since we need to call
+       * DefWindowProc to get the mouse cursor changes
+       * and min/max/close button highlighting in Windows XP.
+       * The Platform SDK says that you should return 0 if you
+       * process this message, but it fails to mention that you
+       * will give up any default functionality if you do return 0.
+       */
+      
+      /* We can't do anything without privates */
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+
+      /* Non-client mouse movement, show Windows cursor */
+      if (!g_fCursor)
+	{
+	  g_fCursor = TRUE;
+	  ShowCursor (TRUE);
+	}
+
+      /*
+       * Timer to poll mouse events.  This is needed to make
+       * programs like xeyes follow the mouse properly.
+       */
+      if (g_uipMousePollingTimerID == 0)
+	g_uipMousePollingTimerID = SetTimer (s_pScreenPriv->hwndScreen,
+					     WIN_POLLING_MOUSE_TIMER_ID,
+					     MOUSE_POLLING_INTERVAL,
+					     NULL);
+      break;
+
+    case WM_MOUSELEAVE:
+      /* Mouse has left our client area */
+
+      /* Flag that we are no longer tracking */
+      s_fTracking = FALSE;
+
+      /* Show the mouse cursor, if necessary */
+      if (!g_fCursor)
+	{
+	  g_fCursor = TRUE;
+	  ShowCursor (TRUE);
+	}
+
+      /*
+       * Timer to poll mouse events.  This is needed to make
+       * programs like xeyes follow the mouse properly.
+       */
+      if (g_uipMousePollingTimerID == 0)
+	g_uipMousePollingTimerID = SetTimer (s_pScreenPriv->hwndScreen,
+					     WIN_POLLING_MOUSE_TIMER_ID,
+					     MOUSE_POLLING_INTERVAL,
+					     NULL);
+      return 0;
+
+    case WM_LBUTTONDBLCLK:
+    case WM_LBUTTONDOWN:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonPress, Button1, wParam);
+      
+    case WM_LBUTTONUP:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button1, wParam);
+
+    case WM_MBUTTONDBLCLK:
+    case WM_MBUTTONDOWN:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonPress, Button2, wParam);
+      
+    case WM_MBUTTONUP:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button2, wParam);
+      
+    case WM_RBUTTONDBLCLK:
+    case WM_RBUTTONDOWN:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonPress, Button3, wParam);
+      
+    case WM_RBUTTONUP:
+      if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
+	break;
+      return winMouseButtonsHandle (s_pScreen, ButtonRelease, Button3, wParam);
+
+    case WM_MOUSEWHEEL:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_MOUSEWHEEL\n");
+#endif
+      
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+      return 0;
+
+    case WM_KILLFOCUS:
+      /* Pop any pressed keys since we are losing keyboard focus */
+      winKeybdReleaseKeys ();
+      return 0;
+
+    case WM_SYSDEADCHAR:      
+    case WM_DEADCHAR:
+      /*
+       * NOTE: We do nothing with WM_*CHAR messages,
+       * nor does the root window, so we can just toss these messages.
+       */
+      return 0;
+
+    case WM_SYSKEYDOWN:
+    case WM_KEYDOWN:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_*KEYDOWN\n");
+#endif
+
+      /*
+       * Don't pass Alt-F4 key combo to root window,
+       * let Windows translate to WM_CLOSE and close this top-level window.
+       *
+       * NOTE: We purposely don't check the fUseWinKillKey setting because
+       * it should only apply to the key handling for the root window,
+       * not for top-level window-manager windows.
+       *
+       * ALSO NOTE: We do pass Ctrl-Alt-Backspace to the root window
+       * because that is a key combo that no X app should be expecting to
+       * receive, since it has historically been used to shutdown the X server.
+       * Passing Ctrl-Alt-Backspace to the root window preserves that
+       * behavior, assuming that -unixkill has been passed as a parameter.
+       */
+      if (wParam == VK_F4 && (GetKeyState (VK_MENU) & 0x8000))
+	  break;
+
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+      return 0;
+
+    case WM_SYSKEYUP:
+    case WM_KEYUP:
+
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_*KEYUP\n");
+#endif
+
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+      return 0;
+
+    case WM_HOTKEY:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_HOTKEY\n");
+#endif
+
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+      return 0;
+
+    case WM_ACTIVATE:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_ACTIVATE\n");
+#endif
+
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+
+      if (s_pScreenPriv != NULL)
+	s_pScreenPriv->fWindowOrderChanged = TRUE;
+
+      if (LOWORD(wParam) != WA_INACTIVE)
+	{
+	  /* Tell our Window Manager thread to activate the window */
+	  wmMsg.msg = WM_WM_ACTIVATE;
+	  if (fWMMsgInitialized)
+	    winSendMessageToWM (s_pScreenPriv->pWMInfo, &wmMsg);
+	}
+      return 0;
+
+    case WM_ACTIVATEAPP:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_ACTIVATEAPP\n");
+#endif
+      
+      /* Pass the message to the root window */
+      SendMessage (hwndScreen, message, wParam, lParam);
+      return 0;
+
+    case WM_CLOSE:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_CLOSE\n");
+#endif
+      /* Branch on if the window was killed in X already */
+      if (pWinPriv->fXKilled)
+        {
+	  /* Window was killed, go ahead and destroy the window */
+	  DestroyWindow (hwnd);
+	}
+      else
+	{
+	  /* Tell our Window Manager thread to kill the window */
+	  wmMsg.msg = WM_WM_KILL;
+	  if (fWMMsgInitialized)
+	    winSendMessageToWM (s_pScreenPriv->pWMInfo, &wmMsg);
+	}
+      return 0;
+
+    case WM_DESTROY:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_DESTROY\n");
+#endif
+
+      /* Branch on if the window was killed in X already */
+      if (pWinPriv && !pWinPriv->fXKilled)
+	{
+	  ErrorF ("winTopLevelWindowProc - WM_DESTROY - WM_WM_KILL\n");
+	  
+	  /* Tell our Window Manager thread to kill the window */
+	  wmMsg.msg = WM_WM_KILL;
+	  if (fWMMsgInitialized)
+	    winSendMessageToWM (s_pScreenPriv->pWMInfo, &wmMsg);
+	}
+
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_DESTROY\n");
+#endif
+      break;
+
+    case WM_MOVE:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_MOVE - %d ms\n", GetTickCount ());
+#endif
+      
+      /* Bail if Windows window is not actually moving */
+      if (pWinPriv->iX == (short) LOWORD(lParam)
+	  && pWinPriv->iY == (short) HIWORD(lParam))
+	break;
+
+      /* Also bail if we're maximizing, we'll do the whole thing in WM_SIZE */
+      {
+	WINDOWPLACEMENT windPlace;
+	windPlace.length = sizeof (WINDOWPLACEMENT);
+
+	/* Get current window placement */
+	GetWindowPlacement (hwnd, &windPlace);
+
+	/* Bail if maximizing */
+	if (windPlace.showCmd == SW_MAXIMIZE
+	    || windPlace.showCmd == SW_SHOWMAXIMIZED)
+	  break;
+      } 
+
+      /* Get new position */
+      pWinPriv->iX = (short) LOWORD(lParam);
+      pWinPriv->iY = (short) HIWORD(lParam);
+
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("\t(%d, %d)\n", pWinPriv->iX, pWinPriv->iY);
+#endif
+
+      winMoveXWindow (pWin,
+		      (LOWORD(lParam) - wBorderWidth (pWin)
+		       - GetSystemMetrics (SM_XVIRTUALSCREEN)),
+		      (HIWORD(lParam) - wBorderWidth (pWin)
+		       - GetSystemMetrics (SM_YVIRTUALSCREEN)));
+      return 0;
+
+    case WM_SHOWWINDOW:
+      /* Bail out if the window is being hidden */
+      if (!wParam)
+	return 0;
+
+      /* Tell X to map the window */
+      MapWindow (pWin, wClient(pWin));
+
+      /* */
+      if (!pWin->overrideRedirect)
+	{
+	  DWORD		dwExStyle;
+	  DWORD		dwStyle;
+	  RECT		rcNew;
+	  int		iDx, iDy;
+	      
+	  /* Flag that this window needs to be made active when clicked */
+	  SetProp (hwnd, WIN_NEEDMANAGE_PROP, (HANDLE) 1);
+
+	  /* Get the standard and extended window style information */
+	  dwExStyle = GetWindowLongPtr (hwnd, GWL_EXSTYLE);
+	  dwStyle = GetWindowLongPtr (hwnd, GWL_STYLE);
+
+	  /* */
+	  if (dwExStyle != WS_EX_APPWINDOW)
+	    {
+	      /* Setup a rectangle with the X window position and size */
+	      SetRect (&rcNew,
+		       pWinPriv->iX,
+		       pWinPriv->iY,
+		       pWinPriv->iX + pWinPriv->iWidth,
+		       pWinPriv->iY + pWinPriv->iHeight);
+
+#if 0
+	      ErrorF ("winTopLevelWindowProc - (%d, %d)-(%d, %d)\n",
+		      rcNew.left, rcNew.top,
+		      rcNew.right, rcNew.bottom);
+#endif
+
+	      /* */
+	      AdjustWindowRectEx (&rcNew,
+				  WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW,
+				  FALSE,
+				  WS_EX_APPWINDOW);
+
+	      /* Calculate position deltas */
+	      iDx = pWinPriv->iX - rcNew.left;
+	      iDy = pWinPriv->iY - rcNew.top;
+
+	      /* Calculate new rectangle */
+	      rcNew.left += iDx;
+	      rcNew.right += iDx;
+	      rcNew.top += iDy;
+	      rcNew.bottom += iDy;
+
+#if 0
+	      ErrorF ("winTopLevelWindowProc - (%d, %d)-(%d, %d)\n",
+		      rcNew.left, rcNew.top,
+		      rcNew.right, rcNew.bottom);
+#endif
+
+	      /* Set the window extended style flags */
+	      SetWindowLongPtr (hwnd, GWL_EXSTYLE, WS_EX_APPWINDOW);
+
+	      /* Set the window standard style flags */
+	      SetWindowLongPtr (hwnd, GWL_STYLE,
+				WS_POPUP | WS_SIZEBOX | WS_OVERLAPPEDWINDOW);
+
+	      /* Position the Windows window */
+	      SetWindowPos (hwnd, HWND_TOP,
+			    rcNew.left, rcNew.top,
+			    rcNew.right - rcNew.left, rcNew.bottom - rcNew.top,
+			    SWP_NOMOVE | SWP_FRAMECHANGED
+			    | SWP_SHOWWINDOW | SWP_NOACTIVATE);
+
+	      /* Bring the Windows window to the foreground */
+	      SetForegroundWindow (hwnd);
+	    }
+	}
+	  
+      /* Setup the Window Manager message */
+      wmMsg.msg = WM_WM_MAP;
+      wmMsg.iWidth = pWinPriv->iWidth;
+      wmMsg.iHeight = pWinPriv->iHeight;
+
+      /* Tell our Window Manager thread to map the window */
+      if (fWMMsgInitialized)
+	winSendMessageToWM (s_pScreenPriv->pWMInfo, &wmMsg);
+
+      if (s_pScreenPriv != NULL)
+	s_pScreenPriv->fWindowOrderChanged = TRUE;
+      return 0;
+
+    case WM_SIZING:
+      /* Need to legalize the size according to WM_NORMAL_HINTS */
+      /* for applications like xterm */
+      return ValidateSizing (hwnd, pWin, wParam, lParam);
+
+    case WM_WINDOWPOSCHANGED:
+      {
+	LPWINDOWPOS pwindPos = (LPWINDOWPOS) lParam;
+
+	/* Bail if window z order was not changed */
+	if (pwindPos->flags & SWP_NOZORDER)
+	  break;
+
+#if CYGMULTIWINDOW_DEBUG
+	ErrorF ("winTopLevelWindowProc - hwndInsertAfter: %p\n",
+		pwindPos->hwndInsertAfter);
+#endif
+	
+	/* Pass the message to the root window */
+	SendMessage (hwndScreen, message, wParam, lParam);
+	
+	if (s_pScreenPriv != NULL)
+	  s_pScreenPriv->fWindowOrderChanged = TRUE;
+      }
+      return 0;
+
+    case WM_SIZE:
+      /* see dix/window.c */
+
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_SIZE - %d ms\n", GetTickCount ());
+#endif
+
+      /* Branch on type of resizing occurring */
+      switch (wParam)
+	{
+	case SIZE_MINIMIZED:
+#if CYGMULTIWINDOW_DEBUG
+	  ErrorF ("\tSIZE_MINIMIZED\n");
+#endif
+	  if (s_pScreenPriv != NULL)
+	    s_pScreenPriv->fWindowOrderChanged = TRUE;
+	  break;
+
+	case SIZE_RESTORED:
+	case SIZE_MAXIMIZED:
+#if CYGMULTIWINDOW_DEBUG
+	  ErrorF ("SIZE_RESTORED || SIZE_MAXIMIZED\n");
+#endif
+	  /* Break out if nothing to do */
+	  if (pWinPriv->iWidth == (short) LOWORD(lParam)
+	      && pWinPriv->iHeight == (short) HIWORD(lParam))
+	    break;
+	  
+	  /* Get the dimensions of the resized Windows window  */
+	  pWinPriv->iWidth = (short) LOWORD(lParam);
+	  pWinPriv->iHeight = (short) HIWORD(lParam);
+
+#if CYGMULTIWINDOW_DEBUG
+	  ErrorF ("\t(%d, %d)\n", pWinPriv->iWidth, pWinPriv->iHeight);
+#endif
+
+	  /*
+	   * If we're maximizing the window has been moved to upper left
+	   * of current screen.  Now it is safe for X to know about this.
+	   */
+	  if (wParam == SIZE_MAXIMIZED)
+	    {
+	      POINT		ptHome;
+
+	      /* Flag that we are being maximized and store info for restore */
+	      pWinPriv->fNeedRestore = TRUE;
+	      pWinPriv->ptRestore.x = pWinPriv->iX;
+	      pWinPriv->ptRestore.y = pWinPriv->iY;
+	     
+	      /* Get screen location of window root */
+	      ptHome.x = 0;
+	      ptHome.y = 0;
+	      ClientToScreen (hwnd, &ptHome);
+
+	      /* Map from screen (-X,-Y) to (0,0) root coords */
+	      winMoveXWindow (pWin,
+			      ptHome.x - wBorderWidth (pWin)
+			      - GetSystemMetrics (SM_XVIRTUALSCREEN),
+			      ptHome.y - wBorderWidth (pWin)
+			      - GetSystemMetrics (SM_YVIRTUALSCREEN));
+	    }
+	  else if (wParam == SIZE_RESTORED && pWinPriv->fNeedRestore)
+	    {
+	      /* If need restore and !maximized then move to cached position */
+	      WINDOWPLACEMENT windPlace;
+
+	      windPlace.length = sizeof (WINDOWPLACEMENT);
+
+	      GetWindowPlacement (hwnd, &windPlace);
+
+	      if (windPlace.showCmd != SW_MAXIMIZE
+		  && windPlace.showCmd != SW_SHOWMAXIMIZED)
+		{
+		  pWinPriv->fNeedRestore = FALSE;
+		  winMoveXWindow (pWin,
+				  pWinPriv->ptRestore.x  - wBorderWidth (pWin)
+				  - GetSystemMetrics (SM_XVIRTUALSCREEN),
+				  pWinPriv->ptRestore.y - wBorderWidth (pWin)
+				  - GetSystemMetrics (SM_YVIRTUALSCREEN));
+		}
+	    }
+
+	  /* Perform the resize and notify the X client */
+	  winResizeXWindow (pWin,
+			    (short) LOWORD(lParam),
+			    (short) HIWORD(lParam));
+	  break;
+
+	default:
+	  break;
+	}
+      return 0;
+
+    case WM_MOUSEACTIVATE:
+#if CYGMULTIWINDOW_DEBUG
+      ErrorF ("winTopLevelWindowProc - WM_MOUSEACTIVATE\n");
+#endif
+
+      /* Check if this window needs to be made active when clicked */
+      if (!GetProp (pWinPriv->hWnd, WIN_NEEDMANAGE_PROP))
+	{
+#if CYGMULTIWINDOW_DEBUG
+	  ErrorF ("winTopLevelWindowProc - WM_MOUSEACTIVATE - "
+		  "MA_NOACTIVATE\n");
+#endif
+
+	  /* */
+	  return MA_NOACTIVATE;
+	}
+      break;
+
+    default:
+      break;
+    }
+
+  return DefWindowProc (hwnd, message, wParam, lParam);
+}
diff --git a/hw/xwin/winprefs.c b/hw/xwin/winprefs.c
new file mode 100644
index 000000000..3bea60d3d
--- /dev/null
+++ b/hw/xwin/winprefs.c
@@ -0,0 +1,661 @@
+/*
+ * Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ * 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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winprefs.c,v 1.1 2003/10/02 13:30:11 eich Exp $ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+#include "win.h"
+
+/* Fixups to prevent collisions between Windows and X headers */
+#define ATOM DWORD
+#include <windows.h>
+
+#include "winprefs.h"
+#include "winmultiwindowclass.h"
+
+/* Where will the custom menu commands start counting from? */
+#define STARTMENUID WM_USER
+
+/* From winmultiwindowflex.l, the real parser */
+extern void parse_file (FILE *fp);
+
+/* From winmultiwindowyacc.y, the pref structure loaded by the parser */
+extern WINMULTIWINDOWPREFS pref;
+
+/* The global X default icon */
+extern HICON		g_hiconX;
+
+/* Currently in use command ID, incremented each new menu item created */
+static int g_cmdid = STARTMENUID;
+
+
+/* Defined in DIX */
+extern char *display;
+
+/*
+ * Creates or appends a menu from a MENUPARSED structure
+ */
+static HMENU
+MakeMenu (char *name,
+	  HMENU editMenu,
+	  int editItem)
+{
+  int i;
+  int item;
+  MENUPARSED *m;
+  HMENU hmenu;
+
+  for (i=0; i<pref.menuItems; i++)
+    {
+      if (!strcmp(name, pref.menu[i].menuName))
+	break;
+    }
+  
+  /* Didn't find a match, bummer */
+  if (i==pref.menuItems)
+    {
+      ErrorF("MakeMenu: Can't find menu %s\n", name);
+      return NULL;
+    }
+  
+  m = &(pref.menu[i]);
+
+  if (editMenu)
+    {
+      hmenu = editMenu;
+      item = editItem;
+    }
+  else
+    {
+      hmenu = CreatePopupMenu();
+      item = 0;
+    }
+
+  /* Add the menu items */
+  for (i=0; i<m->menuItems; i++)
+    {
+      /* Only assign IDs one time... */
+      if ( m->menuItem[i].commandID == 0 )
+	m->menuItem[i].commandID = g_cmdid++;
+
+      switch (m->menuItem[i].cmd)
+	{
+	case CMD_EXEC:
+	case CMD_ALWAYSONTOP:
+	case CMD_RELOAD:
+	  InsertMenu (hmenu,
+		      item,
+		      MF_BYPOSITION|MF_ENABLED|MF_STRING,
+		      m->menuItem[i].commandID,
+		      m->menuItem[i].text);
+	  break;
+	  
+	case CMD_SEPARATOR:
+	  InsertMenu (hmenu,
+		      item,
+		      MF_BYPOSITION|MF_SEPARATOR,
+		      0,
+		      NULL);
+	  break;
+	  
+	case CMD_MENU:
+	  /* Recursive! */
+	  InsertMenu (hmenu,
+		      item,
+		      MF_BYPOSITION|MF_POPUP|MF_ENABLED|MF_STRING,
+		      (UINT_PTR)MakeMenu (m->menuItem[i].param, 0, 0),
+		      m->menuItem[i].text);
+	  break;
+	}
+
+      /* If item==-1 (means to add at end of menu) don't increment) */
+      if (item>=0)
+	item++;
+    }
+
+  return hmenu;
+}
+
+
+/*
+ * Callback routine that is executed once per window class.
+ * Removes or creates custom window settings depending on LPARAM
+ */
+static BOOL CALLBACK
+ReloadEnumWindowsProc (HWND hwnd, LPARAM lParam)
+{
+  char    szClassName[1024];
+  HICON   hicon;
+
+  if (!GetClassName (hwnd, szClassName, 1024))
+    return TRUE;
+
+  if (strncmp (szClassName, WINDOW_CLASS_X, strlen (WINDOW_CLASS_X)))
+    /* Not one of our windows... */
+    return TRUE;
+  
+  /* It's our baby, either clean or dirty it */
+  if (lParam==FALSE) 
+    {
+      hicon = (HICON)GetClassLong(hwnd, GCL_HICON);
+
+      /* Unselect any icon in the class structure */
+      SetClassLong (hwnd, GCL_HICON, (LONG)LoadIcon (NULL, IDI_APPLICATION));
+
+      /* If it's generated on-the-fly, get rid of it, will regen */
+      if (!winIconIsOverride((unsigned long)hicon) && hicon!=g_hiconX)
+	DestroyIcon (hicon);
+      
+      /* Remove any menu additions, use bRevert flag */
+      GetSystemMenu (hwnd, TRUE);
+      
+      /* This window is now clean of our taint */
+    }
+  else
+    {
+      /* Make the icon default, dynamic, of from xwinrc */
+      SetClassLong (hwnd, GCL_HICON, (LONG)g_hiconX);
+      winUpdateIcon ((Window)GetProp (hwnd, WIN_WID_PROP));
+      /* Update the system menu for this window */
+      SetupSysMenu ((unsigned long)hwnd);
+
+      /* That was easy... */
+    }
+
+  return TRUE;
+}
+
+
+/*
+ * Removes any custom icons in classes, custom menus, etc.
+ * Frees all members in pref structure.
+ * Reloads the preferences file.
+ * Set custom icons and menus again.
+ */
+static void
+ReloadPrefs ()
+{
+  int i;
+
+  /* First, iterate over all windows replacing their icon with system */
+  /* default one and deleting any custom system menus                 */
+  EnumWindows (ReloadEnumWindowsProc, FALSE);
+  
+  /* Now, free/clear all info from our prefs structure */
+  for (i=0; i<pref.menuItems; i++)
+    free (pref.menu[i].menuItem);
+  free (pref.menu);
+  pref.menu = NULL;
+  pref.menuItems = 0;
+
+  pref.rootMenuName[0] = 0;
+
+  free (pref.sysMenu);
+  pref.sysMenuItems = 0;
+
+  pref.defaultSysMenuName[0] = 0;
+  pref.defaultSysMenuPos = 0;
+
+  pref.iconDirectory[0] = 0;
+  pref.defaultIconName[0] = 0;
+
+  for (i=0; i<pref.iconItems; i++)
+    if (pref.icon[i].hicon)
+      DestroyIcon ((HICON)pref.icon[i].hicon);
+  free (pref.icon);
+  pref.icon = NULL;
+  pref.iconItems = 0;
+  
+  /* Free global default X icon */
+  DestroyIcon (g_hiconX);
+
+  /* Reset the custom command IDs */
+  g_cmdid = STARTMENUID;
+
+  /* Load the updated resource file */
+  LoadPreferences();
+
+  /* Define global icon, load it */
+  g_hiconX = (HICON)winOverrideDefaultIcon();
+  if (!g_hiconX)
+    g_hiconX = LoadIcon (g_hInstance, MAKEINTRESOURCE(IDI_XWIN));
+  
+  /* Rebuild the icons and menus */
+  EnumWindows (ReloadEnumWindowsProc, TRUE);
+
+  /* Whew, done */
+}
+
+/*
+ * Check/uncheck the ALWAYSONTOP items in this menu
+ */
+void
+HandleCustomWM_INITMENU(unsigned long hwndIn,
+			unsigned long hmenuIn)
+{
+  HWND    hwnd;
+  HMENU   hmenu;
+  DWORD   dwExStyle;
+  int     i, j;
+
+  hwnd = (HWND)hwndIn;
+  hmenu = (HMENU)hmenuIn;
+  if (!hwnd || !hmenu) 
+    return;
+  
+  if (GetWindowLong (hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST)
+    dwExStyle = MF_BYCOMMAND | MF_CHECKED;
+  else
+    dwExStyle = MF_BYCOMMAND | MF_UNCHECKED;
+
+  for (i=0; i<pref.menuItems; i++)
+    for (j=0; j<pref.menu[i].menuItems; j++)
+      if (pref.menu[i].menuItem[j].cmd==CMD_ALWAYSONTOP)
+	CheckMenuItem (hmenu, pref.menu[i].menuItem[j].commandID, dwExStyle );
+  
+}
+    
+/*
+ * Searches for the custom WM_COMMAND command ID and performs action
+ */
+int
+HandleCustomWM_COMMAND (unsigned long hwndIn,
+			int           command)
+{
+  HWND hwnd;
+  int i, j;
+  MENUPARSED *m;
+  DWORD			dwExStyle;
+
+  hwnd = (HWND)hwndIn;
+
+  if (!command)
+    return 0;
+
+  for (i=0; i<pref.menuItems; i++)
+    {
+      m = &(pref.menu[i]);
+      for (j=0; j<m->menuItems; j++)
+	{
+	  if (command==m->menuItem[j].commandID)
+	    {
+	      /* Match! */
+	      switch(m->menuItem[j].cmd)
+		{
+		case CMD_EXEC:
+		  if (fork()==0)
+		    {
+		      struct rlimit rl;
+		      unsigned long i;
+
+		      /* Close any open descriptors except for STD* */
+		      getrlimit (RLIMIT_NOFILE, &rl);
+		      for (i = STDERR_FILENO+1; i < rl.rlim_cur; i++)
+			close(i);
+
+		      /* Disassociate any TTYs */
+		      setsid();
+
+		      execl ("/bin/sh",
+			     "/bin/sh",
+			     "-c",
+			     m->menuItem[j].param,
+			     NULL);
+		      exit (0);
+		    }
+		  else
+		    return 0;
+		  break;
+		  
+		case CMD_ALWAYSONTOP:
+		  if (!hwnd)
+		    return 0;
+
+		  /* Get extended window style */
+		  dwExStyle = GetWindowLong (hwnd, GWL_EXSTYLE);
+		  
+		  /* Handle topmost windows */
+		  if (dwExStyle & WS_EX_TOPMOST)
+		    SetWindowPos (hwnd,
+				  HWND_NOTOPMOST,
+				  0, 0,
+				  0, 0,
+				  SWP_NOSIZE | SWP_NOMOVE);
+		  else
+		    SetWindowPos (hwnd,
+				  HWND_TOPMOST,
+				  0, 0,
+				  0, 0,
+				  SWP_NOSIZE | SWP_NOMOVE);
+		  return 0;
+		  
+		case CMD_RELOAD:
+		  ReloadPrefs();
+		  return 0;
+
+		default:
+		  return 0;
+	      }
+	    } /* match */
+	} /* for j */
+    } /* for i */
+
+  return 0;
+}
+
+
+/*
+ * Add the default or a custom menu depending on the class match
+ */
+void
+SetupSysMenu (unsigned long hwndIn)
+{
+  HWND    hwnd;
+  HMENU	  sys;
+  int     i;
+  WindowPtr pWin;
+  char *res_name, *res_class;
+
+  hwnd = (HWND)hwndIn;
+  if (!hwnd)
+    return;
+
+  pWin = GetProp (hwnd, WIN_WINDOW_PROP);
+  
+  sys = GetSystemMenu (hwnd, FALSE);
+  if (!sys)
+    return;
+
+  if (pWin)
+    {
+      /* First see if there's a class match... */
+      if (winMultiWindowGetClassHint (pWin, &res_name, &res_class))
+	{
+	  for (i=0; i<pref.sysMenuItems; i++)
+	    {
+	      if (!strcmp(pref.sysMenu[i].match, res_name) ||
+		  !strcmp(pref.sysMenu[i].match, res_class) ) 
+		{
+		  free(res_name);
+		  free(res_class);
+  
+		  MakeMenu (pref.sysMenu[i].menuName, sys,
+			    pref.sysMenu[i].menuPos==AT_START?0:-1);
+		  return;
+		}
+	    }
+	  
+	  /* No match, just free alloc'd strings */
+	  free(res_name);
+	  free(res_class);
+	} /* Found wm_class */
+    } /* if pwin */
+
+  /* Fallback to system default */
+  if (pref.defaultSysMenuName[0])
+    {
+      if (pref.defaultSysMenuPos==AT_START)
+	MakeMenu (pref.defaultSysMenuName, sys, 0);
+      else
+	MakeMenu (pref.defaultSysMenuName, sys, -1);
+    }
+}
+
+
+/*
+ * Possibly add a menu to the toolbar icon
+ */
+void
+SetupRootMenu (unsigned long hmenuRoot)
+{
+  HMENU root;
+
+  root = (HMENU)hmenuRoot;
+  if (!root)
+    return;
+
+  if (pref.rootMenuName[0])
+    {
+      MakeMenu(pref.rootMenuName, root, 0);
+    }
+}
+
+
+/*
+ * Check for and return an overridden default ICON specified in the prefs
+ */
+unsigned long
+winOverrideDefaultIcon()
+{
+  HICON hicon;
+  char fname[PATH_MAX+NAME_MAX+2];
+  
+  if (pref.defaultIconName[0])
+    {
+      /* Make sure we have a dir with trailing backslash */
+      /* Note we are using _Windows_ paths here, not cygwin */
+      strcpy (fname, pref.iconDirectory);
+      if (pref.iconDirectory[0])
+	if (fname[strlen(fname)-1]!='\\')
+	  strcat (fname, "\\");
+      strcat (fname, pref.defaultIconName);
+
+      hicon = (HICON)LoadImage(NULL,
+			       fname,
+			       IMAGE_ICON,
+			       0, 0,
+			       LR_DEFAULTSIZE|LR_LOADFROMFILE);
+      if (hicon==NULL)
+	ErrorF ("winOverrideDefaultIcon: LoadIcon(%s) failed\n", fname);
+
+      return (unsigned long)hicon;
+    }
+
+  return 0;
+}
+
+
+/*
+ * Check for a match of the window class to one specified in the
+ * ICONS{} section in the prefs file, and load the icon from a file
+ */
+unsigned long
+winOverrideIcon (unsigned long longWin)
+{
+  WindowPtr pWin = (WindowPtr) longWin;
+  char *res_name, *res_class;
+  int i;
+  HICON hicon;
+  char fname[PATH_MAX+NAME_MAX+2];
+  char *wmName;
+
+  if (pWin==NULL)
+    return 0;
+
+  /* If we can't find the class, we can't override from default! */
+  if (!winMultiWindowGetClassHint (pWin, &res_name, &res_class))
+    return 0;
+
+  winMultiWindowGetWMName (pWin, &wmName);
+  
+  for (i=0; i<pref.iconItems; i++) {
+    if (!strcmp(pref.icon[i].match, res_name) ||
+	!strcmp(pref.icon[i].match, res_class) ||
+	(wmName && strstr(wmName, pref.icon[i].match))) 
+      {
+	free (res_name);
+	free (res_class);
+	if (wmName)
+	  free (wmName);
+
+	if (pref.icon[i].hicon)
+	  return pref.icon[i].hicon;
+
+	/* Make sure we have a dir with trailing backslash */
+	/* Note we are using _Windows_ paths here, not cygwin */
+	strcpy (fname, pref.iconDirectory);
+	if (pref.iconDirectory[0])
+	  if (fname[strlen(fname)-1]!='\\')
+	    strcat (fname, "\\");
+	strcat (fname, pref.icon[i].iconFile);
+
+	hicon = (HICON)LoadImage(NULL,
+				 fname,
+				 IMAGE_ICON,
+				 0, 0,
+				 LR_DEFAULTSIZE|LR_LOADFROMFILE);
+	if (hicon==NULL)
+	  ErrorF ("winOverrideIcon: LoadIcon(%s) failed\n", fname);
+
+	pref.icon[i].hicon = (unsigned long)hicon;
+	return (unsigned long)hicon;
+      }
+  }
+  
+  /* Didn't find the icon, fail gracefully */
+  free (res_name);
+  free (res_class);
+  if (wmName)
+    free (wmName);
+
+  return 0;
+}
+
+
+/*
+ * Should we free this icon or leave it in memory (is it part of our
+ * ICONS{} overrides)?
+ */
+int
+winIconIsOverride(unsigned hiconIn)
+{
+  HICON hicon;
+  int i;
+
+  hicon = (HICON)hiconIn;
+
+  if (!hicon)
+    return 0;
+  
+  for (i=0; i<pref.iconItems; i++)
+    if ((HICON)pref.icon[i].hicon == hicon)
+      return 1;
+  
+  return 0;
+}
+
+
+
+/*
+ * Try and open ~/.XWinrc and /usr/X11R6/lib/X11/system.XWinrc
+ * Load it into prefs structure for use by other functions
+ */
+void
+LoadPreferences ()
+{
+  char *home;
+  char fname[PATH_MAX+NAME_MAX+2];
+  FILE *prefFile;
+  char szDisplay[512];
+  char *szEnvDisplay;
+  int i, j;
+  char param[PARAM_MAX+1];
+  char *srcParam, *dstParam;
+
+  /* First, clear all preference settings */
+  memset (&pref, 0, sizeof(pref));
+  prefFile = NULL;
+
+  /* Now try and find a ~/.xwinrc file */
+  home = getenv ("HOME");
+  if (home)
+    {
+      strcpy (fname, home);
+      if (fname[strlen(fname)-1]!='/')
+	strcat (fname, "/");
+      strcat (fname, ".XWinrc");
+      
+      prefFile = fopen (fname, "r");
+    }
+
+  /* No home file found, check system default */
+  if (!prefFile)
+    prefFile = fopen (PROJECTROOT"/lib/X11/system.XWinrc", "r");
+
+  /* If we could open it, then read the settings and close it */
+  if (prefFile)
+    {
+      parse_file (prefFile);
+      fclose (prefFile);
+    }
+
+  /* Setup a DISPLAY environment variable, need to allocate on heap */
+  /* because putenv doesn't copy the argument... */
+  snprintf (szDisplay, 512, "DISPLAY=127.0.0.1:%s.0", display);
+  szEnvDisplay = (char *)(malloc (strlen(szDisplay)+1));
+  if (szEnvDisplay)
+    {
+      strcpy (szEnvDisplay, szDisplay);
+      putenv (szEnvDisplay);
+    }
+
+  /* Replace any "%display%" in menu commands with display string */
+  snprintf (szDisplay, 512, "127.0.0.1:%s.0", display);
+  for (i=0; i<pref.menuItems; i++)
+    {
+      for (j=0; j<pref.menu[i].menuItems; j++)
+	{
+	  if (pref.menu[i].menuItem[j].cmd==CMD_EXEC)
+	    {
+	      srcParam = pref.menu[i].menuItem[j].param;
+	      dstParam = param;
+	      while (*srcParam) {
+		if (!strncmp(srcParam, "%display%", 9))
+		  {
+		    memcpy (dstParam, szDisplay, strlen(szDisplay));
+		    dstParam += strlen(szDisplay);
+		    srcParam += 9;
+		  }
+		else
+		  {
+		    *dstParam = *srcParam;
+		    dstParam++;
+		    srcParam++;
+		  }
+	      }
+	      *dstParam = 0;
+	      strcpy (pref.menu[i].menuItem[j].param, param);
+	    } /* cmd==cmd_exec */
+	} /* for all menuitems */
+    } /* for all menus */
+
+}
+
diff --git a/hw/xwin/winprefs.h b/hw/xwin/winprefs.h
new file mode 100644
index 000000000..ae1cb07d8
--- /dev/null
+++ b/hw/xwin/winprefs.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ * 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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winprefs.h,v 1.1 2003/10/02 13:30:11 eich Exp $ */
+
+/* Need to know how long paths can be... */
+#include <limits.h>
+
+#ifndef NAME_MAX
+#define NAME_MAX PATH_MAX
+#endif
+#define MENU_MAX 128   /* Maximum string length of a menu name or item */
+#define PARAM_MAX (4*PATH_MAX)  /* Maximim length of a parameter to a MENU */
+
+
+/* Supported commands in a MENU {} statement */
+typedef enum MENUCOMMANDTYPE
+{
+  CMD_EXEC,         /* /bin/sh -c the parameter            */
+  CMD_MENU,         /* Display a popup menu named param    */
+  CMD_SEPARATOR,    /* Menu separator                      */
+  CMD_ALWAYSONTOP,  /* Toggle always-on-top mode           */
+  CMD_RELOAD        /* Reparse the .XWINRC file            */
+} MENUCOMMANDTYPE;
+
+/* Where to place a system menu */
+typedef enum MENUPOSITION
+{
+  AT_START,   /* Place menu at the top of the system menu   */
+  AT_END      /* Put it at the bottom of the menu (default) */
+} MENUPOSITION;
+
+/* Menu item definitions */
+typedef struct MENUITEM
+{
+  char text[MENU_MAX+1];   /* To be displayed in menu */
+  MENUCOMMANDTYPE cmd;     /* What should it do? */
+  char param[PARAM_MAX+1]; /* Any parameters? */
+  unsigned long commandID; /* Windows WM_COMMAND ID assigned at runtime */
+} MENUITEM;
+
+/* A completely read in menu... */
+typedef struct MENUPARSED
+{
+  char menuName[MENU_MAX+1]; /* What's it called in the text? */
+  MENUITEM *menuItem;        /* Array of items */
+  int menuItems;             /* How big's the array? */
+} MENUPARSED;
+
+/* To map between a window and a system menu to add for it */
+typedef struct SYSMENUITEM
+{
+  char match[MENU_MAX+1];    /* String to look for to apply this sysmenu */
+  char menuName[MENU_MAX+1]; /* Which menu to show? Used to set *menu */
+  MENUPOSITION menuPos;      /* Where to place it (ignored in root) */
+} SYSMENUITEM;
+
+/* To redefine icons for certain window types */
+typedef struct ICONITEM
+{
+  char match[MENU_MAX+1];             /* What string to search for? */
+  char iconFile[PATH_MAX+NAME_MAX+2]; /* Icon location, WIN32 path */
+  unsigned long hicon;                /* LoadImage() result */
+} ICONITEM;
+
+typedef struct WINMULTIWINDOWPREFS
+{
+  /* Menu information */
+  MENUPARSED *menu; /* Array of created menus */
+  int menuItems;      /* How big? */
+
+  /* Taskbar menu settings */
+  char rootMenuName[MENU_MAX+1];  /* Menu for taskbar icon */
+
+  /* System menu addition menus */
+  SYSMENUITEM *sysMenu;
+  int sysMenuItems;
+
+  /* Which menu to add to unmatched windows? */
+  char defaultSysMenuName[MENU_MAX+1];
+  MENUPOSITION defaultSysMenuPos;   /* Where to place it */
+
+  /* Icon information */
+  char iconDirectory[PATH_MAX+1]; /* Where do the .icos lie? (Win32 path) */
+  char defaultIconName[NAME_MAX+1];   /* Replacement for x.ico */
+
+  ICONITEM *icon;
+  int iconItems;
+
+} WINMULTIWINDOWPREFS;
+
+
+
+
+/* Functions */
+void
+LoadPreferences();
+
+void
+SetupRootMenu (unsigned long hmenuRoot);
+
+void
+SetupSysMenu (unsigned long hwndIn);
+
+void
+HandleCustomWM_INITMENU(unsigned long hwndIn,
+			unsigned long hmenuIn);
+
+int
+HandleCustomWM_COMMAND (unsigned long hwndIn,
+			int           command);
+
+int
+winIconIsOverride (unsigned hiconIn);
+
+unsigned long
+winOverrideIcon (unsigned long longpWin);
+
+unsigned long
+winOverrideDefaultIcon();
+
diff --git a/hw/xwin/winprefslex.l b/hw/xwin/winprefslex.l
new file mode 100644
index 000000000..8eda8e6c2
--- /dev/null
+++ b/hw/xwin/winprefslex.l
@@ -0,0 +1,113 @@
+%{ # -*- C -*-
+/*
+ * Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ * 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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winprefslex.l,v 1.1 2003/10/02 13:30:11 eich Exp $ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "winprefsyacc.h"
+
+extern YYSTYPE yylval;
+extern char *yytext;
+extern int yyparse();
+
+extern void ErrorF (const char* /*f*/, ...);
+
+int yylineno;
+
+/* Copy the parsed string, must be free()d in yacc parser */
+static char *makestr(char *str)
+{
+  char *ptr;
+  ptr = (char*)malloc (strlen(str)+1);
+  if (!ptr)
+    {
+      ErrorF ("winMultiWindowLex:makestr() out of memory\n");
+      exit (-1);
+    }
+  strcpy(ptr, str);
+  return ptr;
+}
+
+%}
+
+%option yylineno
+
+%%
+\#.*[\r\n]                                               { /* comment */ return NEWLINE; }
+\/\/.*[\r\n]                                             { /* comment */ return NEWLINE; }
+[\r\n]	                                             	 { return NEWLINE; }
+[ \t]+	                                             	 { /* ignore whitespace */ }
+[mM][eE][nN][uU]                                         { return MENU; }
+[iI][cC][oO][nN][dD][iI][rR][eE][cC][tT][oO][rR][yY]	 { return ICONDIRECTORY; }
+[dD][eE][fF][aA][uU][lL][tT][iI][cC][oO][nN]             { return DEFAULTICON; }
+[iI][cC][oO][nN][sS]                              	 { return ICONS; }
+[rR][oO][oO][tT][mM][eE][nN][uU]                         { return ROOTMENU; }
+[dD][eE][fF][aA][uU][lL][tT][sS][yY][sS][mM][eE][nN][uU] { return DEFAULTSYSMENU; }
+[sS][yY][sS][mM][eE][nN][uU]                             { return SYSMENU; }
+[sS][eE][pP][aA][rR][aA][tT][oO][rR]                     { return SEPARATOR; }
+[aA][tT][sS][tT][aA][rR][tT]                             { return ATSTART; }
+[aA][tT][eE][nN][dD]                                     { return ATEND; }
+[eE][xX][eE][cC]                                         { return EXEC; }
+[aA][lL][wW][aA][yY][sS][oO][nN][tT][oO][pP]             { return ALWAYSONTOP; }
+[dD][eE][bB][uU][gG]                                     { return DEBUG; }
+[rR][eE][lL][oO][aA][dD]                                 { return RELOAD; }
+"{"		                                         { return LB; }
+"}"		                                         { return RB; }
+"\""[^\"\r\n]+"\""                                       { yylval.sVal = makestr(yytext+1); \
+                                                           yylval.sVal[strlen(yylval.sVal)-1] = 0; \
+                                                           return STRING; }
+[^ \t\r\n]+                                              { yylval.sVal = makestr(yytext); \
+                                                           return STRING; }
+%%
+
+/*
+ * Run-of-the mill requirement for yacc
+ */
+int
+yywrap ()
+{
+  return 1;
+}
+
+/*
+ * Run a file through the yacc parser
+ */
+void
+parse_file (FILE *file)
+{
+  if (!file)
+    return; 
+  
+  yylineno = 1;
+  yyin = file;
+  yyparse ();
+}
diff --git a/hw/xwin/winprefsyacc.y b/hw/xwin/winprefsyacc.y
new file mode 100644
index 000000000..a6ffc7207
--- /dev/null
+++ b/hw/xwin/winprefsyacc.y
@@ -0,0 +1,334 @@
+%{
+/*
+ * Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ * 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 XFree86 Project.
+ *
+ * Authors:     Earle F. Philhower, III
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winprefsyacc.y,v 1.1 2003/10/02 13:30:11 eich Exp $ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "winprefs.h"
+
+/* The following give better error messages in bison at the cost of a few KB */
+#define YYERROR_VERBOSE 1
+
+/* The global pref settings */
+WINMULTIWINDOWPREFS pref;
+
+/* The working menu */  
+static MENUPARSED menu;
+
+/* Functions for parsing the tokens into out structure */
+/* Defined at the end section of this file */
+
+static void SetIconDirectory (char *path);
+static void SetDefaultIcon (char *fname);
+static void SetRootMenu (char *menu);
+static void SetDefaultSysMenu (char *menu, int pos);
+
+static void OpenMenu(char *menuname);
+static void AddMenuLine(char *name, MENUCOMMANDTYPE cmd, char *param);
+static void CloseMenu();
+
+static void OpenIcons();
+static void AddIconLine(char *matchstr, char *iconfile);
+static void CloseIcons();
+
+static void OpenSysMenu();
+static void AddSysMenuLine(char *matchstr, char *menuname, int pos);
+static void CloseSysMenu();
+
+static int yyerror (char *s);
+
+extern void ErrorF (const char* /*f*/, ...);
+extern char *yytext;
+extern int yylex();
+
+%}
+
+%union {
+  char *sVal;
+  int iVal;
+}
+
+%token NEWLINE MENU LB RB ICONDIRECTORY DEFAULTICON ICONS DEFAULTSYSMENU
+%token SYSMENU ROOTMENU SEPARATOR ATSTART ATEND EXEC ALWAYSONTOP DEBUG
+%token RELOAD
+
+%token <sVal> STRING
+%type <iVal>  atspot
+
+%%
+
+input:	/* empty */
+	| input line
+	;
+
+line:	NEWLINE
+	| command
+	;
+
+
+newline_or_nada:	
+	| NEWLINE newline_or_nada
+	;
+
+command:	defaulticon
+	| icondirectory
+	| menu
+	| icons
+	| sysmenu
+	| rootmenu
+	| defaultsysmenu
+	| debug
+	;
+
+rootmenu:	ROOTMENU STRING NEWLINE { SetRootMenu($2); free($2); }
+	;
+
+defaultsysmenu:	DEFAULTSYSMENU STRING atspot NEWLINE { SetDefaultSysMenu($2, $3); free($2); }
+	;
+
+defaulticon:	DEFAULTICON STRING NEWLINE { SetDefaultIcon($2); free($2); }
+	;
+
+icondirectory:	ICONDIRECTORY STRING NEWLINE { SetIconDirectory($2); free($2); }
+	;
+
+menuline:	SEPARATOR NEWLINE newline_or_nada  { AddMenuLine("-", CMD_SEPARATOR, ""); }
+	| STRING ALWAYSONTOP NEWLINE newline_or_nada  { AddMenuLine($1, CMD_ALWAYSONTOP, ""); free($1); }
+	| STRING EXEC STRING NEWLINE newline_or_nada  { AddMenuLine($1, CMD_EXEC, $3); free($1); free($3); }
+	| STRING MENU STRING NEWLINE newline_or_nada  { AddMenuLine($1, CMD_MENU, $3); free($1); free($3); }
+	| STRING RELOAD NEWLINE newline_or_nada  { AddMenuLine($1, CMD_RELOAD, ""); free($1); }
+	;
+
+menulist:	menuline
+	| menuline menulist
+	;
+
+menu:	MENU STRING LB { OpenMenu($2); free($2); } newline_or_nada menulist RB {CloseMenu();}
+	;
+
+iconline:	STRING STRING NEWLINE newline_or_nada { AddIconLine($1, $2); free($1); free($2); }
+	;
+
+iconlist:	iconline
+	| iconline iconlist
+	;
+
+icons:	ICONS LB {OpenIcons();} newline_or_nada iconlist RB {CloseIcons();}
+	;
+
+atspot:	{ $$=AT_END; }
+	| ATSTART { $$=AT_START; }
+	| ATEND { $$=AT_END; }
+	;
+
+sysmenuline:	STRING STRING atspot NEWLINE newline_or_nada { AddSysMenuLine($1, $2, $3); free($1); free($2); }
+	;
+
+sysmenulist:	sysmenuline
+	| sysmenuline sysmenulist
+	;
+
+sysmenu:	SYSMENU LB NEWLINE {OpenSysMenu();} newline_or_nada sysmenulist RB {CloseSysMenu();}
+	;
+
+debug: 	DEBUG STRING NEWLINE { ErrorF("LoadPreferences: %s\n", $2); free($2); }
+	;
+
+
+%%
+/*
+ * Errors in parsing abort and print log messages
+ */
+static int
+yyerror (char *s) 
+{
+  extern int yylineno; /* Handled by flex internally */
+
+  ErrorF("LoadPreferences: %s line %d\n", s, yylineno);
+  return 1;
+}
+
+/* Miscellaneous functions to store TOKENs into the structure */
+static void
+SetIconDirectory (char *path)
+{
+  strncpy (pref.iconDirectory, path, PATH_MAX);
+  pref.iconDirectory[PATH_MAX] = 0;
+}
+
+static void
+SetDefaultIcon (char *fname)
+{
+  strncpy (pref.defaultIconName, fname, NAME_MAX);
+  pref.defaultIconName[NAME_MAX] = 0;
+}
+
+static void
+SetRootMenu (char *menu)
+{
+  strncpy (pref.rootMenuName, menu, MENU_MAX);
+  pref.rootMenuName[MENU_MAX] = 0;
+}
+
+static void
+SetDefaultSysMenu (char *menu, int pos)
+{
+  strncpy (pref.defaultSysMenuName, menu, MENU_MAX);
+  pref.defaultSysMenuName[MENU_MAX] = 0;
+  pref.defaultSysMenuPos = pos;
+}
+
+static void
+OpenMenu (char *menuname)
+{
+  if (menu.menuItem) free(menu.menuItem);
+  menu.menuItem = NULL;
+  strncpy(menu.menuName, menuname, MENU_MAX);
+  menu.menuName[MENU_MAX] = 0;
+  menu.menuItems = 0;
+}
+
+static void
+AddMenuLine (char *text, MENUCOMMANDTYPE cmd, char *param)
+{
+  if (menu.menuItem==NULL)
+    menu.menuItem = (MENUITEM*)malloc(sizeof(MENUITEM));
+  else
+    menu.menuItem = (MENUITEM*)
+      realloc(menu.menuItem, sizeof(MENUITEM)*(menu.menuItems+1));
+
+  strncpy (menu.menuItem[menu.menuItems].text, text, MENU_MAX);
+  menu.menuItem[menu.menuItems].text[MENU_MAX] = 0;
+
+  menu.menuItem[menu.menuItems].cmd = cmd;
+
+  strncpy(menu.menuItem[menu.menuItems].param, param, PARAM_MAX);
+  menu.menuItem[menu.menuItems].param[PARAM_MAX] = 0;
+
+  menu.menuItem[menu.menuItems].commandID = 0;
+
+  menu.menuItems++;
+}
+
+static void
+CloseMenu ()
+{
+  if (menu.menuItem==NULL || menu.menuItems==0)
+    {
+      ErrorF("LoadPreferences: Empty menu detected\n");
+      return;
+    }
+  
+  if (pref.menuItems)
+    pref.menu = (MENUPARSED*)
+      realloc (pref.menu, (pref.menuItems+1)*sizeof(MENUPARSED));
+  else
+    pref.menu = (MENUPARSED*)malloc (sizeof(MENUPARSED));
+  
+  memcpy (pref.menu+pref.menuItems, &menu, sizeof(MENUPARSED));
+  pref.menuItems++;
+
+  memset (&menu, 0, sizeof(MENUPARSED));
+}
+
+static void 
+OpenIcons ()
+{
+  if (pref.icon != NULL) {
+    ErrorF("LoadPreferences: Redefining icon mappings\n");
+    free(pref.icon);
+    pref.icon = NULL;
+  }
+  pref.iconItems = 0;
+}
+
+static void
+AddIconLine (char *matchstr, char *iconfile)
+{
+  if (pref.icon==NULL)
+    pref.icon = (ICONITEM*)malloc(sizeof(ICONITEM));
+  else
+    pref.icon = (ICONITEM*)
+      realloc(pref.icon, sizeof(ICONITEM)*(pref.iconItems+1));
+
+  strncpy(pref.icon[pref.iconItems].match, matchstr, MENU_MAX);
+  pref.icon[pref.iconItems].match[MENU_MAX] = 0;
+
+  strncpy(pref.icon[pref.iconItems].iconFile, iconfile, PATH_MAX+NAME_MAX+1);
+  pref.icon[pref.iconItems].iconFile[PATH_MAX+NAME_MAX+1] = 0;
+
+  pref.icon[pref.iconItems].hicon = 0;
+
+  pref.iconItems++;
+}
+
+static void 
+CloseIcons ()
+{
+}
+
+static void
+OpenSysMenu ()
+{
+  if (pref.sysMenu != NULL) {
+    ErrorF("LoadPreferences: Redefining system menu\n");
+    free(pref.sysMenu);
+    pref.sysMenu = NULL;
+  }
+  pref.sysMenuItems = 0;
+}
+
+static void
+AddSysMenuLine (char *matchstr, char *menuname, int pos)
+{
+  if (pref.sysMenu==NULL)
+    pref.sysMenu = (SYSMENUITEM*)malloc(sizeof(SYSMENUITEM));
+  else
+    pref.sysMenu = (SYSMENUITEM*)
+      realloc(pref.sysMenu, sizeof(SYSMENUITEM)*(pref.sysMenuItems+1));
+
+  strncpy (pref.sysMenu[pref.sysMenuItems].match, matchstr, MENU_MAX);
+  pref.sysMenu[pref.sysMenuItems].match[MENU_MAX] = 0;
+
+  strncpy (pref.sysMenu[pref.sysMenuItems].menuName, menuname, MENU_MAX);
+  pref.sysMenu[pref.sysMenuItems].menuName[MENU_MAX] = 0;
+
+  pref.sysMenu[pref.sysMenuItems].menuPos = pos;
+
+  pref.sysMenuItems++;
+}
+
+static void
+CloseSysMenu ()
+{
+}
+
diff --git a/hw/xwin/winpushpxl.c b/hw/xwin/winpushpxl.c
new file mode 100644
index 000000000..deb9629d7
--- /dev/null
+++ b/hw/xwin/winpushpxl.c
@@ -0,0 +1,226 @@
+/* $XFree86: xc/programs/Xserver/hw/xwin/winpushpxl.c,v 1.1 2003/08/07 23:47:58 alanh Exp $ */
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 Open Group 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 Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+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 "X.h"
+#include "gcstruct.h"
+#include "scrnintstr.h"
+#include "pixmapstr.h"
+#include "miscstruct.h"
+#include "../mfb/maskbits.h"
+#include "mi.h"
+
+#define NPT 128
+
+/* winPushPixels -- squeegees the fill style of pGC through pBitMap
+ * into pDrawable.  pBitMap is a stencil (dx by dy of it is used, it may
+ * be bigger) which is placed on the drawable at xOrg, yOrg.  Where a 1 bit
+ * is set in the bitmap, the fill style is put onto the drawable using
+ * the GC's logical function. The drawable is not changed where the bitmap
+ * has a zero bit or outside the area covered by the stencil.
+
+WARNING:
+    this code works if the 1-bit deep pixmap format returned by GetSpans
+is the same as the format defined by the mfb code (i.e. 32-bit padding
+per scanline, scanline unit = 32 bits; later, this might mean
+bitsizeof(int) padding and sacnline unit == bitsizeof(int).)
+
+ */
+
+/*
+ * in order to have both (MSB_FIRST and LSB_FIRST) versions of this
+ * in the server, we need to rename one of them
+ */
+void
+winPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
+    GCPtr	pGC;
+    PixmapPtr	pBitMap;
+    DrawablePtr pDrawable;
+    int		dx, dy, xOrg, yOrg;
+{
+    int		h, dxDivPPW, ibEnd;
+    MiBits *pwLineStart;
+    register MiBits	*pw, *pwEnd;
+    register MiBits msk;
+    register int ib, w;
+    register int ipt;		/* index into above arrays */
+    Bool 	fInBox;
+    DDXPointRec	pt[NPT], ptThisLine;
+    int		width[NPT];
+    PixelType	startmask;
+
+
+    startmask = (MiBits)(-1) ^
+            LONG2CHARSDIFFORDER((MiBits)(-1) >> 1);
+
+    pwLineStart = (MiBits *)xalloc(BitmapBytePad(dx));
+    if (!pwLineStart)
+	return;
+    ipt = 0;
+    dxDivPPW = dx/PPW;
+
+    for(h = 0, ptThisLine.x = 0, ptThisLine.y = 0; 
+	h < dy; 
+	h++, ptThisLine.y++)
+    {
+
+	(*pBitMap->drawable.pScreen->GetSpans)((DrawablePtr)pBitMap, dx,
+			&ptThisLine, &dx, 1, (char *)pwLineStart);
+
+	pw = pwLineStart;
+	/* Process all words which are fully in the pixmap */
+	
+	fInBox = FALSE;
+	pwEnd = pwLineStart + dxDivPPW;
+	while(pw  < pwEnd)
+	{
+	    w = *pw;
+#ifdef XFree86Server
+	    msk = startmask;
+#else
+	    msk = (MiBits)(-1) ^ SCRRIGHT((MiBits)(-1), 1);
+#endif
+	    for(ib = 0; ib < PPW; ib++)
+	    {
+		if(w & msk)
+		{
+		    if(!fInBox)
+		    {
+			pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
+			pt[ipt].y = h + yOrg;
+			/* start new box */
+			fInBox = TRUE;
+		    }
+		}
+		else
+		{
+		    if(fInBox)
+		    {
+			width[ipt] = ((pw - pwLineStart) << PWSH) + 
+				     ib + xOrg - pt[ipt].x;
+			if (++ipt >= NPT)
+			{
+			    (*pGC->ops->FillSpans)(pDrawable, pGC, 
+					      NPT, pt, width, TRUE);
+			    ipt = 0;
+			}
+			/* end box */
+			fInBox = FALSE;
+		    }
+		}
+#ifdef XFree86Server
+    		/* This is not quite right, but it'll do for now */
+		msk = LONG2CHARSDIFFORDER(LONG2CHARSDIFFORDER(msk) >> 1);
+#else
+		msk = SCRRIGHT(msk, 1);
+#endif
+	    }
+	    pw++;
+	}
+	ibEnd = dx & PIM;
+	if(ibEnd)
+	{
+	    /* Process final partial word on line */
+	    w = *pw;
+#ifdef XFree86Server
+	    msk = startmask;
+#else
+	    msk = (MiBits)(-1) ^ SCRRIGHT((MiBits)(-1), 1);
+#endif
+	    for(ib = 0; ib < ibEnd; ib++)
+	    {
+		if(w & msk)
+		{
+		    if(!fInBox)
+		    {
+			/* start new box */
+			pt[ipt].x = ((pw - pwLineStart) << PWSH) + ib + xOrg;
+			pt[ipt].y = h + yOrg;
+			fInBox = TRUE;
+		    }
+		}
+		else
+		{
+		    if(fInBox)
+		    {
+			/* end box */
+			width[ipt] = ((pw - pwLineStart) << PWSH) + 
+				     ib + xOrg - pt[ipt].x;
+			if (++ipt >= NPT)
+			{
+			    (*pGC->ops->FillSpans)(pDrawable, 
+					      pGC, NPT, pt, width, TRUE);
+			    ipt = 0;
+			}
+			fInBox = FALSE;
+		    }
+		}
+#ifdef XFree86Server
+    		/* This is not quite right, but it'll do for now */
+		msk = LONG2CHARSDIFFORDER(LONG2CHARSDIFFORDER(msk) >> 1);
+#else
+		msk = SCRRIGHT(msk, 1);
+#endif
+	    }
+	}
+	/* If scanline ended with last bit set, end the box */
+	if(fInBox)
+	{
+	    width[ipt] = dx + xOrg - pt[ipt].x;
+	    if (++ipt >= NPT)
+	    {
+		(*pGC->ops->FillSpans)(pDrawable, pGC, NPT, pt, width, TRUE);
+		ipt = 0;
+	    }
+	}
+    }
+    xfree(pwLineStart);
+    /* Flush any remaining spans */
+    if (ipt)
+    {
+	(*pGC->ops->FillSpans)(pDrawable, pGC, ipt, pt, width, TRUE);
+    }
+}
diff --git a/hw/xwin/winrop.c b/hw/xwin/winrop.c
new file mode 100644
index 000000000..c5ec45de5
--- /dev/null
+++ b/hw/xwin/winrop.c
@@ -0,0 +1,139 @@
+/*
+ *Copyright (C) 1994-2002 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * 	Authors:	Alan Hourihane <alanh@fairlite.demon.co.uk>
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winrop.c,v 1.1 2003/08/07 23:47:58 alanh Exp $ */
+
+/*
+ * Raster operations used by Windows translated to X's 16 rop codes...
+ */
+#include "win.h"
+
+int g_copyROP[16] = { 	0xFF0062, /* GXclear 		- 0 */
+		 	0x8800C6, /* GXand 		- S & D */
+		 	0x440328, /* GXandReverse  	- S & !D */
+		 	0xCC0020, /* GXcopy 		- S */
+		 	0x220326, /* GXandInverted 	- !S & D */
+		 	0xAA0029, /* GXnoop		- D */
+		 	0x660046, /* GXxor 		- S ^ D */
+		 	0xEE0086, /* GXor		- S | D */
+		 	0x1100A6, /* GXnor 		- !S & !D */
+		 	0x990126, /* GXequiv		- !S ^ D */
+		 	0x550009, /* GXinvert		- !D */
+		 	0xDD0228, /* GXorReverse	- S | !D */
+		 	0x330008, /* GXcopyInverted	- !S */
+		 	0xBB0226, /* GXorInverted	- !S | D */
+		 	0x7700C6, /* GXnand		- !S | !D */
+		 	0x000042  /* GXset		- 1 */
+};
+
+int g_patternROP[16] = {0xFF0062, /* GXclear		- 0 */
+		 	0xA000C9, /* GXand 		- P & D */
+		 	0xF50225, /* GXandReverse	- P & !D */
+		 	0xF00021, /* GXcopy 		- P */
+		 	0x5F00E9, /* GXandInverted 	- !P & D */
+		 	0xAA0029, /* GXnoop		- D */
+		 	0xA50065, /* GXxor		- P ^ D */
+		 	0xA000C9, /* GXor		- P | D */
+		 	0x5F00E9, /* GXnor		- !P & !D */
+		 	0x5A0049, /* GXequiv		- !P ^ D */
+		 	0x550009, /* GXinvert		- !D */
+		 	0x500325, /* GXorReverse	- P | !D */
+		 	0x0F0001, /* GXcopyInverted	- !P */
+		 	0x0A0329, /* GXorInverted	- !P | D */
+		 	0x0500A9, /* GXnand		- !P | !D */
+		 	0x000042  /* GXset		- 1 */
+};
+
+
+void
+ROP16 (HDC hdc, int rop)
+{
+  switch (rop)
+    {
+    case GXclear:
+      SetROP2 (hdc, R2_BLACK);
+      break;
+
+    case GXand:
+      SetROP2 (hdc, R2_MASKPEN);
+      break;
+
+    case GXandReverse:
+      SetROP2 (hdc, R2_MASKPENNOT);
+      break;
+
+    case GXcopy:
+      SetROP2 (hdc, R2_COPYPEN);
+      break;
+
+    case GXnoop:
+      SetROP2 (hdc, R2_NOP);
+      break;
+
+    case GXxor:
+      SetROP2 (hdc, R2_XORPEN);
+      break;
+
+    case GXor:
+      SetROP2 (hdc, R2_MERGEPEN);
+      break;
+
+    case GXnor:
+      SetROP2 (hdc, R2_NOTMERGEPEN);
+      break;
+
+    case GXequiv:
+      SetROP2 (hdc, R2_NOTXORPEN);
+      break;
+
+    case GXinvert:
+      SetROP2 (hdc, R2_NOT);
+      break;
+
+    case GXorReverse:
+      SetROP2 (hdc, R2_MERGEPENNOT);
+      break;
+
+    case GXcopyInverted:
+      SetROP2 (hdc, R2_NOTCOPYPEN);
+      break;
+
+    case GXorInverted:
+      SetROP2 (hdc, R2_MERGENOTPEN);
+      break;
+
+    case GXnand:
+      SetROP2 (hdc, R2_NOTMASKPEN);
+      break;
+
+    case GXset:
+      SetROP2 (hdc, R2_WHITE);
+      break;
+    }
+}
diff --git a/hw/xwin/wintrayicon.c b/hw/xwin/wintrayicon.c
new file mode 100755
index 000000000..90c77b1c8
--- /dev/null
+++ b/hw/xwin/wintrayicon.c
@@ -0,0 +1,209 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Early Ehlinger
+ *		Harold L Hunt II
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/wintrayicon.c,v 1.2 2003/10/02 13:30:11 eich Exp $ */
+
+#include "win.h"
+#include <shellapi.h>
+#include "winprefs.h"
+
+/*
+ * Initialize the tray icon
+ */
+
+void
+winInitNotifyIcon (winPrivScreenPtr pScreenPriv)
+{
+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
+  NOTIFYICONDATA	nid = {0};
+  
+  nid.cbSize = sizeof (NOTIFYICONDATA);
+  nid.hWnd = pScreenPriv->hwndScreen;
+  nid.uID = pScreenInfo->dwScreen;
+  nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+  nid.uCallbackMessage = WM_TRAYICON;
+  nid.hIcon = LoadImage (g_hInstance,
+			 MAKEINTRESOURCE(IDI_XWIN),
+			 IMAGE_ICON,
+			 GetSystemMetrics (SM_CXSMICON),
+			 GetSystemMetrics (SM_CYSMICON),
+			 0);
+
+  /* Save handle to the icon so it can be freed later */
+  pScreenPriv->hiconNotifyIcon = nid.hIcon;
+
+  /* Set display and screen-specific tooltip text */
+  snprintf (nid.szTip,
+	    sizeof (nid.szTip),
+	    "Cygwin/XFree86 Server - %s:%d",
+	    display, 
+	    (int) pScreenInfo->dwScreen);
+
+  /* Add the tray icon */
+  if (!Shell_NotifyIcon (NIM_ADD, &nid))
+    ErrorF ("winInitNotifyIcon - Shell_NotifyIcon Failed\n");
+}
+
+
+/*
+ * Delete the tray icon
+ */
+
+void
+winDeleteNotifyIcon (winPrivScreenPtr pScreenPriv)
+{
+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
+  NOTIFYICONDATA	nid = {0};
+  
+#if 0
+  ErrorF ("winDeleteNotifyIcon\n");
+#endif
+
+  nid.cbSize = sizeof (NOTIFYICONDATA);
+  nid.hWnd = pScreenPriv->hwndScreen;
+  nid.uID = pScreenInfo->dwScreen;
+  
+  /* Delete the tray icon */
+  if (!Shell_NotifyIcon (NIM_DELETE, &nid))
+    {
+      ErrorF ("winDeleteNotifyIcon - Shell_NotifyIcon failed\n");
+      return;
+    }
+
+  /* Free the icon that was loaded */
+  if (pScreenPriv->hiconNotifyIcon != NULL
+      && DestroyIcon (pScreenPriv->hiconNotifyIcon) == 0)
+    {
+      ErrorF ("winDeleteNotifyIcon - DestroyIcon failed\n");
+    }
+  pScreenPriv->hiconNotifyIcon = NULL;
+}
+
+
+/*
+ * Process messages intended for the tray icon
+ */
+
+LRESULT
+winHandleIconMessage (HWND hwnd, UINT message,
+		      WPARAM wParam, LPARAM lParam,
+		      winPrivScreenPtr pScreenPriv)
+{
+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo;
+
+  switch (lParam)
+    {
+    case WM_LBUTTONDBLCLK:
+      /* Display Exit dialog box */
+      winDisplayExitDialog (pScreenPriv);
+      break;
+
+    case WM_RBUTTONUP:
+      {
+	POINT		ptCursor;
+	HMENU		hmenuPopup;
+	HMENU		hmenuTray;
+
+	/* Get cursor position */
+	GetCursorPos (&ptCursor);
+
+	/* Load tray icon menu resource */
+	hmenuPopup = LoadMenu (g_hInstance,
+			       MAKEINTRESOURCE(IDM_TRAYICON_MENU));
+	if (!hmenuPopup)
+	  ErrorF ("winHandleIconMessage - LoadMenu failed\n");
+
+	/* Get actual tray icon menu */
+	hmenuTray = GetSubMenu (hmenuPopup, 0);
+
+	/* Check for MultiWindow mode */
+	if (pScreenInfo->fMultiWindow)
+	  {
+	    /* Check if root window is shown or hidden */
+	    if (pScreenPriv->fRootWindowShown)
+	      {
+		/* Remove Show Root Window button */
+		RemoveMenu (hmenuTray,
+			    ID_APP_SHOW_ROOT,
+			    MF_BYCOMMAND);
+	      }
+	    else
+	      {
+		/* Remove Hide Root Window button */
+		RemoveMenu (hmenuTray,
+			    ID_APP_HIDE_ROOT,
+			    MF_BYCOMMAND);
+	      }
+	  }
+	else
+	  {
+	    /* Remove Show Root Window button */
+	    RemoveMenu (hmenuTray,
+			ID_APP_SHOW_ROOT,
+			MF_BYCOMMAND);
+	    
+	    /* Remove Hide Root Window button */
+	    RemoveMenu (hmenuTray,
+			ID_APP_HIDE_ROOT,
+			MF_BYCOMMAND);
+
+	    /* Remove separator */
+	    RemoveMenu (hmenuTray,
+			0,
+			MF_BYPOSITION);
+	  }
+
+	SetupRootMenu ((unsigned long)hmenuTray);
+
+	/*
+	 * NOTE: This three-step procedure is required for
+	 * proper popup menu operation.  Without the
+	 * call to SetForegroundWindow the
+	 * popup menu will often not disappear when you click
+	 * outside of it.  Without the PostMessage the second
+	 * time you display the popup menu it might immediately
+	 * disappear.
+	 */
+	SetForegroundWindow (hwnd);
+	TrackPopupMenuEx (hmenuTray,
+			  TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON,
+			  ptCursor.x, ptCursor.y,
+			  hwnd,
+			  NULL);
+	PostMessage (hwnd, WM_NULL, 0, 0);
+
+	/* Free menu */
+	DestroyMenu (hmenuPopup);
+      }
+      break;
+    }
+
+  return 0;
+}
diff --git a/hw/xwin/winvideo.c b/hw/xwin/winvideo.c
new file mode 100755
index 000000000..8bf12cd66
--- /dev/null
+++ b/hw/xwin/winvideo.c
@@ -0,0 +1,206 @@
+/*
+ *Copyright (C) 1994-2000 The XFree86 Project, 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 XFREE86 PROJECT 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 XFree86 Project
+ *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 XFree86 Project.
+ *
+ * Authors:	Harold L Hunt II
+ */
+/* $XFree86: xc/programs/Xserver/hw/xwin/winvideo.c,v 1.2 2003/11/10 18:22:44 tsi Exp $ */
+
+#include "win.h"
+#include "Xv.h"
+#include "Xvproto.h"
+
+
+/*
+ * winInitVideo - Initialize support for the X Video (Xv) Extension.
+ */
+
+void
+winInitVideo (ScreenPtr pScreen)
+{
+  winScreenPriv(pScreen);
+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo; 
+
+  if (pScreenInfo->dwBPP > 8) 
+    {
+      
+    }
+  
+
+}
+
+
+
+
+
+
+
+#if 0
+#include "../xfree86/common/xf86.h"
+#include "../Xext/xvdix.h"
+#include "../xfree86/common/xf86xv.h"
+#include "Xv.h"
+#endif
+
+#include "win.h"
+
+
+
+#if 0
+/* client libraries expect an encoding */
+static XF86VideoEncodingRec DummyEncoding[1] =
+{
+ {
+   0,
+   "XV_IMAGE",
+   IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,
+   {1, 1}
+ }
+};
+
+#define NUM_FORMATS 3
+
+static XF86VideoFormatRec Formats[NUM_FORMATS] = 
+{
+  {15, TrueColor}, {16, TrueColor}, {24, TrueColor}
+};
+
+#define NUM_ATTRIBUTES 3
+
+static XF86AttributeRec Attributes[NUM_ATTRIBUTES] =
+{
+   {XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
+   {XvSettable | XvGettable, -128, 127, "XV_BRIGHTNESS"},
+   {XvSettable | XvGettable, 0, 255, "XV_CONTRAST"}
+};
+
+#define NUM_IMAGES 4
+
+static XF86ImageRec Images[NUM_IMAGES] =
+{
+	XVIMAGE_YUY2,
+	XVIMAGE_YV12,
+	XVIMAGE_I420,
+	XVIMAGE_UYVY
+};
+
+
+
+/*
+ * winInitVideo - Initialize support for the X Video (Xv) Extension.
+ */
+
+void
+winInitVideo (ScreenPtr pScreen)
+{
+  winScreenPriv(pScreen);
+  winScreenInfo		*pScreenInfo = pScreenPriv->pScreenInfo; 
+  XF86VideoAdaptorPtr	newAdaptor = NULL;
+
+  if (pScreenInfo->dwBPP > 8) 
+    {
+      newAdaptor = I810SetupImageVideo (pScreen);
+      I810InitOffscreenImages (pScreen);
+    }
+  
+    xf86XVScreenInit (pScreen, adaptors, 1);
+}
+
+
+static XF86VideoAdaptorPtr 
+winSetupImageVideo (ScreenPtr pScreen)
+{
+    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
+#if 0
+    I810Ptr pI810 = I810PTR(pScrn);
+#endif
+    XF86VideoAdaptorPtr adapt;
+
+    if (!(adapt = xcalloc (1, sizeof(XF86VideoAdaptorRec))))
+      return NULL;
+
+    adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+    adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
+    adapt->name = "Cygwin/XFree86 Video Overlay";
+    adapt->nEncodings = 1;
+    adapt->pEncodings = DummyEncoding;
+    adapt->nFormats = NUM_FORMATS;
+    adapt->pFormats = Formats;
+    adapt->nPorts = 1;
+    adapt->pPortPrivates = NULL;
+
+    adapt->pPortPrivates[0].ptr = NULL;
+    adapt->pAttributes = Attributes;
+    adapt->nImages = NUM_IMAGES;
+    adapt->nAttributes = NUM_ATTRIBUTES;
+    adapt->pImages = Images;
+    adapt->PutVideo = NULL;
+    adapt->PutStill = NULL;
+    adapt->GetVideo = NULL;
+    adapt->GetStill = NULL;
+#if 0
+    adapt->StopVideo = I810StopVideo;
+    adapt->SetPortAttribute = I810SetPortAttribute;
+    adapt->GetPortAttribute = I810GetPortAttribute;
+    adapt->QueryBestSize = I810QueryBestSize;
+    adapt->PutImage = I810PutImage;
+    adapt->QueryImageAttributes = I810QueryImageAttributes;
+#endif
+
+#if 0
+    pPriv->colorKey = pI810->colorKey & ((1 << pScrn->depth) - 1);
+#endif
+    pPriv->videoStatus = 0;
+    pPriv->brightness = 0;
+    pPriv->contrast = 64;
+    pPriv->linear = NULL;
+    pPriv->currentBuf = 0;
+
+#if 0
+    /* gotta uninit this someplace */
+    REGION_NULL(pScreen, &pPriv->clip);
+#endif
+
+#if 0
+    pI810->adaptor = adapt;
+
+    pI810->BlockHandler = pScreen->BlockHandler;
+    pScreen->BlockHandler = I810BlockHandler;
+#endif
+
+#if 0
+    xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
+    xvContrast   = MAKE_ATOM("XV_CONTRAST");
+    xvColorKey   = MAKE_ATOM("XV_COLORKEY");
+#endif
+
+#if 0
+    I810ResetVideo(pScrn);
+#endif
+
+    return adapt;
+}
+#endif