Removed a bunch of X11 support that we no longer need.
authorSam Lantinga <slouken@libsdl.org>
Fri, 04 Feb 2011 19:18:08 -0800
changeset 5183 227d81a4b66c
parent 5182 073b86030262
child 5184 d976b67150c5
Removed a bunch of X11 support that we no longer need.
configure.in
include/SDL_config.h.in
src/video/Xext/XmuStdCmap/AllCmap.c
src/video/Xext/XmuStdCmap/CmapAlloc.c
src/video/Xext/XmuStdCmap/CrCmap.c
src/video/Xext/XmuStdCmap/DelCmap.c
src/video/Xext/XmuStdCmap/Distinct.c
src/video/Xext/XmuStdCmap/LookupCmap.c
src/video/Xext/XmuStdCmap/StdCmap.c
src/video/Xext/XmuStdCmap/VisCmap.c
src/video/Xext/extensions/StdCmap.h
src/video/x11/SDL_x11dyn.h
src/video/x11/SDL_x11sym.h
src/video/x11/SDL_x11video.h
src/video/x11/SDL_x11window.c
--- a/configure.in	Fri Feb 04 18:05:20 2011 -0800
+++ b/configure.in	Fri Feb 04 19:18:08 2011 -0800
@@ -1118,7 +1118,6 @@
 
             AC_DEFINE(SDL_VIDEO_DRIVER_X11)
             SOURCES="$SOURCES $srcdir/src/video/x11/*.c"
-            SOURCES="$SOURCES $srcdir/src/video/Xext/XmuStdCmap/*.c"
             EXTRA_CFLAGS="$EXTRA_CFLAGS $X_CFLAGS"
 
             if test x$enable_x11_shared = xmaybe; then
@@ -1261,69 +1260,6 @@
             if test x$definitely_enable_video_x11_scrnsaver = xyes; then
                 AC_DEFINE(SDL_VIDEO_DRIVER_X11_SCRNSAVER)
             fi
-            AC_ARG_ENABLE(video-x11-xrender,
-AC_HELP_STRING([--enable-video-x11-xrender], [enable X11 Xrender extension [[default=yes]]]),
-                            , enable_video_x11_xrender=yes)
-            if test x$enable_video_x11_xrender = xyes; then
-                AC_CHECK_HEADER(X11/extensions/Xrender.h,
-                                have_xrender_h_hdr=yes,
-                                have_xrender_h_hdr=no,
-                                [#include <X11/Xlib.h>
-                                ])
-                if test x$have_xrender_h_hdr = xyes; then
-                    if test x$enable_x11_shared = xyes && test x$xrender_lib != x ; then
-                        echo "-- dynamic libXrender -> $xrender_lib"
-                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER, "$xrender_lib")
-                        definitely_enable_video_x11_xrender=yes
-                    else
-                        AC_CHECK_LIB(Xrender, XRenderQueryExtension, have_xrender_lib=yes)
-                        if test x$have_xrender_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXrender"
-                            definitely_enable_video_x11_xrender=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_xrender = xyes; then
-                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XRENDER)
-            fi
-            AC_ARG_ENABLE(video-x11-xdamage-xfixes,
-AC_HELP_STRING([--enable-video-x11-xdamage-xfixes], [enable X11 Xdamage and Xfixes extensions [[default=yes]]]),
-                            , enable_video_x11_xdamage=yes)
-            if test x$enable_video_x11_xdamage = xyes && test x$definitely_enable_video_x11_xrender = xyes ; then
-                AC_CHECK_HEADER(X11/extensions/Xdamage.h,
-                                have_xdamage_h_hdr=yes,
-                                have_xdamage_h_hdr=no,
-                                [#include <X11/Xlib.h>
-                                ])
-                AC_CHECK_HEADER(X11/extensions/Xfixes.h,
-                                have_xfixes_h_hdr=yes,
-                                have_xfixes_h_hdr=no,
-                                [#include <X11/Xlib.h>
-                                ])
-                if test x$have_xdamage_h_hdr = xyes && test x$have_xfixes_h_hdr = xyes ; then
-                    if test x$enable_x11_shared = xyes && test x$xdamage_lib != x && test x$xfixes_lib != x ; then
-                        echo "-- dynamic libXdamage -> $xdamage_lib"
-                        echo "-- dynamic libXfixes -> $xfixes_lib"
-                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XDAMAGE, "$xdamage_lib")
-                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES, "$xfixes_lib")
-                        definitely_enable_video_x11_xdamage=yes
-                        definitely_enable_video_x11_xfixes=yes
-                    else
-                        AC_CHECK_LIB(Xdamage, XDamageQueryExtension, have_xdamage_lib=yes)
-                        AC_CHECK_LIB(Xfixes, XFixesQueryExtension, have_xfixes_lib=yes)
-                        if test x$have_xdamage_lib = xyes && test x$have_xfixes_lib = xyes ; then
-                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXdamage -lXfixes"
-                            definitely_enable_video_x11_xdamage=yes
-                            definitely_enable_video_x11_xfixes=yes
-                        fi
-                    fi
-                fi
-            fi
-            if test x$definitely_enable_video_x11_xdamage = xyes && test x$definitely_enable_video_x11_xfixes = xyes ; then
-                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XDAMAGE)
-                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XFIXES)
-            fi
         fi
     fi
 }
--- a/include/SDL_config.h.in	Fri Feb 04 18:05:20 2011 -0800
+++ b/include/SDL_config.h.in	Fri Feb 04 19:18:08 2011 -0800
@@ -266,20 +266,14 @@
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT
 #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XDAMAGE
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_VIDMODE
 #undef SDL_VIDEO_DRIVER_X11_XINERAMA
 #undef SDL_VIDEO_DRIVER_X11_XRANDR
 #undef SDL_VIDEO_DRIVER_X11_XINPUT
 #undef SDL_VIDEO_DRIVER_X11_SCRNSAVER
 #undef SDL_VIDEO_DRIVER_X11_XV
-#undef SDL_VIDEO_DRIVER_X11_XRENDER
-#undef SDL_VIDEO_DRIVER_X11_XDAMAGE
-#undef SDL_VIDEO_DRIVER_X11_XFIXES
 #undef SDL_VIDEO_DRIVER_X11_XSHAPE
 
 #undef SDL_VIDEO_RENDER_D3D
--- a/src/video/Xext/XmuStdCmap/AllCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,159 +0,0 @@
-/* $Xorg: AllCmap.c,v 1.4 2001/02/09 02:03:51 xorgcvs Exp $ */
-
-/* 
- 
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/AllCmap.c,v 1.7 2001/01/17 19:42:53 dawes Exp $ */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-static XVisualInfo *getDeepestVisual(int, XVisualInfo *, int);
-
-/*
- * To create all of the appropriate standard colormaps for every visual of
- * every screen on a given display, use XmuAllStandardColormaps.
- *
- * Define and retain as permanent resources all standard colormaps which are
- * meaningful for the visuals of each screen of the display.  Return 0 on
- * failure, non-zero on success.  If the property of any standard colormap 
- * is already defined, redefine it.
- *
- * This interface is intended to be used by window managers or a client
- * upon start-up of a session.
- *
- * The standard colormaps of a screen are defined by properties associated
- * with the screen's root window.  Each screen has exactly one root window.
- * The property names of standard colormaps are predefined, and each property
- * name may describe at most one colormap.
- * 
- * The standard colormaps are
- *		RGB_BEST_MAP
- *		RGB_RED_MAP
- *		RGB_GREEN_MAP
- *		RGB_BLUE_MAP
- *		RGB_DEFAULT_MAP
- *		RGB_GRAY_MAP
- *
- * Therefore a screen may have at most 6 standard colormap properties defined.
- *
- * A standard colormap is associated with a particular visual of the screen.
- * A screen may have multiple visuals defined, including visuals of the same
- * class at different depths.  Note that a visual id might be repeated for
- * more than one depth, so the visual id and the depth of a visual identify
- * the visual.  The characteristics of the visual will determine which
- * standard colormaps are meaningful under that visual, and will determine
- * how the standard colormap is defined.  Because a standard colormap is
- * associated with a specific visual, there must be a method of determining
- * which visuals take precedence in defining standard colormaps.
- * 
- * The method used here is: for the visual of greatest depth, define all 
- * standard colormaps meaningful to that visual class, according to this
- * order of (descending) precedence:
- *	1. DirectColor
- *	2. PseudoColor
- *	3. TrueColor and GrayScale
- *	4. StaticColor and StaticGray
- *
- * Allows partial success by screenful.  For example, if a map on screen 1
- * fails, the maps on screen 0, created earlier, will remain.  However,
- * none on screen 1 will remain.  If a map on 0 fails, none will remain.
- *
- * See the comments under XmuVisualStandardColormaps() for notes on which
- * standard colormaps are meaningful under these classes of visuals.
- */
-
-Status
-XmuAllStandardColormaps(Display * dpy)
-{
-    int nvisuals, scr;
-    Status status;
-    long vinfo_mask;
-    XVisualInfo template, *vinfo, *v1, *v2;
-
-    status = 0;
-    /* for each screen, determine all visuals of this server */
-    for (scr = 0; scr < ScreenCount(dpy); scr++) {
-        template.screen = scr;
-        vinfo_mask = VisualScreenMask;
-        vinfo = XGetVisualInfo(dpy, vinfo_mask, &template, &nvisuals);
-        if (vinfo == NULL)      /* unexpected: a screen with no visuals */
-            continue;
-
-        v1 = getDeepestVisual(DirectColor, vinfo, nvisuals);
-        v2 = getDeepestVisual(PseudoColor, vinfo, nvisuals);
-
-        if (v2 &&
-            (!v1 || (v2->colormap_size >=
-                     ((v1->red_mask | v1->green_mask | v1->blue_mask) + 1))))
-            status = XmuVisualStandardColormaps(dpy, scr, v2->visualid,
-                                                (unsigned) v2->depth, 1, 1);
-        else if (v1)
-            status = XmuVisualStandardColormaps(dpy, scr, v1->visualid,
-                                                (unsigned) v1->depth, 1, 1);
-
-        else {
-            if (((v1 = getDeepestVisual(TrueColor, vinfo, nvisuals)) != NULL)
-                || ((v1 = getDeepestVisual(StaticColor, vinfo, nvisuals)) !=
-                    NULL))
-                status = XmuVisualStandardColormaps(dpy, scr, v1->visualid,
-                                                    (unsigned) v1->depth, 1,
-                                                    1);
-            if (status
-                &&
-                (((v1 = getDeepestVisual(GrayScale, vinfo, nvisuals)) != NULL)
-                 || ((v1 = getDeepestVisual(StaticGray, vinfo, nvisuals)) !=
-                     NULL)))
-                status =
-                    XmuVisualStandardColormaps(dpy, scr, v1->visualid,
-                                               (unsigned) v1->depth, 1, 1);
-        }
-        XFree((char *) vinfo);
-        if (!status)
-            break;
-    }
-    return status;
-}
-
-static XVisualInfo *
-getDeepestVisual(int visual_class, XVisualInfo * vinfo, int nvisuals)
-{
-    register int i;
-    register int maxdepth = 0;
-    XVisualInfo *v = NULL;
-
-    for (i = 0; i < nvisuals; i++, vinfo++)
-        if (vinfo->class == visual_class && vinfo->depth > maxdepth) {
-            maxdepth = vinfo->depth;
-            v = vinfo;
-        }
-    return (v);
-}
--- a/src/video/Xext/XmuStdCmap/CmapAlloc.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,337 +0,0 @@
-/* $Xorg: CmapAlloc.c,v 1.4 2001/02/09 02:03:51 xorgcvs Exp $ */
-
-/* 
-
-Copyright 1989, 1994, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/CmapAlloc.c,v 1.6 2001/01/17 19:42:53 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-#include <stdio.h>
-
-#define lowbit(x) ((x) & (~(x) + 1))
-
-/*
- * Prototypes
- */
-static void best_allocation(XVisualInfo *, unsigned long *, unsigned long *,
-                            unsigned long *);
-static int default_allocation(XVisualInfo *, unsigned long *,
-                              unsigned long *, unsigned long *);
-static void gray_allocation(int, unsigned long *, unsigned long *,
-                            unsigned long *);
-static int icbrt(int);
-static int icbrt_with_bits(int, int);
-static int icbrt_with_guess(int, int);
-
-/* To determine the best allocation of reds, greens, and blues in a 
- * standard colormap, use XmuGetColormapAllocation.
- * 	vinfo		specifies visual information for a chosen visual
- *	property	specifies one of the standard colormap property names
- * 	red_max		returns maximum red value 
- *      green_max	returns maximum green value
- * 	blue_max	returns maximum blue value
- *
- * XmuGetColormapAllocation returns 0 on failure, non-zero on success.
- * It is assumed that the visual is appropriate for the colormap property.
- */
-
-Status
-XmuGetColormapAllocation(XVisualInfo * vinfo, Atom property,
-                         unsigned long *red_max,
-                         unsigned long *green_max, unsigned long *blue_max)
-{
-    Status status = 1;
-
-    if (vinfo->colormap_size <= 2)
-        return 0;
-
-    switch (property) {
-    case XA_RGB_DEFAULT_MAP:
-        status = default_allocation(vinfo, red_max, green_max, blue_max);
-        break;
-    case XA_RGB_BEST_MAP:
-        best_allocation(vinfo, red_max, green_max, blue_max);
-        break;
-    case XA_RGB_GRAY_MAP:
-        gray_allocation(vinfo->colormap_size, red_max, green_max, blue_max);
-        break;
-    case XA_RGB_RED_MAP:
-        *red_max = vinfo->colormap_size - 1;
-        *green_max = *blue_max = 0;
-        break;
-    case XA_RGB_GREEN_MAP:
-        *green_max = vinfo->colormap_size - 1;
-        *red_max = *blue_max = 0;
-        break;
-    case XA_RGB_BLUE_MAP:
-        *blue_max = vinfo->colormap_size - 1;
-        *red_max = *green_max = 0;
-        break;
-    default:
-        status = 0;
-    }
-    return status;
-}
-
-/****************************************************************************/
-/* Determine the appropriate color allocations of a gray scale.
- *
- * Keith Packard, MIT X Consortium
- */
-
-static void
-gray_allocation(int n, unsigned long *red_max, unsigned long *green_max,
-                unsigned long *blue_max)
-{
-    *red_max = (n * 30) / 100;
-    *green_max = (n * 59) / 100;
-    *blue_max = (n * 11) / 100;
-    *green_max += ((n - 1) - (*red_max + *green_max + *blue_max));
-}
-
-/****************************************************************************/
-/* Determine an appropriate color allocation for the RGB_DEFAULT_MAP.
- * If a map has less than a minimum number of definable entries, we do not
- * produce an allocation for an RGB_DEFAULT_MAP.  
- *
- * For 16 planes, the default colormap will have 27 each RGB; for 12 planes,
- * 12 each.  For 8 planes, let n = the number of colormap entries, which may
- * be 256 or 254.  Then, maximum red value = floor(cube_root(n - 125)) - 1.
- * Maximum green and maximum blue values are identical to maximum red.
- * This leaves at least 125 cells which clients can allocate.
- *
- * Return 0 if an allocation has been determined, non-zero otherwise.
- */
-
-static int
-default_allocation(XVisualInfo * vinfo, unsigned long *red,
-                   unsigned long *green, unsigned long *blue)
-{
-    int ngrays;                 /* number of gray cells */
-
-    switch (vinfo->class) {
-    case PseudoColor:
-
-        if (vinfo->colormap_size > 65000)
-            /* intended for displays with 16 planes */
-            *red = *green = *blue = (unsigned long) 27;
-        else if (vinfo->colormap_size > 4000)
-            /* intended for displays with 12 planes */
-            *red = *green = *blue = (unsigned long) 12;
-        else if (vinfo->colormap_size < 250)
-            return 0;
-        else
-            /* intended for displays with 8 planes */
-            *red = *green = *blue = (unsigned long)
-                (icbrt(vinfo->colormap_size - 125) - 1);
-        break;
-
-    case DirectColor:
-
-        if (vinfo->colormap_size < 10)
-            return 0;
-        *red = *green = *blue = vinfo->colormap_size / 2 - 1;
-        break;
-
-    case TrueColor:
-
-        *red = vinfo->red_mask / lowbit(vinfo->red_mask);
-        *green = vinfo->green_mask / lowbit(vinfo->green_mask);
-        *blue = vinfo->blue_mask / lowbit(vinfo->blue_mask);
-        break;
-
-    case GrayScale:
-
-        if (vinfo->colormap_size > 65000)
-            ngrays = 4096;
-        else if (vinfo->colormap_size > 4000)
-            ngrays = 512;
-        else if (vinfo->colormap_size < 250)
-            return 0;
-        else
-            ngrays = 12;
-        gray_allocation(ngrays, red, green, blue);
-        break;
-
-    default:
-        return 0;
-    }
-    return 1;
-}
-
-/****************************************************************************/
-/* Determine an appropriate color allocation for the RGB_BEST_MAP.
- *
- * For a DirectColor or TrueColor visual, the allocation is determined
- * by the red_mask, green_mask, and blue_mask members of the visual info.
- *
- * Otherwise, if the colormap size is an integral power of 2, determine
- * the allocation according to the number of bits given to each color,
- * with green getting more than red, and red more than blue, if there
- * are to be inequities in the distribution.  If the colormap size is
- * not an integral power of 2, let n = the number of colormap entries.
- * Then maximum red value = floor(cube_root(n)) - 1;
- * 	maximum blue value = floor(cube_root(n)) - 1;
- *	maximum green value = n / ((# red values) * (# blue values)) - 1;
- * Which, on a GPX, allows for 252 entries in the best map, out of 254
- * defineable colormap entries.
- */
-
-static void
-best_allocation(XVisualInfo * vinfo, unsigned long *red, unsigned long *green,
-                unsigned long *blue)
-{
-
-    if (vinfo->class == DirectColor || vinfo->class == TrueColor) {
-        *red = vinfo->red_mask;
-        while ((*red & 01) == 0)
-            *red >>= 1;
-        *green = vinfo->green_mask;
-        while ((*green & 01) == 0)
-            *green >>= 1;
-        *blue = vinfo->blue_mask;
-        while ((*blue & 01) == 0)
-            *blue >>= 1;
-    } else {
-        register int bits, n;
-
-        /* Determine n such that n is the least integral power of 2 which is
-         * greater than or equal to the number of entries in the colormap.
-         */
-        n = 1;
-        bits = 0;
-        while (vinfo->colormap_size > n) {
-            n = n << 1;
-            bits++;
-        }
-
-        /* If the number of entries in the colormap is a power of 2, determine
-         * the allocation by "dealing" the bits, first to green, then red, then
-         * blue.  If not, find the maximum integral red, green, and blue values
-         * which, when multiplied together, do not exceed the number of 
-
-         * colormap entries.
-         */
-        if (n == vinfo->colormap_size) {
-            register int r, g, b;
-            b = bits / 3;
-            g = b + ((bits % 3) ? 1 : 0);
-            r = b + (((bits % 3) == 2) ? 1 : 0);
-            *red = 1 << r;
-            *green = 1 << g;
-            *blue = 1 << b;
-        } else {
-            *red = icbrt_with_bits(vinfo->colormap_size, bits);
-            *blue = *red;
-            *green = (vinfo->colormap_size / ((*red) * (*blue)));
-        }
-        (*red)--;
-        (*green)--;
-        (*blue)--;
-    }
-    return;
-}
-
-/*
- * integer cube roots by Newton's method
- *
- * Stephen Gildea, MIT X Consortium, July 1991
- */
-
-static int
-icbrt(int a)
-{
-    register int bits = 0;
-    register unsigned n = a;
-
-    while (n) {
-        bits++;
-        n >>= 1;
-    }
-    return icbrt_with_bits(a, bits);
-}
-
-
-static int
-icbrt_with_bits(int a, int bits)
-     /* bits - log 2 of a */
-{
-    return icbrt_with_guess(a, a >> 2 * bits / 3);
-}
-
-#ifdef _X_ROOT_STATS
-int icbrt_loopcount;
-#endif
-
-/* Newton's Method:  x_n+1 = x_n - ( f(x_n) / f'(x_n) ) */
-
-/* for cube roots, x^3 - a = 0,  x_new = x - 1/3 (x - a/x^2) */
-
-/*
- * Quick and dirty cube roots.  Nothing fancy here, just Newton's method.
- * Only works for positive integers (since that's all we need).
- * We actually return floor(cbrt(a)) because that's what we need here, too.
- */
-
-static int
-icbrt_with_guess(int a, int guess)
-{
-    register int delta;
-
-#ifdef _X_ROOT_STATS
-    icbrt_loopcount = 0;
-#endif
-    if (a <= 0)
-        return 0;
-    if (guess < 1)
-        guess = 1;
-
-    do {
-#ifdef _X_ROOT_STATS
-        icbrt_loopcount++;
-#endif
-        delta = (guess - a / (guess * guess)) / 3;
-#ifdef DEBUG
-        printf("pass %d: guess=%d, delta=%d\n", icbrt_loopcount, guess,
-               delta);
-#endif
-        guess -= delta;
-    } while (delta != 0);
-
-    if (guess * guess * guess > a)
-        guess--;
-
-    return guess;
-}
--- a/src/video/Xext/XmuStdCmap/CrCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,531 +0,0 @@
-/* $Xorg: CrCmap.c,v 1.4 2001/02/09 02:03:51 xorgcvs Exp $ */
-
-/* 
-
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/CrCmap.c,v 3.6 2001/01/17 19:42:53 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-/*
- * CreateCmap.c - given a standard colormap description, make the map.
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-/*
- * Prototypes
- */
-/* allocate entire map Read Only */
-static int ROmap(Display *, Colormap, unsigned long[], int, int);
-
-/* allocate a cell, prefer Read Only */
-static Status ROorRWcell(Display *, Colormap, unsigned long[], int,
-                         XColor *, unsigned long);
-
-/* allocate a cell Read Write */
-static Status RWcell(Display *, Colormap, XColor *, XColor *,
-                     unsigned long *);
-
-/* for quicksort */
-static int compare(_Xconst void *, _Xconst void *);
-
-/* find contiguous sequence of cells */
-static Status contiguous(unsigned long[], int, int, unsigned long, int *,
-                         int *);
-
-/* frees resources before quitting */
-static void free_cells(Display *, Colormap, unsigned long[], int, int);
-
-/* create a map in a RO visual type */
-static Status readonly_map(Display *, XVisualInfo *, XStandardColormap *);
-
-/* create a map in a RW visual type */
-static Status readwrite_map(Display *, XVisualInfo *, XStandardColormap *);
-
-#define lowbit(x) ((x) & (~(x) + 1))
-#define TRUEMATCH(mult,max,mask) \
-    (colormap->max * colormap->mult <= vinfo->mask && \
-     lowbit(vinfo->mask) == colormap->mult)
-
-/*
- * To create any one colormap which is described by an XStandardColormap
- * structure, use XmuCreateColormap().
- *
- * Return 0 on failure, non-zero on success.
- * Resources created by this function are not made permanent.
- * No argument error checking is provided.  Use at your own risk.
- *
- * All colormaps are created with read only allocations, with the exception
- * of read only allocations of colors in the default map or otherwise
- * which fail to return the expected pixel value, and these are individually 
- * defined as read/write allocations.  This is done so that all the cells
- * defined in the default map are contiguous, for use in image processing.
- * This typically happens with White and Black in the default map.
- *
- * Colormaps of static visuals are considered to be successfully created if
- * the map of the static visual matches the definition given in the
- * standard colormap structure.
- */
-
-Status
-XmuCreateColormap(Display * dpy, XStandardColormap * colormap)
-     /* dpy      - specifies the connection under which the map is created
-      * colormap - specifies the map to be created, and returns, particularly
-      *            if the map is created as a subset of the default colormap
-      *            of the screen, the base_pixel of the map.
-      */
-{
-    XVisualInfo vinfo_template; /* template visual information */
-    XVisualInfo *vinfo;         /* matching visual information */
-    XVisualInfo *vpointer;      /* for freeing the entire list */
-    long vinfo_mask;            /* specifies the visual mask value */
-    int n;                      /* number of matching visuals */
-    int status;
-
-    vinfo_template.visualid = colormap->visualid;
-    vinfo_mask = VisualIDMask;
-    if ((vinfo =
-         XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
-        return 0;
-
-    /* A visual id may be valid on multiple screens.  Also, there may 
-     * be multiple visuals with identical visual ids at different depths.  
-     * If the colormap is the Default Colormap, use the Default Visual.
-     * Otherwise, arbitrarily, use the deepest visual.
-     */
-    vpointer = vinfo;
-    if (n > 1) {
-        register int i;
-        register int screen_number;
-        Bool def_cmap;
-
-        def_cmap = False;
-        for (screen_number = ScreenCount(dpy); --screen_number >= 0;)
-            if (colormap->colormap == DefaultColormap(dpy, screen_number)) {
-                def_cmap = True;
-                break;
-            }
-
-        if (def_cmap) {
-            for (i = 0; i < n; i++, vinfo++) {
-                if (vinfo->visual == DefaultVisual(dpy, screen_number))
-                    break;
-            }
-        } else {
-            int maxdepth = 0;
-            XVisualInfo *v = NULL;
-
-            for (i = 0; i < n; i++, vinfo++)
-                if (vinfo->depth > maxdepth) {
-                    maxdepth = vinfo->depth;
-                    v = vinfo;
-                }
-            vinfo = v;
-        }
-    }
-
-    if (vinfo->class == PseudoColor || vinfo->class == DirectColor ||
-        vinfo->class == GrayScale)
-        status = readwrite_map(dpy, vinfo, colormap);
-    else if (vinfo->class == TrueColor)
-        status = TRUEMATCH(red_mult, red_max, red_mask) &&
-            TRUEMATCH(green_mult, green_max, green_mask) &&
-            TRUEMATCH(blue_mult, blue_max, blue_mask);
-    else
-        status = readonly_map(dpy, vinfo, colormap);
-
-    XFree((char *) vpointer);
-    return status;
-}
-
-/****************************************************************************/
-static Status
-readwrite_map(Display * dpy, XVisualInfo * vinfo,
-              XStandardColormap * colormap)
-{
-    register unsigned long i, n;        /* index counters */
-    unsigned long ncolors;      /* number of colors to be defined */
-    int npixels;                /* number of pixels allocated R/W */
-    int first_index;            /* first index of pixels to use */
-    int remainder;              /* first index of remainder */
-    XColor color;               /* the definition of a color */
-    unsigned long *pixels;      /* array of colormap pixels */
-    unsigned long delta;
-
-
-    /* Determine ncolors, the number of colors to be defined.
-     * Insure that 1 < ncolors <= the colormap size.
-     */
-    if (vinfo->class == DirectColor) {
-        ncolors = colormap->red_max;
-        if (colormap->green_max > ncolors)
-            ncolors = colormap->green_max;
-        if (colormap->blue_max > ncolors)
-            ncolors = colormap->blue_max;
-        ncolors++;
-        delta = lowbit(vinfo->red_mask) +
-            lowbit(vinfo->green_mask) + lowbit(vinfo->blue_mask);
-    } else {
-        ncolors = colormap->red_max * colormap->red_mult +
-            colormap->green_max * colormap->green_mult +
-            colormap->blue_max * colormap->blue_mult + 1;
-        delta = 1;
-    }
-    if (ncolors <= 1 || (int) ncolors > vinfo->colormap_size)
-        return 0;
-
-    /* Allocate Read/Write as much of the colormap as we can possibly get.
-     * Then insure that the pixels we were allocated are given in 
-     * monotonically increasing order, using a quicksort.  Next, insure
-     * that our allocation includes a subset of contiguous pixels at least
-     * as long as the number of colors to be defined.  Now we know that 
-     * these conditions are met:
-     *  1) There are no free cells in the colormap.
-     *  2) We have a contiguous sequence of pixels, monotonically 
-     *     increasing, of length >= the number of colors requested.
-     *
-     * One cell at a time, we will free, compute the next color value, 
-     * then allocate read only.  This takes a long time.
-     * This is done to insure that cells are allocated read only in the
-     * contiguous order which we prefer.  If the server has a choice of
-     * cells to grant to an allocation request, the server may give us any
-     * cell, so that is why we do these slow gymnastics.
-     */
-
-    if ((pixels = (unsigned long *) calloc((unsigned) vinfo->colormap_size,
-                                           sizeof(unsigned long))) == NULL)
-        return 0;
-
-    if ((npixels = ROmap(dpy, colormap->colormap, pixels,
-                         vinfo->colormap_size, ncolors)) == 0) {
-        free((char *) pixels);
-        return 0;
-    }
-
-    qsort((char *) pixels, npixels, sizeof(unsigned long), compare);
-
-    if (!contiguous
-        (pixels, npixels, ncolors, delta, &first_index, &remainder)) {
-        /* can't find enough contiguous cells, give up */
-        XFreeColors(dpy, colormap->colormap, pixels, npixels,
-                    (unsigned long) 0);
-        free((char *) pixels);
-        return 0;
-    }
-    colormap->base_pixel = pixels[first_index];
-
-    /* construct a gray map */
-    if (colormap->red_mult == 1 && colormap->green_mult == 1 &&
-        colormap->blue_mult == 1)
-        for (n = colormap->base_pixel, i = 0; i < ncolors; i++, n += delta) {
-            color.pixel = n;
-            color.blue = color.green = color.red =
-                (unsigned short) ((i * 65535) / (colormap->red_max +
-                                                 colormap->green_max +
-                                                 colormap->blue_max));
-
-            if (!ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
-                            first_index + i))
-                return 0;
-        }
-
-    /* construct a red ramp map */
-    else if (colormap->green_max == 0 && colormap->blue_max == 0)
-        for (n = colormap->base_pixel, i = 0; i < ncolors; i++, n += delta) {
-            color.pixel = n;
-            color.red = (unsigned short) ((i * 65535) / colormap->red_max);
-            color.green = color.blue = 0;
-
-            if (!ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
-                            first_index + i))
-                return 0;
-        }
-
-    /* construct a green ramp map */
-    else if (colormap->red_max == 0 && colormap->blue_max == 0)
-        for (n = colormap->base_pixel, i = 0; i < ncolors; i++, n += delta) {
-            color.pixel = n;
-            color.green =
-                (unsigned short) ((i * 65535) / colormap->green_max);
-            color.red = color.blue = 0;
-
-            if (!ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
-                            first_index + i))
-                return 0;
-        }
-
-    /* construct a blue ramp map */
-    else if (colormap->red_max == 0 && colormap->green_max == 0)
-        for (n = colormap->base_pixel, i = 0; i < ncolors; i++, n += delta) {
-            color.pixel = n;
-            color.blue = (unsigned short) ((i * 65535) / colormap->blue_max);
-            color.red = color.green = 0;
-
-            if (!ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
-                            first_index + i))
-                return 0;
-        }
-
-    /* construct a standard red green blue cube map */
-    else {
-#define calc(max,mult) (((n / colormap->mult) % \
-			 (colormap->max + 1)) * 65535) / colormap->max
-
-        for (n = 0, i = 0; i < ncolors; i++, n += delta) {
-            color.pixel = n + colormap->base_pixel;
-            color.red = calc(red_max, red_mult);
-            color.green = calc(green_max, green_mult);
-            color.blue = calc(blue_max, blue_mult);
-            if (!ROorRWcell(dpy, colormap->colormap, pixels, npixels, &color,
-                            first_index + i))
-                return 0;
-        }
-#undef calc
-    }
-    /* We have a read-only map defined.  Now free unused cells,
-     * first those occuring before the contiguous sequence begins,
-     * then any following the contiguous sequence.
-     */
-
-    if (first_index)
-        XFreeColors(dpy, colormap->colormap, pixels, first_index,
-                    (unsigned long) 0);
-    if (remainder)
-        XFreeColors(dpy, colormap->colormap,
-                    &(pixels[first_index + ncolors]), remainder,
-                    (unsigned long) 0);
-
-    free((char *) pixels);
-    return 1;
-}
-
-
-/****************************************************************************/
-static int
-ROmap(Display * dpy, Colormap cmap, unsigned long pixels[], int m, int n)
-     /*
-      * dpy     - the X server connection
-      * cmap    - specifies colormap ID
-      * pixels  - returns pixel allocations
-      * m       - specifies colormap size
-      * n       - specifies number of colors
-      */
-{
-    register int p;
-
-    /* first try to allocate the entire colormap */
-    if (XAllocColorCells(dpy, cmap, 1, (unsigned long *) NULL,
-                         (unsigned) 0, pixels, (unsigned) m))
-        return m;
-
-    /* Allocate all available cells in the colormap, using a binary
-     * algorithm to discover how many cells we can allocate in the colormap.
-     */
-    m--;
-    while (n <= m) {
-        p = n + ((m - n + 1) / 2);
-        if (XAllocColorCells(dpy, cmap, 1, (unsigned long *) NULL,
-                             (unsigned) 0, pixels, (unsigned) p)) {
-            if (p == m)
-                return p;
-            else {
-                XFreeColors(dpy, cmap, pixels, p, (unsigned long) 0);
-                n = p;
-            }
-        } else
-            m = p - 1;
-    }
-    return 0;
-}
-
-
-/****************************************************************************/
-static Status
-contiguous(unsigned long pixels[], int npixels, int ncolors,
-           unsigned long delta, int *first, int *rem)
-     /* pixels  - specifies allocated pixels
-      * npixels - specifies count of alloc'd pixels
-      * ncolors - specifies needed sequence length
-      * delta   - between pixels
-      * first   - returns first index of sequence
-      * rem     - returns first index after sequence, or 0, if none follow
-      */
-{
-    register int i = 1;         /* walking index into the pixel array */
-    register int count = 1;     /* length of sequence discovered so far */
-
-    *first = 0;
-    if (npixels == ncolors) {
-        *rem = 0;
-        return 1;
-    }
-    *rem = npixels - 1;
-    while (count < ncolors && ncolors - count <= *rem) {
-        if (pixels[i - 1] + delta == pixels[i])
-            count++;
-        else {
-            count = 1;
-            *first = i;
-        }
-        i++;
-        (*rem)--;
-    }
-    if (count != ncolors)
-        return 0;
-    return 1;
-}
-
-
-/****************************************************************************/
-static Status
-ROorRWcell(Display * dpy, Colormap cmap, unsigned long pixels[],
-           int npixels, XColor * color, unsigned long p)
-{
-    unsigned long pixel;
-    XColor request;
-
-    /* Free the read/write allocation of one cell in the colormap.
-     * Request a read only allocation of one cell in the colormap.
-     * If the read only allocation cannot be granted, give up, because
-     * there must be no free cells in the colormap.
-     * If the read only allocation is granted, but gives us a cell which
-     * is not the one that we just freed, it is probably the case that
-     * we are trying allocate White or Black or some other color which
-     * already has a read-only allocation in the map.  So we try to 
-     * allocate the previously freed cell with a read/write allocation,
-     * because we want contiguous cells for image processing algorithms.
-     */
-
-    pixel = color->pixel;
-    request.red = color->red;
-    request.green = color->green;
-    request.blue = color->blue;
-
-    XFreeColors(dpy, cmap, &pixel, 1, (unsigned long) 0);
-    if (!XAllocColor(dpy, cmap, color)
-        || (color->pixel != pixel &&
-            (!RWcell(dpy, cmap, color, &request, &pixel)))) {
-        free_cells(dpy, cmap, pixels, npixels, (int) p);
-        return 0;
-    }
-    return 1;
-}
-
-
-/****************************************************************************/
-static void
-free_cells(Display * dpy, Colormap cmap, unsigned long pixels[],
-           int npixels, int p)
-     /*
-      * pixels  - to be freed
-      * npixels - original number allocated
-      */
-{
-    /* One of the npixels allocated has already been freed.
-     * p is the index of the freed pixel.
-     * First free the pixels preceeding p, and there are p of them;
-     * then free the pixels following p, there are npixels - p - 1 of them.
-     */
-    XFreeColors(dpy, cmap, pixels, p, (unsigned long) 0);
-    XFreeColors(dpy, cmap, &(pixels[p + 1]), npixels - p - 1,
-                (unsigned long) 0);
-    free((char *) pixels);
-}
-
-
-/****************************************************************************/
-static Status
-RWcell(Display * dpy, Colormap cmap, XColor * color, XColor * request,
-       unsigned long *pixel)
-{
-    unsigned long n = *pixel;
-
-    XFreeColors(dpy, cmap, &(color->pixel), 1, (unsigned long) 0);
-    if (!XAllocColorCells(dpy, cmap, (Bool) 0, (unsigned long *) NULL,
-                          (unsigned) 0, pixel, (unsigned) 1))
-        return 0;
-    if (*pixel != n) {
-        XFreeColors(dpy, cmap, pixel, 1, (unsigned long) 0);
-        return 0;
-    }
-    color->pixel = *pixel;
-    color->flags = DoRed | DoGreen | DoBlue;
-    color->red = request->red;
-    color->green = request->green;
-    color->blue = request->blue;
-    XStoreColors(dpy, cmap, color, 1);
-    return 1;
-}
-
-
-/****************************************************************************/
-static int
-compare(_Xconst void *e1, _Xconst void *e2)
-{
-    return ((int) (*(long *) e1 - *(long *) e2));
-}
-
-
-/****************************************************************************/
-static Status
-readonly_map(Display * dpy, XVisualInfo * vinfo, XStandardColormap * colormap)
-{
-    int i, last_pixel;
-    XColor color;
-
-    last_pixel = (colormap->red_max + 1) * (colormap->green_max + 1) *
-        (colormap->blue_max + 1) + colormap->base_pixel - 1;
-
-    for (i = colormap->base_pixel; i <= last_pixel; i++) {
-
-        color.pixel = (unsigned long) i;
-        color.red = (unsigned short)
-            (((i / colormap->red_mult) * 65535) / colormap->red_max);
-
-        if (vinfo->class == StaticColor) {
-            color.green = (unsigned short)
-                ((((i / colormap->green_mult) % (colormap->green_max + 1)) *
-                  65535) / colormap->green_max);
-            color.blue = (unsigned short)
-                (((i % colormap->green_mult) * 65535) / colormap->blue_max);
-        } else                  /* vinfo->class == GrayScale, old style allocation XXX */
-            color.green = color.blue = color.red;
-
-        XAllocColor(dpy, colormap->colormap, &color);
-        if (color.pixel != (unsigned long) i)
-            return 0;
-    }
-    return 1;
-}
--- a/src/video/Xext/XmuStdCmap/DelCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-/* $Xorg: DelCmap.c,v 1.4 2001/02/09 02:03:52 xorgcvs Exp $ */
-
-/* 
- 
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/DelCmap.c,v 1.6 2001/01/17 19:42:54 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-/* To remove any standard colormap property, use XmuDeleteStandardColormap().
- * XmuDeleteStandardColormap() will remove the specified property from the
- * specified screen, releasing any resources used by the colormap(s) of the
- * property if possible.
- */
-
-void
-XmuDeleteStandardColormap(Display * dpy, int screen, Atom property)
-     /* dpy;            - specifies the X server to connect to
-      * screen          - specifies the screen of the display
-      * property        - specifies the standard colormap property
-      */
-{
-    XStandardColormap *stdcmaps, *s;
-    int count = 0;
-
-    if (XGetRGBColormaps(dpy, RootWindow(dpy, screen), &stdcmaps, &count,
-                         property)) {
-        for (s = stdcmaps; count > 0; count--, s++) {
-            if ((s->killid == ReleaseByFreeingColormap) &&
-                (s->colormap != None) &&
-                (s->colormap != DefaultColormap(dpy, screen)))
-                XFreeColormap(dpy, s->colormap);
-            else if (s->killid != None)
-                XKillClient(dpy, s->killid);
-        }
-        XDeleteProperty(dpy, RootWindow(dpy, screen), property);
-        XFree((char *) stdcmaps);
-        XSync(dpy, False);
-    }
-}
--- a/src/video/Xext/XmuStdCmap/Distinct.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,90 +0,0 @@
-/* $Xorg: Distinct.c,v 1.4 2001/02/09 02:03:52 xorgcvs Exp $ */
-
-/*
-
-Copyright 1990, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/Distinct.c,v 3.5 2001/07/25 15:04:50 dawes Exp $ */
-
-/*
- * Author:  Keith Packard, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <X11/Xlib.h>
-#include <stdlib.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-/*
- * Distinguishable colors routine.  Determines if two colors are
- * distinguishable or not.  Somewhat arbitrary meaning.
- */
-
-#define MIN_DISTINGUISH	10000.0
-
-Bool
-XmuDistinguishableColors(XColor * colors, int count)
-{
-    double deltaRed, deltaGreen, deltaBlue;
-    double dist;
-    int i, j;
-
-    for (i = 0; i < count - 1; i++)
-        for (j = i + 1; j < count; j++) {
-            deltaRed = (double) colors[i].red - (double) colors[j].red;
-            deltaGreen = (double) colors[i].green - (double) colors[j].green;
-            deltaBlue = (double) colors[i].blue - (double) colors[j].blue;
-            dist = deltaRed * deltaRed +
-                deltaGreen * deltaGreen + deltaBlue * deltaBlue;
-            if (dist <= MIN_DISTINGUISH * MIN_DISTINGUISH)
-                return False;
-        }
-    return True;
-}
-
-Bool
-XmuDistinguishablePixels(Display * dpy, Colormap cmap,
-                         unsigned long *pixels, int count)
-{
-    XColor *defs;
-    int i, j;
-    Bool ret;
-
-    for (i = 0; i < count - 1; i++)
-        for (j = i + 1; j < count; j++)
-            if (pixels[i] == pixels[j])
-                return False;
-    defs = (XColor *) malloc(count * sizeof(XColor));
-    if (!defs)
-        return False;
-    for (i = 0; i < count; i++)
-        defs[i].pixel = pixels[i];
-    XQueryColors(dpy, cmap, defs, count);
-    ret = XmuDistinguishableColors(defs, count);
-    free((char *) defs);
-    return ret;
-}
--- a/src/video/Xext/XmuStdCmap/LookupCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,323 +0,0 @@
-/* $Xorg: LookupCmap.c,v 1.4 2001/02/09 02:03:53 xorgcvs Exp $ */
-
-/* 
- 
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/LookupCmap.c,v 1.7 2001/07/25 15:04:50 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-#include <stdlib.h>
-
-/*
- * Prototypes
- */
-static Status lookup(Display *, int, VisualID, Atom, XStandardColormap *,
-                     Bool);
-
-/*
- * To create a standard colormap if one does not currently exist, or
- * replace the currently existing standard colormap, use 
- * XmuLookupStandardColormap().
- *
- * Given a screen, a visual, and a property, XmuLookupStandardColormap()
- * will determine the best allocation for the property under the specified
- * visual, and determine the whether to create a new colormap or to use
- * the default colormap of the screen.  It will call XmuStandardColormap()
- * to create the standard colormap.
- *
- * If replace is true, any previous definition of the property will be 
- * replaced.  If retain is true, the property and the colormap will be
- * made permanent for the duration of the server session.  However,
- * pre-existing property definitions which are not replaced cannot be made
- * permanent by a call to XmuLookupStandardColormap(); a request to retain 
- * resources pertains to newly created resources.
- *
- * Returns 0 on failure, non-zero on success.  A request to create a 
- * standard colormap upon a visual which cannot support such a map is
- * considered a failure.  An example of this would be requesting any
- * standard colormap property on a monochrome visual, or, requesting an
- * RGB_BEST_MAP on a display whose colormap size is 16.
- */
-
-Status
-XmuLookupStandardColormap(Display * dpy, int screen, VisualID visualid,
-                          unsigned int depth, Atom property,
-                          Bool replace, Bool retain)
-     /*
-      * dpy             - specifies X server connection
-      * screen          - specifies screen of display
-      * visualid        - specifies the visual type
-      * depth           - specifies  the visual type
-      * property        - a standard colormap property
-      * replace         - specifies whether to replace
-      * retain          - specifies whether to retain
-      */
-{
-    Display *odpy;              /* original display connection */
-    XStandardColormap *colormap;
-    XVisualInfo vinfo_template, *vinfo; /* visual */
-    long vinfo_mask;
-    unsigned long r_max, g_max, b_max;  /* allocation */
-    int count;
-    Colormap cmap;              /* colormap ID */
-    Status status = 0;
-
-
-    /* Match the requested visual */
-
-    vinfo_template.visualid = visualid;
-    vinfo_template.screen = screen;
-    vinfo_template.depth = depth;
-    vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
-    if ((vinfo = XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &count)) ==
-        NULL)
-        return 0;
-
-    /* Monochrome visuals have no standard maps */
-
-    if (vinfo->colormap_size <= 2) {
-        XFree((char *) vinfo);
-        return 0;
-    }
-
-    /* If the requested property already exists on this screen, and, 
-     * if the replace flag has not been set to true, return success.
-     * lookup() will remove a pre-existing map if replace is true.
-     */
-
-    if (lookup(dpy, screen, visualid, property, (XStandardColormap *) NULL,
-               replace) && !replace) {
-        XFree((char *) vinfo);
-        return 1;
-    }
-
-    /* Determine the best allocation for this property under the requested
-     * visualid and depth, and determine whether or not to use the default
-     * colormap of the screen.
-     */
-
-    if (!XmuGetColormapAllocation(vinfo, property, &r_max, &g_max, &b_max)) {
-        XFree((char *) vinfo);
-        return 0;
-    }
-
-    cmap = (property == XA_RGB_DEFAULT_MAP &&
-            visualid == XVisualIDFromVisual(DefaultVisual(dpy, screen)))
-        ? DefaultColormap(dpy, screen) : None;
-
-    /* If retaining resources, open a new connection to the same server */
-
-    if (retain) {
-        odpy = dpy;
-        if ((dpy = XOpenDisplay(XDisplayString(odpy))) == NULL) {
-            XFree((char *) vinfo);
-            return 0;
-        }
-    }
-
-    /* Create the standard colormap */
-
-    colormap = XmuStandardColormap(dpy, screen, visualid, depth, property,
-                                   cmap, r_max, g_max, b_max);
-
-    /* Set the standard colormap property */
-
-    if (colormap) {
-        XGrabServer(dpy);
-
-        if (lookup(dpy, screen, visualid, property, colormap, replace) &&
-            !replace) {
-            /* Someone has defined the property since we last looked.
-             * Since we will not replace it, release our own resources.
-             * If this is the default map, our allocations will be freed 
-             * when this connection closes.
-             */
-            if (colormap->killid == ReleaseByFreeingColormap)
-                XFreeColormap(dpy, colormap->colormap);
-        } else if (retain) {
-            XSetCloseDownMode(dpy, RetainPermanent);
-        }
-        XUngrabServer(dpy);
-        XFree((char *) colormap);
-        status = 1;
-    }
-
-    if (retain)
-        XCloseDisplay(dpy);
-    XFree((char *) vinfo);
-    return status;
-}
-
-/***************************************************************************/
-
-/* Lookup a standard colormap property.  If the property is RGB_DEFAULT_MAP,
- * the visualid is used to determine whether the indicated standard colormap
- * exists.  If the map exists and replace is true, delete the resources used
- * by the map and remove the property.  Return true if the map exists,
- * or did exist and was deleted; return false if the map was not found.
- *
- * Note that this is not the way that a Status return is normally used.
- *
- * If new is not NULL, new points to an XStandardColormap structure which
- * describes a standard colormap of the specified property.  It will be made
- * a standard colormap of the screen if none already exists, or if replace 
- * is true.
- */
-
-static Status
-lookup(Display * dpy, int screen, VisualID visualid, Atom property,
-       XStandardColormap * cnew, Bool replace)
-     /*
-      * dpy             - specifies display connection
-      * screen          - specifies screen number
-      * visualid        - specifies visualid for std map
-      * property        - specifies colormap property name
-      * cnew            - specifies a standard colormap
-      * replace         - specifies whether to replace
-      */
-{
-    register int i;
-    int count;
-    XStandardColormap *stdcmaps, *s;
-    Window win = RootWindow(dpy, screen);
-
-    /* The property does not already exist */
-
-    if (!XGetRGBColormaps(dpy, win, &stdcmaps, &count, property)) {
-        if (cnew)
-            XSetRGBColormaps(dpy, win, cnew, 1, property);
-        return 0;
-    }
-
-    /* The property exists and is not describing the RGB_DEFAULT_MAP */
-
-    if (property != XA_RGB_DEFAULT_MAP) {
-        if (replace) {
-            XmuDeleteStandardColormap(dpy, screen, property);
-            if (cnew)
-                XSetRGBColormaps(dpy, win, cnew, 1, property);
-        }
-        XFree((char *) stdcmaps);
-        return 1;
-    }
-
-    /* The property exists and is RGB_DEFAULT_MAP */
-
-    for (i = 0, s = stdcmaps; (i < count) && (s->visualid != visualid);
-         i++, s++);
-
-    /* No RGB_DEFAULT_MAP property matches the given visualid */
-
-    if (i == count) {
-        if (cnew) {
-            XStandardColormap *m, *maps;
-
-            s = (XStandardColormap *) malloc((unsigned) ((count + 1) * sizeof
-                                                         (XStandardColormap)));
-
-            for (i = 0, m = s, maps = stdcmaps; i < count; i++, m++, maps++) {
-                m->colormap = maps->colormap;
-                m->red_max = maps->red_max;
-                m->red_mult = maps->red_mult;
-                m->green_max = maps->green_max;
-                m->green_mult = maps->green_mult;
-                m->blue_max = maps->blue_max;
-                m->blue_mult = maps->blue_mult;
-                m->base_pixel = maps->base_pixel;
-                m->visualid = maps->visualid;
-                m->killid = maps->killid;
-            }
-            m->colormap = cnew->colormap;
-            m->red_max = cnew->red_max;
-            m->red_mult = cnew->red_mult;
-            m->green_max = cnew->green_max;
-            m->green_mult = cnew->green_mult;
-            m->blue_max = cnew->blue_max;
-            m->blue_mult = cnew->blue_mult;
-            m->base_pixel = cnew->base_pixel;
-            m->visualid = cnew->visualid;
-            m->killid = cnew->killid;
-
-            XSetRGBColormaps(dpy, win, s, ++count, property);
-            free((char *) s);
-        }
-        XFree((char *) stdcmaps);
-        return 0;
-    }
-
-    /* Found an RGB_DEFAULT_MAP property with a matching visualid */
-
-    if (replace) {
-        /* Free old resources first - we may need them, particularly in 
-         * the default colormap of the screen.  However, because of this,
-         * it is possible that we will destroy the old resource and fail 
-         * to create a new one if XmuStandardColormap() fails.
-         */
-
-        if (count == 1) {
-            XmuDeleteStandardColormap(dpy, screen, property);
-            if (cnew)
-                XSetRGBColormaps(dpy, win, cnew, 1, property);
-        } else {
-            XStandardColormap *map;
-
-            /* s still points to the matching standard colormap */
-
-            if (s->killid == ReleaseByFreeingColormap) {
-                if ((s->colormap != None) &&
-                    (s->colormap != DefaultColormap(dpy, screen)))
-                    XFreeColormap(dpy, s->colormap);
-            } else if (s->killid != None)
-                XKillClient(dpy, s->killid);
-
-            map = (cnew) ? cnew : stdcmaps + --count;
-
-            s->colormap = map->colormap;
-            s->red_max = map->red_max;
-            s->red_mult = map->red_mult;
-            s->green_max = map->green_max;
-            s->green_mult = map->green_mult;
-            s->blue_max = map->blue_max;
-            s->blue_mult = map->blue_mult;
-            s->visualid = map->visualid;
-            s->killid = map->killid;
-
-            XSetRGBColormaps(dpy, win, stdcmaps, count, property);
-        }
-    }
-    XFree((char *) stdcmaps);
-    return 1;
-}
--- a/src/video/Xext/XmuStdCmap/StdCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,236 +0,0 @@
-/* $Xorg: StdCmap.c,v 1.4 2001/02/09 02:03:53 xorgcvs Exp $ */
-
-/* 
-
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/StdCmap.c,v 1.5 2001/01/17 19:42:56 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-#define lowbit(x) ((x) & (~(x) + 1))
-
-/*
- * Prototypes
- */
-/* argument restrictions */
-static Status valid_args(XVisualInfo *, unsigned long, unsigned long,
-                         unsigned long, Atom);
-
-/*
- * To create any one standard colormap, use XmuStandardColormap().
- *
- * Create a standard colormap for the given screen, visualid, and visual
- * depth, with the given red, green, and blue maximum values, with the
- * given standard property name.  Return a pointer to an XStandardColormap
- * structure which describes the newly created colormap, upon success.
- * Upon failure, return NULL.
- * 
- * XmuStandardColormap() calls XmuCreateColormap() to create the map.
- *
- * Resources created by this function are not made permanent; that is the
- * caller's responsibility.
- */
-
-XStandardColormap *
-XmuStandardColormap(Display * dpy, int screen, VisualID visualid,
-                    unsigned int depth, Atom property, Colormap cmap,
-                    unsigned long red_max, unsigned long green_max,
-                    unsigned long blue_max)
-     /*
-      * dpy                             - specifies X server connection
-      * screen                          - specifies display screen
-      * visualid                        - identifies the visual type
-      * depth                           - identifies the visual type
-      * property                        - a standard colormap property
-      * cmap                            - specifies colormap ID or None
-      * red_max, green_max, blue_max    - allocations
-      */
-{
-    XStandardColormap *stdcmap;
-    Status status;
-    XVisualInfo vinfo_template, *vinfo;
-    long vinfo_mask;
-    int n;
-
-    /* Match the required visual information to an actual visual */
-    vinfo_template.visualid = visualid;
-    vinfo_template.screen = screen;
-    vinfo_template.depth = depth;
-    vinfo_mask = VisualIDMask | VisualScreenMask | VisualDepthMask;
-    if ((vinfo =
-         XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
-        return 0;
-
-    /* Check the validity of the combination of visual characteristics,
-     * allocation, and colormap property.  Create an XStandardColormap
-     * structure.
-     */
-
-    if (!valid_args(vinfo, red_max, green_max, blue_max, property)
-        || ((stdcmap = XAllocStandardColormap()) == NULL)) {
-        XFree((char *) vinfo);
-        return 0;
-    }
-
-    /* Fill in the XStandardColormap structure */
-
-    if (cmap == DefaultColormap(dpy, screen)) {
-        /* Allocating out of the default map, cannot use XFreeColormap() */
-        Window win = XCreateWindow(dpy, RootWindow(dpy, screen), 1, 1, 1, 1,
-                                   0, 0, InputOnly, vinfo->visual,
-                                   (unsigned long) 0,
-                                   (XSetWindowAttributes *) NULL);
-        stdcmap->killid = (XID) XCreatePixmap(dpy, win, 1, 1, depth);
-        XDestroyWindow(dpy, win);
-        stdcmap->colormap = cmap;
-    } else {
-        stdcmap->killid = ReleaseByFreeingColormap;
-        stdcmap->colormap = XCreateColormap(dpy, RootWindow(dpy, screen),
-                                            vinfo->visual, AllocNone);
-    }
-    stdcmap->red_max = red_max;
-    stdcmap->green_max = green_max;
-    stdcmap->blue_max = blue_max;
-    if (property == XA_RGB_GRAY_MAP)
-        stdcmap->red_mult = stdcmap->green_mult = stdcmap->blue_mult = 1;
-    else if (vinfo->class == TrueColor || vinfo->class == DirectColor) {
-        stdcmap->red_mult = lowbit(vinfo->red_mask);
-        stdcmap->green_mult = lowbit(vinfo->green_mask);
-        stdcmap->blue_mult = lowbit(vinfo->blue_mask);
-    } else {
-        stdcmap->red_mult = (red_max > 0)
-            ? (green_max + 1) * (blue_max + 1) : 0;
-        stdcmap->green_mult = (green_max > 0) ? blue_max + 1 : 0;
-        stdcmap->blue_mult = (blue_max > 0) ? 1 : 0;
-    }
-    stdcmap->base_pixel = 0;    /* base pixel may change */
-    stdcmap->visualid = vinfo->visualid;
-
-    /* Make the colormap */
-
-    status = XmuCreateColormap(dpy, stdcmap);
-
-    /* Clean up */
-
-    XFree((char *) vinfo);
-    if (!status) {
-
-        /* Free the colormap or the pixmap, if we created one */
-        if (stdcmap->killid == ReleaseByFreeingColormap)
-            XFreeColormap(dpy, stdcmap->colormap);
-        else if (stdcmap->killid != None)
-            XFreePixmap(dpy, stdcmap->killid);
-
-        XFree((char *) stdcmap);
-        return (XStandardColormap *) NULL;
-    }
-    return stdcmap;
-}
-
-/****************************************************************************/
-static Status
-valid_args(XVisualInfo * vinfo, unsigned long red_max,
-           unsigned long green_max, unsigned long blue_max, Atom property)
-     /*
-      * vinfo                           - specifies visual
-      * red_max, green_max, blue_max    - specifies alloc
-      * property                        - specifies property name
-      */
-{
-    unsigned long ncolors;      /* number of colors requested */
-
-    /* Determine that the number of colors requested is <= map size */
-
-    if ((vinfo->class == DirectColor) || (vinfo->class == TrueColor)) {
-        unsigned long mask;
-
-        mask = vinfo->red_mask;
-        while (!(mask & 1))
-            mask >>= 1;
-        if (red_max > mask)
-            return 0;
-        mask = vinfo->green_mask;
-        while (!(mask & 1))
-            mask >>= 1;
-        if (green_max > mask)
-            return 0;
-        mask = vinfo->blue_mask;
-        while (!(mask & 1))
-            mask >>= 1;
-        if (blue_max > mask)
-            return 0;
-    } else if (property == XA_RGB_GRAY_MAP) {
-        ncolors = red_max + green_max + blue_max + 1;
-        if (ncolors > vinfo->colormap_size)
-            return 0;
-    } else {
-        ncolors = (red_max + 1) * (green_max + 1) * (blue_max + 1);
-        if (ncolors > vinfo->colormap_size)
-            return 0;
-    }
-
-    /* Determine that the allocation and visual make sense for the property */
-
-    switch (property) {
-    case XA_RGB_DEFAULT_MAP:
-        if (red_max == 0 || green_max == 0 || blue_max == 0)
-            return 0;
-        break;
-    case XA_RGB_RED_MAP:
-        if (red_max == 0)
-            return 0;
-        break;
-    case XA_RGB_GREEN_MAP:
-        if (green_max == 0)
-            return 0;
-        break;
-    case XA_RGB_BLUE_MAP:
-        if (blue_max == 0)
-            return 0;
-        break;
-    case XA_RGB_BEST_MAP:
-        if (red_max == 0 || green_max == 0 || blue_max == 0)
-            return 0;
-        break;
-    case XA_RGB_GRAY_MAP:
-        if (red_max == 0 || blue_max == 0 || green_max == 0)
-            return 0;
-        break;
-    default:
-        return 0;
-    }
-    return 1;
-}
--- a/src/video/Xext/XmuStdCmap/VisCmap.c	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,184 +0,0 @@
-/* $Xorg: VisCmap.c,v 1.4 2001/02/09 02:03:53 xorgcvs Exp $ */
-
-/* 
-
-Copyright 1989, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/VisCmap.c,v 1.6 2001/01/17 19:42:57 dawes Exp $ */
-
-/*
- * Author:  Donna Converse, MIT X Consortium
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <math.h>
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#include <X11/Xutil.h>
-#include "../extensions/StdCmap.h"
-
-/*
- * To create all of the appropriate standard colormaps for a given visual on
- * a given screen, use XmuVisualStandardColormaps.
- * 
- * Define all appropriate standard colormap properties for the given visual.
- * If replace is true, any previous definition will be removed.
- * If retain is true, new properties will be retained for the duration of
- * the server session.  Return 0 on failure, non-zero on success.
- * On failure, no new properties will be defined, and, old ones may have
- * been removed if replace was True.
- *
- * Not all standard colormaps are meaningful to all visual classes.  This
- * routine will check and define the following properties for the following
- * classes, provided that the size of the colormap is not too small.
- *
- *	DirectColor and PseudoColor
- *	    RGB_DEFAULT_MAP
- *	    RGB_BEST_MAP
- *	    RGB_RED_MAP
- *	    RGB_GREEN_MAP
- * 	    RGB_BLUE_MAP
- *          RGB_GRAY_MAP
- *
- *	TrueColor and StaticColor
- *	    RGB_BEST_MAP
- *
- *	GrayScale and StaticGray
- *	    RGB_GRAY_MAP
- */
-
-Status
-XmuVisualStandardColormaps(Display * dpy, int screen, VisualID visualid,
-                           unsigned int depth, Bool replace, Bool retain)
-     /*
-      * dpy                     - specifies server connection
-      * screen                  - specifies screen number
-      * visualid                - specifies the visual
-      * depth                   - specifies the visual
-      * replace specifies       - whether to replace
-      * retain                  - specifies whether to retain
-      */
-{
-    Status status;
-    int n;
-    long vinfo_mask;
-    XVisualInfo vinfo_template, *vinfo;
-
-    status = 0;
-    vinfo_template.screen = screen;
-    vinfo_template.visualid = visualid;
-    vinfo_template.depth = depth;
-    vinfo_mask = VisualScreenMask | VisualIDMask | VisualDepthMask;
-    if ((vinfo =
-         XGetVisualInfo(dpy, vinfo_mask, &vinfo_template, &n)) == NULL)
-        return 0;
-
-    if (vinfo->colormap_size <= 2) {
-        /* Monochrome visuals have no standard maps; considered successful */
-        XFree((char *) vinfo);
-        return 1;
-    }
-
-    switch (vinfo->class) {
-    case PseudoColor:
-    case DirectColor:
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_DEFAULT_MAP, replace,
-                                           retain);
-        if (!status)
-            break;
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_GRAY_MAP, replace, retain);
-        if (!status) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            break;
-        }
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_RED_MAP, replace, retain);
-        if (!status) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
-            break;
-        }
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_GREEN_MAP, replace, retain);
-        if (!status) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
-            break;
-        }
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_BLUE_MAP, replace, retain);
-        if (!status) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GREEN_MAP);
-            break;
-        }
-        /* fall through */
-
-    case StaticColor:
-    case TrueColor:
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_BEST_MAP, replace, retain);
-        if (!status && (vinfo->class == PseudoColor ||
-                        vinfo->class == DirectColor)) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GRAY_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_RED_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_GREEN_MAP);
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_BLUE_MAP);
-        }
-        break;
-        /* the end for PseudoColor, DirectColor, StaticColor, and TrueColor */
-
-    case GrayScale:
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_DEFAULT_MAP, replace,
-                                           retain);
-        if (!status)
-            break;
-     /*FALLTHROUGH*/ case StaticGray:
-
-        status = XmuLookupStandardColormap(dpy, screen, visualid, depth,
-                                           XA_RGB_GRAY_MAP, replace, retain);
-        if (!status && vinfo->class == GrayScale) {
-            XmuDeleteStandardColormap(dpy, screen, XA_RGB_DEFAULT_MAP);
-            break;
-        }
-    }
-
-    XFree((char *) vinfo);
-    return status;
-}
--- a/src/video/Xext/extensions/StdCmap.h	Fri Feb 04 18:05:20 2011 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-/* $Xorg: StdCmap.h,v 1.5 2001/02/09 02:03:53 xorgcvs Exp $ */
-
-/*
- 
-Copyright 1988, 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.
-
-*/
-/* $XFree86: xc/lib/Xmu/StdCmap.h,v 1.8 2001/01/23 17:38:14 keithp Exp $ */
-
-/*
- * The interfaces described by this header file are for miscellaneous utilities
- * and are not part of the Xlib standard.
- */
-
-#ifndef _XMU_STDCMAP_H_
-#define _XMU_STDCMAP_H_
-
-#include <X11/Xfuncproto.h>
-#include "SDL_name.h"
-
-_XFUNCPROTOBEGIN extern Status XmuAllStandardColormaps(Display * dpy);
-
-extern Status XmuCreateColormap(Display * dpy, XStandardColormap * colormap);
-
-extern void XmuDeleteStandardColormap
-    (Display * dpy, int screen, Atom property);
-
-extern Status XmuGetColormapAllocation
-    (XVisualInfo * vinfo,
-     Atom property,
-     unsigned long *red_max_return,
-     unsigned long *green_max_return, unsigned long *blue_max_return);
-
-extern Status XmuLookupStandardColormap
-    (Display * dpy,
-     int screen,
-     VisualID visualid,
-     unsigned int depth, Atom property, Bool replace, Bool retain);
-
-extern XStandardColormap *XmuStandardColormap
-    (Display * dpy,
-     int screen,
-     VisualID visualid,
-     unsigned int depth,
-     Atom property,
-     Colormap cmap,
-     unsigned long red_max, unsigned long green_max, unsigned long blue_max);
-
-extern Status XmuVisualStandardColormaps
-    (Display * dpy,
-     int screen,
-     VisualID visualid, unsigned int depth, Bool replace, Bool retain);
-
-extern Bool XmuDistinguishableColors(XColor * colors, int count);
-
-extern Bool XmuDistinguishablePixels
-    (Display * dpy, Colormap cmap, unsigned long *pixels, int count);
-
-_XFUNCPROTOEND
-#endif /* _XMU_STDCMAP_H_ */
--- a/src/video/x11/SDL_x11dyn.h	Fri Feb 04 18:05:20 2011 -0800
+++ b/src/video/x11/SDL_x11dyn.h	Fri Feb 04 19:18:08 2011 -0800
@@ -52,18 +52,6 @@
 #include <X11/extensions/XInput.h>
 #endif
 
-#if SDL_VIDEO_DRIVER_X11_XRENDER
-#include <X11/extensions/Xrender.h>
-#endif
-
-#if SDL_VIDEO_DRIVER_X11_XDAMAGE
-#include <X11/extensions/Xdamage.h>
-#endif
-
-#if SDL_VIDEO_DRIVER_X11_XFIXES
-#include <X11/extensions/Xfixes.h>
-#endif
-
 /*
  * When using the "dynamic X11" functionality, we duplicate all the Xlib
  *  symbols that would be referenced by SDL inside of SDL itself.
--- a/src/video/x11/SDL_x11sym.h	Fri Feb 04 18:05:20 2011 -0800
+++ b/src/video/x11/SDL_x11sym.h	Fri Feb 04 19:18:08 2011 -0800
@@ -24,58 +24,38 @@
 
 SDL_X11_MODULE(BASEXLIB)
 SDL_X11_SYM(XClassHint*,XAllocClassHint,(void),(),return)
-SDL_X11_SYM(Status,XAllocColor,(Display* a,Colormap b,XColor* c),(a,b,c),return)
-SDL_X11_SYM(Status,XAllocColorCells,(Display *a,Colormap b,Bool c,unsigned long d[],unsigned int e,unsigned long f[],unsigned int g),(a,b,c,d,e,f,g),return)
 SDL_X11_SYM(XSizeHints*,XAllocSizeHints,(void),(),return)
-SDL_X11_SYM(XStandardColormap *,XAllocStandardColormap,(void),(),return)
 SDL_X11_SYM(XWMHints*,XAllocWMHints,(void),(),return)
 SDL_X11_SYM(int,XAutoRepeatOn,(Display* a),(a),return)
 SDL_X11_SYM(int,XAutoRepeatOff,(Display* a),(a),return)
 SDL_X11_SYM(int,XChangePointerControl,(Display* a,Bool b,Bool c,int d,int e,int f),(a,b,c,d,e,f),return)
 SDL_X11_SYM(int,XChangeProperty,(Display* a,Window b,Atom c,Atom d,int e,int f,_Xconst unsigned char* g,int h),(a,b,c,d,e,f,g,h),return)
-SDL_X11_SYM(int,XChangeWindowAttributes,(Display* a,Window b,unsigned long c,XSetWindowAttributes* d),(a,b,c,d),return)
-SDL_X11_SYM(Bool,XCheckWindowEvent,(Display* a,Window b,long c,XEvent* d),(a,b,c,d),return)
-SDL_X11_SYM(int,XClearWindow,(Display* a,Window b),(a,b),return)
 SDL_X11_SYM(int,XCloseDisplay,(Display* a),(a),return)
 SDL_X11_SYM(int,XConvertSelection,(Display* a,Atom b,Atom c,Atom d,Window e,Time f),(a,b,c,d,e,f),return)
-SDL_X11_SYM(int,XCopyArea,(Display* a,Drawable b,Drawable c,GC d,int e,int f,unsigned int g,unsigned int h,int i,int j),(a,b,c,d,e,f,g,h,i,j),return)
 SDL_X11_SYM(Pixmap,XCreateBitmapFromData,(Display *dpy,Drawable d,_Xconst char *data,unsigned int width,unsigned int height),(dpy,d,data,width,height),return)
 SDL_X11_SYM(Colormap,XCreateColormap,(Display* a,Window b,Visual* c,int d),(a,b,c,d),return)
 SDL_X11_SYM(Cursor,XCreatePixmapCursor,(Display* a,Pixmap b,Pixmap c,XColor* d,XColor* e,unsigned int f,unsigned int g),(a,b,c,d,e,f,g),return)
 SDL_X11_SYM(GC,XCreateGC,(Display* a,Drawable b,unsigned long c,XGCValues* d),(a,b,c,d),return)
 SDL_X11_SYM(XImage*,XCreateImage,(Display* a,Visual* b,unsigned int c,int d,int e,char* f,unsigned int g,unsigned int h,int i,int j),(a,b,c,d,e,f,g,h,i,j),return)
-SDL_X11_SYM(Pixmap,XCreatePixmap,(Display* a,Drawable b,unsigned int c,unsigned int d,unsigned int e),(a,b,c,d,e),return)
-SDL_X11_SYM(Pixmap,XCreatePixmapFromBitmapData,(Display* a,Drawable b,char* c,unsigned int d,unsigned int e,unsigned long f,unsigned long g,unsigned int h),(a,b,c,d,e,f,g,h),return)
-SDL_X11_SYM(Window,XCreateSimpleWindow,(Display* a,Window b,int c,int d,unsigned int e,unsigned int f,unsigned int g,unsigned long h,unsigned long i),(a,b,c,d,e,f,g,h,i),return)
 SDL_X11_SYM(Window,XCreateWindow,(Display* a,Window b,int c,int d,unsigned int e,unsigned int f,unsigned int g,int h,unsigned int i,Visual* j,unsigned long k,XSetWindowAttributes* l),(a,b,c,d,e,f,g,h,i,j,k,l),return)
 SDL_X11_SYM(int,XDefineCursor,(Display* a,Window b,Cursor c),(a,b,c),return)
 SDL_X11_SYM(int,XDeleteProperty,(Display* a,Window b,Atom c),(a,b,c),return)
 SDL_X11_SYM(int,XDestroyWindow,(Display* a,Window b),(a,b),return)
 SDL_X11_SYM(int,XDisplayKeycodes,(Display* a,int* b,int* c),(a,b,c),return)
-SDL_X11_SYM(int,XDrawLines,(Display* a, Drawable b, GC c, XPoint* d, int e, int f),(a,b,c,d,e,f),return)
-SDL_X11_SYM(int,XDrawPoint,(Display* a, Drawable b, GC c, int d, int e),(a,b,c,d,e),return)
-SDL_X11_SYM(int,XDrawPoints,(Display* a, Drawable b, GC c, XPoint* d, int e, int f),(a,b,c,d,e,f),return)
-SDL_X11_SYM(int,XDrawRectangles,(Display* a,Drawable b,GC c,XRectangle* d,int e),(a,b,c,d,e),return)
-SDL_X11_SYM(int,XFillRectangles,(Display* a,Drawable b,GC c,XRectangle* d,int e),(a,b,c,d,e),return)
 SDL_X11_SYM(char*,XDisplayName,(_Xconst char* a),(a),return)
 SDL_X11_SYM(int,XEventsQueued,(Display* a,int b),(a,b),return)
 SDL_X11_SYM(Bool,XFilterEvent,(XEvent *event,Window w),(event,w),return)
 SDL_X11_SYM(int,XFlush,(Display* a),(a),return)
 SDL_X11_SYM(int,XFree,(void*a),(a),return)
-SDL_X11_SYM(int,XFreeColormap,(Display* a,Colormap b),(a,b),return)
-SDL_X11_SYM(int,XFreeColors,(Display* a,Colormap b,unsigned long* c,int d,unsigned long e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XFreeCursor,(Display* a,Cursor b),(a,b),return)
 SDL_X11_SYM(int,XFreeGC,(Display* a,GC b),(a,b),return)
 SDL_X11_SYM(int,XFreeModifiermap,(XModifierKeymap* a),(a),return)
 SDL_X11_SYM(int,XFreePixmap,(Display* a,Pixmap b),(a,b),return)
 SDL_X11_SYM(char*,XGetAtomName,(Display *a,Atom b),(a,b),return)
 SDL_X11_SYM(int,XGetErrorDatabaseText,(Display* a,_Xconst char* b,_Xconst char* c,_Xconst char* d,char* e,int f),(a,b,c,d,e,f),return)
-SDL_X11_SYM(XImage*,XGetImage,(Display* a,Drawable b,int c,int d,unsigned int e,unsigned int f,unsigned long g, int h),(a,b,c,d,e,f,g,h),return)
 SDL_X11_SYM(XModifierKeymap*,XGetModifierMapping,(Display* a),(a),return)
 SDL_X11_SYM(int,XGetPointerControl,(Display* a,int* b,int* c,int* d),(a,b,c,d),return)
-SDL_X11_SYM(int,XGetRGBColormaps,(Display* a,Window b,XStandardColormap **c,int *d,Atom e),(a,b,c,d,e),return)
 SDL_X11_SYM(Window,XGetSelectionOwner,(Display* a,Atom b),(a,b),return)
-SDL_X11_SYM(Status,XGetTextProperty,(Display *a,Window b,XTextProperty *c,Atom d),(a,b,c,d),return)
 SDL_X11_SYM(XVisualInfo*,XGetVisualInfo,(Display* a,long b,XVisualInfo* c,int* d),(a,b,c,d),return)
 SDL_X11_SYM(Status,XGetWindowAttributes,(Display* a,Window b,XWindowAttributes* c),(a,b,c),return)
 SDL_X11_SYM(int,XGetWindowProperty,(Display* a,Window b,Atom c,long d,long e,Bool f,Atom g,Atom* h,int* i,unsigned long* j,unsigned long *k,unsigned char **l),(a,b,c,d,e,f,g,h,i,j,k,l),return)
@@ -84,47 +64,34 @@
 SDL_X11_SYM(int,XGrabPointer,(Display* a,Window b,Bool c,unsigned int d,int e,int f,Window g,Cursor h,Time i),(a,b,c,d,e,f,g,h,i),return)
 SDL_X11_SYM(int,XGrabServer,(Display* a),(a),return)
 SDL_X11_SYM(Status,XIconifyWindow,(Display* a,Window b,int c),(a,b,c),return)
-SDL_X11_SYM(int,XInstallColormap,(Display* a,Colormap b),(a,b),return)
 SDL_X11_SYM(KeyCode,XKeysymToKeycode,(Display* a,KeySym b),(a,b),return)
 SDL_X11_SYM(char*,XKeysymToString,(KeySym a),(a),return)
-SDL_X11_SYM(int,XKillClient,(Display* a,XID b),(a,b),return)
 SDL_X11_SYM(Atom,XInternAtom,(Display* a,_Xconst char* b,Bool c),(a,b,c),return)
 SDL_X11_SYM(XPixmapFormatValues*,XListPixmapFormats,(Display* a,int* b),(a,b),return)
 SDL_X11_SYM(KeySym,XLookupKeysym,(XKeyEvent* a,int b),(a,b),return)
 SDL_X11_SYM(int,XLookupString,(XKeyEvent* a,char* b,int c,KeySym* d,XComposeStatus* e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XMapRaised,(Display* a,Window b),(a,b),return)
-SDL_X11_SYM(int,XMapWindow,(Display* a,Window b),(a,b),return)
-SDL_X11_SYM(int,XMaskEvent,(Display* a,long b,XEvent* c),(a,b,c),return)
 SDL_X11_SYM(Status,XMatchVisualInfo,(Display* a,int b,int c,int d,XVisualInfo* e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XMissingExtension,(Display* a,_Xconst char* b),(a,b),return)
-SDL_X11_SYM(int,XMoveResizeWindow,(Display* a,Window b,int c,int d,unsigned int e,unsigned int f),(a,b,c,d,e,f),return)
 SDL_X11_SYM(int,XMoveWindow,(Display* a,Window b,int c,int d),(a,b,c,d),return)
 SDL_X11_SYM(int,XNextEvent,(Display* a,XEvent* b),(a,b),return)
 SDL_X11_SYM(Display*,XOpenDisplay,(_Xconst char* a),(a),return)
 SDL_X11_SYM(int,XPeekEvent,(Display* a,XEvent* b),(a,b),return)
 SDL_X11_SYM(int,XPending,(Display* a),(a),return)
 SDL_X11_SYM(int,XPutImage,(Display* a,Drawable b,GC c,XImage* d,int e,int f,int g,int h,unsigned int i,unsigned int j),(a,b,c,d,e,f,g,h,i,j),return)
-SDL_X11_SYM(int,XQueryColors,(Display* a,Colormap b,XColor* c,int d),(a,b,c,d),return)
 SDL_X11_SYM(int,XQueryKeymap,(Display* a,char *b),(a,b),return)
 SDL_X11_SYM(Bool,XQueryPointer,(Display* a,Window b,Window* c,Window* d,int* e,int* f,int* g,int* h,unsigned int* i),(a,b,c,d,e,f,g,h,i),return)
 SDL_X11_SYM(int,XRaiseWindow,(Display* a,Window b),(a,b),return)
-SDL_X11_SYM(int,XReparentWindow,(Display* a,Window b,Window c,int d,int e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XResetScreenSaver,(Display* a),(a),return)
 SDL_X11_SYM(int,XResizeWindow,(Display* a,Window b,unsigned int c,unsigned int d),(a,b,c,d),return)
 SDL_X11_SYM(int,XSelectInput,(Display* a,Window b,long c),(a,b,c),return)
 SDL_X11_SYM(Status,XSendEvent,(Display* a,Window b,Bool c,long d,XEvent* e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XSetClassHint,(Display* a,Window b,XClassHint* c),(a,b,c),return)
-SDL_X11_SYM(int,XSetCloseDownMode,(Display *a, int b),(a,b),return)
-SDL_X11_SYM(int,XSetForeground,(Display* a,GC b,unsigned long c),(a,b,c),return)
 SDL_X11_SYM(XErrorHandler,XSetErrorHandler,(XErrorHandler a),(a),return)
 SDL_X11_SYM(XIOErrorHandler,XSetIOErrorHandler,(XIOErrorHandler a),(a),return)
-SDL_X11_SYM(void,XSetRGBColormaps,( Display *a,Window b,XStandardColormap *c,int d,Atom e),(a,b,c,d,e),return)
 SDL_X11_SYM(int,XSetSelectionOwner,(Display* a,Atom b,Window c,Time d),(a,b,c,d),return)
 SDL_X11_SYM(int,XSetTransientForHint,(Display* a,Window b,Window c),(a,b,c),return)
 SDL_X11_SYM(void,XSetTextProperty,(Display* a,Window b,XTextProperty* c,Atom d),(a,b,c,d),)
-SDL_X11_SYM(int,XSetWindowBackground,(Display* a,Window b,unsigned long c),(a,b,c),return)
-SDL_X11_SYM(int,XSetWindowBackgroundPixmap,(Display* a,Window b,Pixmap c),(a,b,c),return)
-SDL_X11_SYM(int,XSetWindowColormap,(Display* a,Window b,Colormap c),(a,b,c),return)
 SDL_X11_SYM(int,XSetWMHints,(Display* a,Window b,XWMHints* c),(a,b,c),return)
 SDL_X11_SYM(void,XSetWMNormalHints,(Display* a,Window b,XSizeHints* c),(a,b,c),)
 SDL_X11_SYM(Status,XSetWMProtocols,(Display* a,Window b,Atom* c,int d),(a,b,c,d),return)
@@ -157,10 +124,6 @@
 SDL_X11_SYM(SDL_X11_XESetWireToEventRetType,XESetWireToEvent,(Display* a,int b,SDL_X11_XESetWireToEventRetType c),(a,b,c),return)
 SDL_X11_SYM(SDL_X11_XESetEventToWireRetType,XESetEventToWire,(Display* a,int b,SDL_X11_XESetEventToWireRetType c),(a,b,c),return)
 SDL_X11_SYM(XExtensionErrorHandler,XSetExtensionErrorHandler,(XExtensionErrorHandler a),(a),return)
-SDL_X11_SYM(int,XFillRectangle,(Display *dpy,Drawable d,GC gc,int x,int y,unsigned int width,unsigned int height),(dpy,d,gc,x,y,width,height),return)
-SDL_X11_SYM(int,XSetBackground,(Display *dpy,GC gc,unsigned long background),(dpy,gc,background),return)
-SDL_X11_SYM(Status,XInitImage,(XImage *image),(image),return)
-SDL_X11_SYM(int,XSetClipMask,(Display *dpy,GC gc,Pixmap pixmap),(dpy,gc,pixmap),return)
 
 #if NeedWidePrototypes
 SDL_X11_SYM(KeySym,XKeycodeToKeysym,(Display* a,unsigned int b,int c),(a,b,c),return)
@@ -243,42 +206,6 @@
 SDL_X11_SYM(void,XScreenSaverSuspend,(Display *dpy,Bool suspend),(dpy,suspend),return)
 #endif
 
-/* XRender support */
-#if SDL_VIDEO_DRIVER_X11_XRENDER
-SDL_X11_MODULE(XRENDER)
-SDL_X11_SYM(Bool,XRenderQueryExtension,(Display *dpy,int *event_base,int *error_base),(dpy,event_base,error_base),return)
-SDL_X11_SYM(Bool,XRenderQueryVersion,(Display *dpy,int *major,int *minor),(dpy,major,minor),return)
-SDL_X11_SYM(XRenderPictFormat*,XRenderFindVisualFormat,(Display *dpy,_Xconst Visual *visual),(dpy,visual),return)
-SDL_X11_SYM(XRenderPictFormat*,XRenderFindStandardFormat,(Display *dpy,int format),(dpy,format),return)
-SDL_X11_SYM(XRenderPictFormat*,XRenderFindFormat,(Display *dpy,unsigned long mask,_Xconst XRenderPictFormat* templ,int count),(dpy,mask,templ,count),return)
-SDL_X11_SYM(Picture,XRenderCreatePicture,(Display *dpy,Drawable drawable,_Xconst XRenderPictFormat* format,unsigned long valuemask,_Xconst XRenderPictureAttributes* attributes),(dpy,drawable,format,valuemask,attributes),return)
-SDL_X11_SYM(void,XRenderFreePicture,(Display *dpy,Picture picture),(dpy,picture),return)
-SDL_X11_SYM(void,XRenderChangePicture,(Display *dpy,Picture picture,unsigned long valuemask,_Xconst XRenderPictureAttributes* attributes),(dpy,picture,valuemask,attributes),return)
-SDL_X11_SYM(void,XRenderComposite,(Display *dpy,int op,Picture src,Picture mask,Picture dst,int src_x,int src_y,int mask_x,int mask_y,int dst_x,int dst_y,unsigned int width,unsigned int height),(dpy,op,src,mask,dst,src_x,src_y,mask_x,mask_y,dst_x,dst_y,width,height),return)
-SDL_X11_SYM(Picture,XRenderCreateSolidFill,(Display *dpy,const XRenderColor *color),(dpy,color),return)
-SDL_X11_SYM(void,XRenderSetPictureTransform,(Display *dpy,Picture picture,XTransform *transform),(dpy,picture,transform),return)
-SDL_X11_SYM(void,XRenderFillRectangle,(Display *dpy,int op,Picture dst,_Xconst XRenderColor *color,int x,int y,unsigned int width,unsigned int height),(dpy,op,dst,color,x,y,width,height),return)
-SDL_X11_SYM(void,XRenderFillRectangles,(Display *dpy,int op,Picture dst,_Xconst XRenderColor *color,_Xconst XRectangle *rectangles,int n_rects),(dpy,op,dst,color,rectangles,n_rects),return)
-SDL_X11_SYM(void,XRenderSetPictureFilter,(Display *dpy,Picture picture,const char *filter,XFixed *params,int nparams),(dpy,picture,filter,params,nparams),return)
-#endif
-
-#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
-SDL_X11_MODULE(XDAMAGE)
-SDL_X11_SYM(Bool,XDamageQueryExtension,(Display *dpy,int *event_base_return,int *error_base_return),(dpy,event_base_return,error_base_return),return)
-SDL_X11_SYM(Status,XDamageQueryVersion,(Display *dpy,int *major,int *minor),(dpy,major,minor),return)
-SDL_X11_SYM(Damage,XDamageCreate,(Display *dpy,Drawable d,int level),(dpy,d,level),return)
-SDL_X11_SYM(void,XDamageSubtract,(Display *dpy,Damage damage,XserverRegion repair,XserverRegion parts),(dpy,damage,repair,parts),return)
-SDL_X11_SYM(void,XDamageDestroy,(Display *dpy,Damage damage),(dpy,damage),return)
-#endif
-
-#ifdef SDL_VIDEO_DRIVER_X11_XFIXES
-SDL_X11_MODULE(XFIXES)
-SDL_X11_SYM(Bool,XFixesQueryExtension,(Display *dpy,int *event_base,int *error_base),(dpy,event_base,error_base),return)
-SDL_X11_SYM(Status,XFixesQueryVersion,(Display *dpy,int *major,int *minor),(dpy,major,minor),return)
-SDL_X11_SYM(void,XFixesSetGCClipRegion,(Display *dpy,GC gc,int clip_x,int clip_y,XserverRegion region),(dpy,gc,clip_x,clip_y,region),return)
-SDL_X11_SYM(void,XFixesSetPictureClipRegion,(Display *dpy,XID picture,int clip_x,int clip_y,XserverRegion region),(dpy,picture,clip_x,clip_y,region),return)
-#endif
-
 #if SDL_VIDEO_DRIVER_X11_XSHAPE
 SDL_X11_MODULE(XSHAPE)
 SDL_X11_SYM(void,XShapeCombineMask,(Display *dpy,Window dest,int dest_kind,int x_off,int y_off,Pixmap src,int op),(dpy,dest,dest_kind,x_off,y_off,src,op),)
--- a/src/video/x11/SDL_x11video.h	Fri Feb 04 18:05:20 2011 -0800
+++ b/src/video/x11/SDL_x11video.h	Fri Feb 04 19:18:08 2011 -0800
@@ -47,15 +47,6 @@
 #if SDL_VIDEO_DRIVER_X11_SCRNSAVER
 #include <X11/extensions/scrnsaver.h>
 #endif
-#if SDL_VIDEO_DRIVER_X11_XRENDER
-#include <X11/extensions/Xrender.h>
-#endif
-#if SDL_VIDEO_DRIVER_X11_XDAMAGE
-#include <X11/extensions/Xdamage.h>
-#endif
-#if SDL_VIDEO_DRIVER_X11_XFIXES
-#include <X11/extensions/Xfixes.h>
-#endif
 #if SDL_VIDEO_DRIVER_X11_XSHAPE
 #include <X11/extensions/shape.h>
 #endif
--- a/src/video/x11/SDL_x11window.c	Fri Feb 04 18:05:20 2011 -0800
+++ b/src/video/x11/SDL_x11window.c	Fri Feb 04 19:18:08 2011 -0800
@@ -30,7 +30,6 @@
 #include "SDL_x11mouse.h"
 #include "SDL_x11gamma.h"
 #include "SDL_x11shape.h"
-#include "../Xext/extensions/StdCmap.h"
 
 #ifdef SDL_VIDEO_DRIVER_PANDORA
 #include "SDL_x11opengles.h"