[deb_xorg-server.git] / hw / xnest / Color.c

/*

Copyright 1993 by Davor Matic

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.  Davor Matic makes no representations about
the suitability of this software for any purpose.  It is provided "as
is" without express or implied warranty.

*/

#ifdef HAVE_XNEST_CONFIG_H
#include <xnest-config.h>
#endif

#include <X11/X.h>
#include <X11/Xproto.h>
#include "scrnintstr.h"
#include "window.h"
#include "windowstr.h"
#include "colormapst.h"
#include "resource.h"

#include "Xnest.h"

#include "Display.h"
#include "Screen.h"
#include "Color.h"
#include "Visual.h"
#include "XNWindow.h"
#include "Args.h"

DevPrivateKeyRec xnestColormapPrivateKeyRec;

static DevPrivateKeyRec cmapScrPrivateKeyRec;

#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)

#define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))
#define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))

Bool
xnestCreateColormap(ColormapPtr pCmap)
{
    VisualPtr pVisual;
    XColor *colors;
    int i, ncolors;
    Pixel red, green, blue;
    Pixel redInc, greenInc, blueInc;

    pVisual = pCmap->pVisual;
    ncolors = pVisual->ColormapEntries;

    xnestColormapPriv(pCmap)->colormap =
        XCreateColormap(xnestDisplay,
                        xnestDefaultWindows[pCmap->pScreen->myNum],
                        xnestVisual(pVisual),
                        (pVisual->class & DynamicClass) ? AllocAll : AllocNone);

    switch (pVisual->class) {
    case StaticGray:           /* read only */
        colors = (XColor *) malloc(ncolors * sizeof(XColor));
        for (i = 0; i < ncolors; i++)
            colors[i].pixel = i;
        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
        for (i = 0; i < ncolors; i++) {
            pCmap->red[i].co.local.red = colors[i].red;
            pCmap->red[i].co.local.green = colors[i].red;
            pCmap->red[i].co.local.blue = colors[i].red;
        }
        free(colors);
        break;

    case StaticColor:          /* read only */
        colors = (XColor *) malloc(ncolors * sizeof(XColor));
        for (i = 0; i < ncolors; i++)
            colors[i].pixel = i;
        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
        for (i = 0; i < ncolors; i++) {
            pCmap->red[i].co.local.red = colors[i].red;
            pCmap->red[i].co.local.green = colors[i].green;
            pCmap->red[i].co.local.blue = colors[i].blue;
        }
        free(colors);
        break;

    case TrueColor:            /* read only */
        colors = (XColor *) malloc(ncolors * sizeof(XColor));
        red = green = blue = 0L;
        redInc = lowbit(pVisual->redMask);
        greenInc = lowbit(pVisual->greenMask);
        blueInc = lowbit(pVisual->blueMask);
        for (i = 0; i < ncolors; i++) {
            colors[i].pixel = red | green | blue;
            red += redInc;
            if (red > pVisual->redMask)
                red = 0L;
            green += greenInc;
            if (green > pVisual->greenMask)
                green = 0L;
            blue += blueInc;
            if (blue > pVisual->blueMask)
                blue = 0L;
        }
        XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
        for (i = 0; i < ncolors; i++) {
            pCmap->red[i].co.local.red = colors[i].red;
            pCmap->green[i].co.local.green = colors[i].green;
            pCmap->blue[i].co.local.blue = colors[i].blue;
        }
        free(colors);
        break;

    case GrayScale:            /* read and write */
        break;

    case PseudoColor:          /* read and write */
        break;

    case DirectColor:          /* read and write */
        break;
    }

    return True;
}

void
xnestDestroyColormap(ColormapPtr pCmap)
{
    XFreeColormap(xnestDisplay, xnestColormap(pCmap));
}

#define SEARCH_PREDICATE \
  (xnestWindow(pWin) != None && wColormap(pWin) == icws->cmapIDs[i])

static int
xnestCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)
{
    xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *) ptr;
    int i;

    for (i = 0; i < icws->numCmapIDs; i++)
        if (SEARCH_PREDICATE) {
            icws->numWindows++;
            return WT_DONTWALKCHILDREN;
        }

    return WT_WALKCHILDREN;
}

static int
xnestGetInstalledColormapWindows(WindowPtr pWin, pointer ptr)
{
    xnestInstalledColormapWindows *icws = (xnestInstalledColormapWindows *) ptr;
    int i;

    for (i = 0; i < icws->numCmapIDs; i++)
        if (SEARCH_PREDICATE) {
            icws->windows[icws->index++] = xnestWindow(pWin);
            return WT_DONTWALKCHILDREN;
        }

    return WT_WALKCHILDREN;
}

static Window *xnestOldInstalledColormapWindows = NULL;
static int xnestNumOldInstalledColormapWindows = 0;

static Bool
xnestSameInstalledColormapWindows(Window *windows, int numWindows)
{
    if (xnestNumOldInstalledColormapWindows != numWindows)
        return False;

    if (xnestOldInstalledColormapWindows == windows)
        return True;

    if (xnestOldInstalledColormapWindows == NULL || windows == NULL)
        return False;

    if (memcmp(xnestOldInstalledColormapWindows, windows,
               numWindows * sizeof(Window)))
        return False;

    return True;
}

void
xnestSetInstalledColormapWindows(ScreenPtr pScreen)
{
    xnestInstalledColormapWindows icws;
    int numWindows;

    icws.cmapIDs = (Colormap *) malloc(pScreen->maxInstalledCmaps *
                                       sizeof(Colormap));
    icws.numCmapIDs = xnestListInstalledColormaps(pScreen, icws.cmapIDs);
    icws.numWindows = 0;
    WalkTree(pScreen, xnestCountInstalledColormapWindows, (pointer) &icws);
    if (icws.numWindows) {
        icws.windows =
            (Window *) malloc((icws.numWindows + 1) * sizeof(Window));
        icws.index = 0;
        WalkTree(pScreen, xnestGetInstalledColormapWindows, (pointer) &icws);
        icws.windows[icws.numWindows] = xnestDefaultWindows[pScreen->myNum];
        numWindows = icws.numWindows + 1;
    }
    else {
        icws.windows = NULL;
        numWindows = 0;
    }

    free(icws.cmapIDs);

    if (!xnestSameInstalledColormapWindows(icws.windows, icws.numWindows)) {
        free(xnestOldInstalledColormapWindows);

#ifdef _XSERVER64
        {
            int i;
            Window64 *windows =
                (Window64 *) malloc(numWindows * sizeof(Window64));

            for (i = 0; i < numWindows; ++i)
                windows[i] = icws.windows[i];
            XSetWMColormapWindows(xnestDisplay,
                                  xnestDefaultWindows[pScreen->myNum], windows,
                                  numWindows);
            free(windows);
        }
#else
        XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
                              icws.windows, numWindows);
#endif

        xnestOldInstalledColormapWindows = icws.windows;
        xnestNumOldInstalledColormapWindows = icws.numWindows;

#ifdef DUMB_WINDOW_MANAGERS
        /* 
           This code is for dumb window managers.
           This will only work with default local visual colormaps.
         */
        if (icws.numWindows) {
            WindowPtr pWin;
            Visual *visual;
            ColormapPtr pCmap;

            pWin = xnestWindowPtr(icws.windows[0]);
            visual = xnestVisualFromID(pScreen, wVisual(pWin));

            if (visual == xnestDefaultVisual(pScreen))
                dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
                                        RT_COLORMAP, serverClient,
                                        DixUseAccess);
            else
                dixLookupResourceByType((pointer *) &pCmap,
                                        pScreen->defColormap, RT_COLORMAP,
                                        serverClient, DixUseAccess);

            XSetWindowColormap(xnestDisplay,
                               xnestDefaultWindows[pScreen->myNum],
                               xnestColormap(pCmap));
        }
#endif                          /* DUMB_WINDOW_MANAGERS */
    }
    else
        free(icws.windows);
}

void
xnestSetScreenSaverColormapWindow(ScreenPtr pScreen)
{
    free(xnestOldInstalledColormapWindows);

#ifdef _XSERVER64
    {
        Window64 window;

        window = xnestScreenSaverWindows[pScreen->myNum];
        XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
                              &window, 1);
        xnestScreenSaverWindows[pScreen->myNum] = window;
    }
#else
    XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
                          &xnestScreenSaverWindows[pScreen->myNum], 1);
#endif                          /* _XSERVER64 */

    xnestOldInstalledColormapWindows = NULL;
    xnestNumOldInstalledColormapWindows = 0;

    xnestDirectUninstallColormaps(pScreen);
}

void
xnestDirectInstallColormaps(ScreenPtr pScreen)
{
    int i, n;
    Colormap pCmapIDs[MAXCMAPS];

    if (!xnestDoDirectColormaps)
        return;

    n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);

    for (i = 0; i < n; i++) {
        ColormapPtr pCmap;

        dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
                                serverClient, DixInstallAccess);
        if (pCmap)
            XInstallColormap(xnestDisplay, xnestColormap(pCmap));
    }
}

void
xnestDirectUninstallColormaps(ScreenPtr pScreen)
{
    int i, n;
    Colormap pCmapIDs[MAXCMAPS];

    if (!xnestDoDirectColormaps)
        return;

    n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);

    for (i = 0; i < n; i++) {
        ColormapPtr pCmap;

        dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
                                serverClient, DixUninstallAccess);
        if (pCmap)
            XUninstallColormap(xnestDisplay, xnestColormap(pCmap));
    }
}

void
xnestInstallColormap(ColormapPtr pCmap)
{
    ColormapPtr pOldCmap = GetInstalledColormap(pCmap->pScreen);

    if (pCmap != pOldCmap) {
        xnestDirectUninstallColormaps(pCmap->pScreen);

        /* Uninstall pInstalledMap. Notify all interested parties. */
        if (pOldCmap != (ColormapPtr) None)
            WalkTree(pCmap->pScreen, TellLostMap, (pointer) &pOldCmap->mid);

        SetInstalledColormap(pCmap->pScreen, pCmap);
        WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &pCmap->mid);

        xnestSetInstalledColormapWindows(pCmap->pScreen);
        xnestDirectInstallColormaps(pCmap->pScreen);
    }
}

void
xnestUninstallColormap(ColormapPtr pCmap)
{
    ColormapPtr pCurCmap = GetInstalledColormap(pCmap->pScreen);

    if (pCmap == pCurCmap) {
        if (pCmap->mid != pCmap->pScreen->defColormap) {
            dixLookupResourceByType((pointer *) &pCurCmap,
                                    pCmap->pScreen->defColormap,
                                    RT_COLORMAP,
                                    serverClient, DixInstallAccess);
            (*pCmap->pScreen->InstallColormap) (pCurCmap);
        }
    }
}

static Bool xnestInstalledDefaultColormap = False;

int
xnestListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmapIDs)
{
    if (xnestInstalledDefaultColormap) {
        *pCmapIDs = GetInstalledColormap(pScreen)->mid;
        return 1;
    }
    else
        return 0;
}

void
xnestStoreColors(ColormapPtr pCmap, int nColors, xColorItem * pColors)
{
    if (pCmap->pVisual->class & DynamicClass)
#ifdef _XSERVER64
    {
        int i;
        XColor *pColors64 = (XColor *) malloc(nColors * sizeof(XColor));

        for (i = 0; i < nColors; ++i) {
            pColors64[i].pixel = pColors[i].pixel;
            pColors64[i].red = pColors[i].red;
            pColors64[i].green = pColors[i].green;
            pColors64[i].blue = pColors[i].blue;
            pColors64[i].flags = pColors[i].flags;
        }
        XStoreColors(xnestDisplay, xnestColormap(pCmap), pColors64, nColors);
        free(pColors64);
    }
#else
        XStoreColors(xnestDisplay, xnestColormap(pCmap),
                     (XColor *) pColors, nColors);
#endif
}

void
xnestResolveColor(unsigned short *pRed, unsigned short *pGreen,
                  unsigned short *pBlue, VisualPtr pVisual)
{
    int shift;
    unsigned int lim;

    shift = 16 - pVisual->bitsPerRGBValue;
    lim = (1 << pVisual->bitsPerRGBValue) - 1;

    if ((pVisual->class == PseudoColor) || (pVisual->class == DirectColor)) {
        /* rescale to rgb bits */
        *pRed = ((*pRed >> shift) * 65535) / lim;
        *pGreen = ((*pGreen >> shift) * 65535) / lim;
        *pBlue = ((*pBlue >> shift) * 65535) / lim;
    }
    else if (pVisual->class == GrayScale) {
        /* rescale to gray then rgb bits */
        *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;
        *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;
    }
    else if (pVisual->class == StaticGray) {
        unsigned int limg;

        limg = pVisual->ColormapEntries - 1;
        /* rescale to gray then [0..limg] then [0..65535] then rgb bits */
        *pRed = (30L * *pRed + 59L * *pGreen + 11L * *pBlue) / 100;
        *pRed = ((((*pRed * (limg + 1))) >> 16) * 65535) / limg;
        *pBlue = *pGreen = *pRed = ((*pRed >> shift) * 65535) / lim;
    }
    else {
        unsigned limr, limg, limb;

        limr = pVisual->redMask >> pVisual->offsetRed;
        limg = pVisual->greenMask >> pVisual->offsetGreen;
        limb = pVisual->blueMask >> pVisual->offsetBlue;
        /* rescale to [0..limN] then [0..65535] then rgb bits */
        *pRed = ((((((*pRed * (limr + 1)) >> 16) *
                    65535) / limr) >> shift) * 65535) / lim;
        *pGreen = ((((((*pGreen * (limg + 1)) >> 16) *
                      65535) / limg) >> shift) * 65535) / lim;
        *pBlue = ((((((*pBlue * (limb + 1)) >> 16) *
                     65535) / limb) >> shift) * 65535) / lim;
    }
}

Bool
xnestCreateDefaultColormap(ScreenPtr pScreen)
{
    VisualPtr pVisual;
    ColormapPtr pCmap;
    unsigned short zero = 0, ones = 0xFFFF;
    Pixel wp, bp;

    if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))
        return FALSE;

    for (pVisual = pScreen->visuals;
         pVisual->vid != pScreen->rootVisual; pVisual++);

    if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &pCmap,
                       (pVisual->class & DynamicClass) ? AllocNone : AllocAll,
                       0)
        != Success)
        return False;

    wp = pScreen->whitePixel;
    bp = pScreen->blackPixel;
    if ((AllocColor(pCmap, &ones, &ones, &ones, &wp, 0) !=
         Success) ||
        (AllocColor(pCmap, &zero, &zero, &zero, &bp, 0) != Success))
        return FALSE;
    pScreen->whitePixel = wp;
    pScreen->blackPixel = bp;
    (*pScreen->InstallColormap) (pCmap);

    xnestInstalledDefaultColormap = True;

    return True;
}
Commit	Line	Data
a09e091a JB	1	/*
	2
	3	Copyright 1993 by Davor Matic
	4
	5	Permission to use, copy, modify, distribute, and sell this software
	6	and its documentation for any purpose is hereby granted without fee,
	7	provided that the above copyright notice appear in all copies and that
	8	both that copyright notice and this permission notice appear in
	9	supporting documentation. Davor Matic makes no representations about
	10	the suitability of this software for any purpose. It is provided "as
	11	is" without express or implied warranty.
	12
	13	*/
	14
	15	#ifdef HAVE_XNEST_CONFIG_H
	16	#include <xnest-config.h>
	17	#endif
	18
	19	#include <X11/X.h>
	20	#include <X11/Xproto.h>
	21	#include "scrnintstr.h"
	22	#include "window.h"
	23	#include "windowstr.h"
	24	#include "colormapst.h"
	25	#include "resource.h"
	26
	27	#include "Xnest.h"
	28
	29	#include "Display.h"
	30	#include "Screen.h"
	31	#include "Color.h"
	32	#include "Visual.h"
	33	#include "XNWindow.h"
	34	#include "Args.h"
	35
	36	DevPrivateKeyRec xnestColormapPrivateKeyRec;
	37
	38	static DevPrivateKeyRec cmapScrPrivateKeyRec;
	39
	40	#define cmapScrPrivateKey (&cmapScrPrivateKeyRec)
	41
	42	#define GetInstalledColormap(s) ((ColormapPtr) dixLookupPrivate(&(s)->devPrivates, cmapScrPrivateKey))
	43	#define SetInstalledColormap(s,c) (dixSetPrivate(&(s)->devPrivates, cmapScrPrivateKey, c))
	44
	45	Bool
	46	xnestCreateColormap(ColormapPtr pCmap)
	47	{
	48	VisualPtr pVisual;
	49	XColor *colors;
	50	int i, ncolors;
	51	Pixel red, green, blue;
	52	Pixel redInc, greenInc, blueInc;
	53
	54	pVisual = pCmap->pVisual;
	55	ncolors = pVisual->ColormapEntries;
	56
	57	xnestColormapPriv(pCmap)->colormap =
	58	XCreateColormap(xnestDisplay,
	59	xnestDefaultWindows[pCmap->pScreen->myNum],
	60	xnestVisual(pVisual),
	61	(pVisual->class & DynamicClass) ? AllocAll : AllocNone);
	62
	63	switch (pVisual->class) {
	64	case StaticGray: /* read only */
65	colors = (XColor ) malloc(ncolors sizeof(XColor));
66	for (i = 0; i < ncolors; i++)
67	colors[i].pixel = i;
68	XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
69	for (i = 0; i < ncolors; i++) {
70	pCmap->red[i].co.local.red = colors[i].red;
71	pCmap->red[i].co.local.green = colors[i].red;
72	pCmap->red[i].co.local.blue = colors[i].red;
73	}
74	free(colors);
75	break;
76
77	case StaticColor: /* read only */
78	colors = (XColor ) malloc(ncolors sizeof(XColor));
79	for (i = 0; i < ncolors; i++)
80	colors[i].pixel = i;
81	XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
82	for (i = 0; i < ncolors; i++) {
83	pCmap->red[i].co.local.red = colors[i].red;
84	pCmap->red[i].co.local.green = colors[i].green;
85	pCmap->red[i].co.local.blue = colors[i].blue;
86	}
87	free(colors);
88	break;
89
90	case TrueColor: /* read only */
91	colors = (XColor ) malloc(ncolors sizeof(XColor));
92	red = green = blue = 0L;
93	redInc = lowbit(pVisual->redMask);
94	greenInc = lowbit(pVisual->greenMask);
95	blueInc = lowbit(pVisual->blueMask);
96	for (i = 0; i < ncolors; i++) {
97	colors[i].pixel = red \| green \| blue;
98	red += redInc;
99	if (red > pVisual->redMask)
100	red = 0L;
101	green += greenInc;
102	if (green > pVisual->greenMask)
103	green = 0L;
104	blue += blueInc;
105	if (blue > pVisual->blueMask)
106	blue = 0L;
107	}
108	XQueryColors(xnestDisplay, xnestColormap(pCmap), colors, ncolors);
109	for (i = 0; i < ncolors; i++) {
110	pCmap->red[i].co.local.red = colors[i].red;
111	pCmap->green[i].co.local.green = colors[i].green;
112	pCmap->blue[i].co.local.blue = colors[i].blue;
113	}
114	free(colors);
115	break;
116
117	case GrayScale: /* read and write */
118	break;
119
120	case PseudoColor: /* read and write */
121	break;
122
123	case DirectColor: /* read and write */
124	break;
125	}
126
127	return True;
128	}
129
130	void
131	xnestDestroyColormap(ColormapPtr pCmap)
132	{
133	XFreeColormap(xnestDisplay, xnestColormap(pCmap));
134	}
135
136	#define SEARCH_PREDICATE \
137	(xnestWindow(pWin) != None && wColormap(pWin) == icws->cmapIDs[i])
138
139	static int
140	xnestCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)
141	{
142	xnestInstalledColormapWindows icws = (xnestInstalledColormapWindows ) ptr;
143	int i;
144
145	for (i = 0; i < icws->numCmapIDs; i++)
146	if (SEARCH_PREDICATE) {
147	icws->numWindows++;
148	return WT_DONTWALKCHILDREN;
149	}
150
151	return WT_WALKCHILDREN;
152	}
153
154	static int
155	xnestGetInstalledColormapWindows(WindowPtr pWin, pointer ptr)
156	{
157	xnestInstalledColormapWindows icws = (xnestInstalledColormapWindows ) ptr;
158	int i;
159
160	for (i = 0; i < icws->numCmapIDs; i++)
161	if (SEARCH_PREDICATE) {
162	icws->windows[icws->index++] = xnestWindow(pWin);
163	return WT_DONTWALKCHILDREN;
164	}
165
166	return WT_WALKCHILDREN;
167	}
168
169	static Window *xnestOldInstalledColormapWindows = NULL;
170	static int xnestNumOldInstalledColormapWindows = 0;
171
172	static Bool
173	xnestSameInstalledColormapWindows(Window *windows, int numWindows)
174	{
175	if (xnestNumOldInstalledColormapWindows != numWindows)
176	return False;
177
178	if (xnestOldInstalledColormapWindows == windows)
179	return True;
180
181	if (xnestOldInstalledColormapWindows == NULL \|\| windows == NULL)
182	return False;
183
184	if (memcmp(xnestOldInstalledColormapWindows, windows,
185	numWindows * sizeof(Window)))
186	return False;
187
188	return True;
189	}
190
191	void
192	xnestSetInstalledColormapWindows(ScreenPtr pScreen)
193	{
194	xnestInstalledColormapWindows icws;
195	int numWindows;
196
197	icws.cmapIDs = (Colormap ) malloc(pScreen->maxInstalledCmaps
198	sizeof(Colormap));
199	icws.numCmapIDs = xnestListInstalledColormaps(pScreen, icws.cmapIDs);
200	icws.numWindows = 0;
201	WalkTree(pScreen, xnestCountInstalledColormapWindows, (pointer) &icws);
202	if (icws.numWindows) {
203	icws.windows =
204	(Window ) malloc((icws.numWindows + 1) sizeof(Window));
205	icws.index = 0;
206	WalkTree(pScreen, xnestGetInstalledColormapWindows, (pointer) &icws);
207	icws.windows[icws.numWindows] = xnestDefaultWindows[pScreen->myNum];
208	numWindows = icws.numWindows + 1;
209	}
210	else {
211	icws.windows = NULL;
212	numWindows = 0;
213	}
214
215	free(icws.cmapIDs);
216
217	if (!xnestSameInstalledColormapWindows(icws.windows, icws.numWindows)) {
218	free(xnestOldInstalledColormapWindows);
219
220	#ifdef _XSERVER64
221	{
222	int i;
223	Window64 *windows =
224	(Window64 ) malloc(numWindows sizeof(Window64));
225
226	for (i = 0; i < numWindows; ++i)
227	windows[i] = icws.windows[i];
228	XSetWMColormapWindows(xnestDisplay,
229	xnestDefaultWindows[pScreen->myNum], windows,
230	numWindows);
231	free(windows);
232	}
233	#else
234	XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
235	icws.windows, numWindows);
236	#endif
237
238	xnestOldInstalledColormapWindows = icws.windows;
239	xnestNumOldInstalledColormapWindows = icws.numWindows;
240
241	#ifdef DUMB_WINDOW_MANAGERS
242	/*
243	This code is for dumb window managers.
244	This will only work with default local visual colormaps.
245	*/
246	if (icws.numWindows) {
247	WindowPtr pWin;
248	Visual *visual;
249	ColormapPtr pCmap;
250
251	pWin = xnestWindowPtr(icws.windows[0]);
252	visual = xnestVisualFromID(pScreen, wVisual(pWin));
253
254	if (visual == xnestDefaultVisual(pScreen))
255	dixLookupResourceByType((pointer *) &pCmap, wColormap(pWin),
256	RT_COLORMAP, serverClient,
257	DixUseAccess);
258	else
259	dixLookupResourceByType((pointer *) &pCmap,
260	pScreen->defColormap, RT_COLORMAP,
261	serverClient, DixUseAccess);
262
263	XSetWindowColormap(xnestDisplay,
264	xnestDefaultWindows[pScreen->myNum],
265	xnestColormap(pCmap));
266	}
267	#endif /* DUMB_WINDOW_MANAGERS */
268	}
269	else
270	free(icws.windows);
271	}
272
273	void
274	xnestSetScreenSaverColormapWindow(ScreenPtr pScreen)
275	{
276	free(xnestOldInstalledColormapWindows);
277
278	#ifdef _XSERVER64
279	{
280	Window64 window;
281
282	window = xnestScreenSaverWindows[pScreen->myNum];
283	XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
284	&window, 1);
285	xnestScreenSaverWindows[pScreen->myNum] = window;
286	}
287	#else
288	XSetWMColormapWindows(xnestDisplay, xnestDefaultWindows[pScreen->myNum],
289	&xnestScreenSaverWindows[pScreen->myNum], 1);
290	#endif /* _XSERVER64 */
291
292	xnestOldInstalledColormapWindows = NULL;
293	xnestNumOldInstalledColormapWindows = 0;
294
295	xnestDirectUninstallColormaps(pScreen);
296	}
297
298	void
299	xnestDirectInstallColormaps(ScreenPtr pScreen)
300	{
301	int i, n;
302	Colormap pCmapIDs[MAXCMAPS];
303
304	if (!xnestDoDirectColormaps)
305	return;
306
307	n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);
308
309	for (i = 0; i < n; i++) {
310	ColormapPtr pCmap;
311
312	dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
313	serverClient, DixInstallAccess);
314	if (pCmap)
315	XInstallColormap(xnestDisplay, xnestColormap(pCmap));
316	}
317	}
318
319	void
320	xnestDirectUninstallColormaps(ScreenPtr pScreen)
321	{
322	int i, n;
323	Colormap pCmapIDs[MAXCMAPS];
324
325	if (!xnestDoDirectColormaps)
326	return;
327
328	n = (*pScreen->ListInstalledColormaps) (pScreen, pCmapIDs);
329
330	for (i = 0; i < n; i++) {
331	ColormapPtr pCmap;
332
333	dixLookupResourceByType((pointer *) &pCmap, pCmapIDs[i], RT_COLORMAP,
334	serverClient, DixUninstallAccess);
335	if (pCmap)
336	XUninstallColormap(xnestDisplay, xnestColormap(pCmap));
337	}
338	}
339
340	void
341	xnestInstallColormap(ColormapPtr pCmap)
342	{
343	ColormapPtr pOldCmap = GetInstalledColormap(pCmap->pScreen);
344
345	if (pCmap != pOldCmap) {
346	xnestDirectUninstallColormaps(pCmap->pScreen);
347
348	/* Uninstall pInstalledMap. Notify all interested parties. */
349	if (pOldCmap != (ColormapPtr) None)
350	WalkTree(pCmap->pScreen, TellLostMap, (pointer) &pOldCmap->mid);
351
352	SetInstalledColormap(pCmap->pScreen, pCmap);
353	WalkTree(pCmap->pScreen, TellGainedMap, (pointer) &pCmap->mid);
354
355	xnestSetInstalledColormapWindows(pCmap->pScreen);
356	xnestDirectInstallColormaps(pCmap->pScreen);
357	}
358	}
359
360	void
361	xnestUninstallColormap(ColormapPtr pCmap)
362	{
363	ColormapPtr pCurCmap = GetInstalledColormap(pCmap->pScreen);
364
365	if (pCmap == pCurCmap) {
366	if (pCmap->mid != pCmap->pScreen->defColormap) {
367	dixLookupResourceByType((pointer *) &pCurCmap,
368	pCmap->pScreen->defColormap,
369	RT_COLORMAP,
370	serverClient, DixInstallAccess);
371	(*pCmap->pScreen->InstallColormap) (pCurCmap);
372	}
373	}
374	}
375
376	static Bool xnestInstalledDefaultColormap = False;
377
378	int
379	xnestListInstalledColormaps(ScreenPtr pScreen, Colormap * pCmapIDs)
380	{
381	if (xnestInstalledDefaultColormap) {
382	*pCmapIDs = GetInstalledColormap(pScreen)->mid;
383	return 1;
384	}
385	else
386	return 0;
387	}
388
389	void
390	xnestStoreColors(ColormapPtr pCmap, int nColors, xColorItem * pColors)
391	{
392	if (pCmap->pVisual->class & DynamicClass)
393	#ifdef _XSERVER64
394	{
395	int i;
396	XColor pColors64 = (XColor ) malloc(nColors * sizeof(XColor));
397
398	for (i = 0; i < nColors; ++i) {
399	pColors64[i].pixel = pColors[i].pixel;
400	pColors64[i].red = pColors[i].red;
401	pColors64[i].green = pColors[i].green;
402	pColors64[i].blue = pColors[i].blue;
403	pColors64[i].flags = pColors[i].flags;
404	}
405	XStoreColors(xnestDisplay, xnestColormap(pCmap), pColors64, nColors);
406	free(pColors64);
407	}
408	#else
409	XStoreColors(xnestDisplay, xnestColormap(pCmap),
410	(XColor *) pColors, nColors);
411	#endif
412	}
413
414	void
415	xnestResolveColor(unsigned short pRed, unsigned short pGreen,
416	unsigned short *pBlue, VisualPtr pVisual)
417	{
418	int shift;
419	unsigned int lim;
420
421	shift = 16 - pVisual->bitsPerRGBValue;
422	lim = (1 << pVisual->bitsPerRGBValue) - 1;
423
424	if ((pVisual->class == PseudoColor) \|\| (pVisual->class == DirectColor)) {
425	/* rescale to rgb bits */
426	pRed = ((pRed >> shift) * 65535) / lim;
427	pGreen = ((pGreen >> shift) * 65535) / lim;
428	pBlue = ((pBlue >> shift) * 65535) / lim;
429	}
430	else if (pVisual->class == GrayScale) {
431	/* rescale to gray then rgb bits */
432	pRed = (30L pRed + 59L pGreen + 11L *pBlue) / 100;
433	pBlue = pGreen = pRed = ((pRed >> shift) * 65535) / lim;
434	}
435	else if (pVisual->class == StaticGray) {
436	unsigned int limg;
437
438	limg = pVisual->ColormapEntries - 1;
439	/* rescale to gray then [0..limg] then [0..65535] then rgb bits */
440	pRed = (30L pRed + 59L pGreen + 11L *pBlue) / 100;
441	pRed = ((((pRed * (limg + 1))) >> 16) * 65535) / limg;
442	pBlue = pGreen = pRed = ((pRed >> shift) * 65535) / lim;
443	}
444	else {
445	unsigned limr, limg, limb;
446
447	limr = pVisual->redMask >> pVisual->offsetRed;
448	limg = pVisual->greenMask >> pVisual->offsetGreen;
449	limb = pVisual->blueMask >> pVisual->offsetBlue;
450	/* rescale to [0..limN] then [0..65535] then rgb bits */
451	pRed = ((((((pRed * (limr + 1)) >> 16) *
452	65535) / limr) >> shift) * 65535) / lim;
453	pGreen = ((((((pGreen * (limg + 1)) >> 16) *
454	65535) / limg) >> shift) * 65535) / lim;
455	pBlue = ((((((pBlue * (limb + 1)) >> 16) *
456	65535) / limb) >> shift) * 65535) / lim;
457	}
458	}
459
460	Bool
461	xnestCreateDefaultColormap(ScreenPtr pScreen)
462	{
463	VisualPtr pVisual;
464	ColormapPtr pCmap;
465	unsigned short zero = 0, ones = 0xFFFF;
466	Pixel wp, bp;
467
468	if (!dixRegisterPrivateKey(&cmapScrPrivateKeyRec, PRIVATE_SCREEN, 0))
469	return FALSE;
470
471	for (pVisual = pScreen->visuals;
472	pVisual->vid != pScreen->rootVisual; pVisual++);
473
474	if (CreateColormap(pScreen->defColormap, pScreen, pVisual, &pCmap,
475	(pVisual->class & DynamicClass) ? AllocNone : AllocAll,
476	0)
477	!= Success)
478	return False;
479
480	wp = pScreen->whitePixel;
481	bp = pScreen->blackPixel;
482	if ((AllocColor(pCmap, &ones, &ones, &ones, &wp, 0) !=
483	Success) \|\|
484	(AllocColor(pCmap, &zero, &zero, &zero, &bp, 0) != Success))
485	return FALSE;
486	pScreen->whitePixel = wp;
487	pScreen->blackPixel = bp;
488	(*pScreen->InstallColormap) (pCmap);
489
490	xnestInstalledDefaultColormap = True;
491
492	return True;
493	}