massive reduction of unneeded files

1 files changed, 0 insertions, 537 deletions

diff --git a/nx-X11/lib/Xmu/CrCmap.c b/nx-X11/lib/Xmu/CrCmap.c
deleted file mode 100644
index 011c71465..000000000
--- a/nx-X11/lib/Xmu/CrCmap.c
+++ /dev/null
@@ -1,537 +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 <X11/Xmu/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;
-}