9838b7032e
This is strictly the application of the script 'x-indent-all.sh' from util/modular. Compared to the patch that Daniel posted in January, I've added a few indent flags: -bap -psl -T PrivatePtr -T pmWait -T _XFUNCPROTOBEGIN -T _XFUNCPROTOEND -T _X_EXPORT The typedefs were needed to make the output of sdksyms.sh match the previous output, otherwise, the code is formatted badly enough that sdksyms.sh generates incorrect output. The generated code was compared with the previous version and found to be essentially identical -- "assert" line numbers and BUILD_TIME were the only differences found. The comparison was done with this script: dir1=$1 dir2=$2 for dir in $dir1 $dir2; do (cd $dir && find . -name '*.o' | while read file; do dir=`dirname $file` base=`basename $file .o` dump=$dir/$base.dump objdump -d $file > $dump done) done find $dir1 -name '*.dump' | while read dump; do otherdump=`echo $dump | sed "s;$dir1;$dir2;"` diff -u $dump $otherdump done Signed-off-by: Keith Packard <keithp@keithp.com> Acked-by: Daniel Stone <daniel@fooishbar.org> Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
603 lines
18 KiB
C
603 lines
18 KiB
C
/*
|
|
*Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
|
|
*
|
|
*Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
*"Software"), to deal in the Software without restriction, including
|
|
*without limitation the rights to use, copy, modify, merge, publish,
|
|
*distribute, sublicense, and/or sell copies of the Software, and to
|
|
*permit persons to whom the Software is furnished to do so, subject to
|
|
*the following conditions:
|
|
*
|
|
*The above copyright notice and this permission notice shall be
|
|
*included in all copies or substantial portions of the Software.
|
|
*
|
|
*THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
*EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
*MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
*NONINFRINGEMENT. IN NO EVENT SHALL THE XFREE86 PROJECT BE LIABLE FOR
|
|
*ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
|
|
*CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
*WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*Except as contained in this notice, the name of the XFree86 Project
|
|
*shall not be used in advertising or otherwise to promote the sale, use
|
|
*or other dealings in this Software without prior written authorization
|
|
*from the XFree86 Project.
|
|
*
|
|
* Authors: Dakshinamurthy Karra
|
|
* Suhaib M Siddiqi
|
|
* Peter Busch
|
|
* Harold L Hunt II
|
|
*/
|
|
|
|
#ifdef HAVE_XWIN_CONFIG_H
|
|
#include <xwin-config.h>
|
|
#endif
|
|
#include "win.h"
|
|
|
|
/*
|
|
* Local prototypes
|
|
*/
|
|
|
|
static int
|
|
winListInstalledColormaps(ScreenPtr pScreen, Colormap * pmaps);
|
|
|
|
static void
|
|
winStoreColors(ColormapPtr pmap, int ndef, xColorItem * pdefs);
|
|
|
|
static void
|
|
winInstallColormap(ColormapPtr pmap);
|
|
|
|
static void
|
|
winUninstallColormap(ColormapPtr pmap);
|
|
|
|
static void
|
|
|
|
winResolveColor(unsigned short *pred,
|
|
unsigned short *pgreen,
|
|
unsigned short *pblue, VisualPtr pVisual);
|
|
|
|
static Bool
|
|
winCreateColormap(ColormapPtr pmap);
|
|
|
|
static void
|
|
winDestroyColormap(ColormapPtr pmap);
|
|
|
|
static Bool
|
|
winGetPaletteDIB(ScreenPtr pScreen, ColormapPtr pcmap);
|
|
|
|
static Bool
|
|
winGetPaletteDD(ScreenPtr pScreen, ColormapPtr pcmap);
|
|
|
|
/*
|
|
* Set screen functions for colormaps
|
|
*/
|
|
|
|
void
|
|
winSetColormapFunctions(ScreenPtr pScreen)
|
|
{
|
|
pScreen->CreateColormap = winCreateColormap;
|
|
pScreen->DestroyColormap = winDestroyColormap;
|
|
pScreen->InstallColormap = winInstallColormap;
|
|
pScreen->UninstallColormap = winUninstallColormap;
|
|
pScreen->ListInstalledColormaps = winListInstalledColormaps;
|
|
pScreen->StoreColors = winStoreColors;
|
|
pScreen->ResolveColor = winResolveColor;
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 30 */
|
|
/*
|
|
* Walk the list of installed colormaps, filling the pmaps list
|
|
* with the resource ids of the installed maps, and return
|
|
* a count of the total number of installed maps.
|
|
*/
|
|
static int
|
|
winListInstalledColormaps(ScreenPtr pScreen, Colormap * pmaps)
|
|
{
|
|
winScreenPriv(pScreen);
|
|
|
|
/*
|
|
* There will only be one installed colormap, so we only need
|
|
* to return one id, and the count of installed maps will always
|
|
* be one.
|
|
*/
|
|
*pmaps = pScreenPriv->pcmapInstalled->mid;
|
|
return 1;
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 30 */
|
|
/* See Programming Windows - p. 663 */
|
|
static void
|
|
winInstallColormap(ColormapPtr pColormap)
|
|
{
|
|
ScreenPtr pScreen = pColormap->pScreen;
|
|
|
|
winScreenPriv(pScreen);
|
|
ColormapPtr oldpmap = pScreenPriv->pcmapInstalled;
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winInstallColormap\n");
|
|
#endif
|
|
|
|
/* Did the colormap actually change? */
|
|
if (pColormap != oldpmap) {
|
|
#if CYGDEBUG
|
|
winDebug("winInstallColormap - Colormap has changed, attempt "
|
|
"to install.\n");
|
|
#endif
|
|
|
|
/* Was there a previous colormap? */
|
|
if (oldpmap != (ColormapPtr) None) {
|
|
/* There was a previous colormap; tell clients it is gone */
|
|
WalkTree(pColormap->pScreen, TellLostMap, (char *) &oldpmap->mid);
|
|
}
|
|
|
|
/* Install new colormap */
|
|
pScreenPriv->pcmapInstalled = pColormap;
|
|
WalkTree(pColormap->pScreen, TellGainedMap, (char *) &pColormap->mid);
|
|
|
|
/* Call the engine specific colormap install procedure */
|
|
if (!((*pScreenPriv->pwinInstallColormap) (pColormap))) {
|
|
winErrorFVerb(2,
|
|
"winInstallColormap - Screen specific colormap install "
|
|
"procedure failed. Continuing, but colors may be "
|
|
"messed up from now on.\n");
|
|
}
|
|
}
|
|
|
|
/* Save a pointer to the newly installed colormap */
|
|
pScreenPriv->pcmapInstalled = pColormap;
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 30 */
|
|
static void
|
|
winUninstallColormap(ColormapPtr pmap)
|
|
{
|
|
winScreenPriv(pmap->pScreen);
|
|
ColormapPtr curpmap = pScreenPriv->pcmapInstalled;
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winUninstallColormap\n");
|
|
#endif
|
|
|
|
/* Is the colormap currently installed? */
|
|
if (pmap != curpmap) {
|
|
/* Colormap not installed, nothing to do */
|
|
return;
|
|
}
|
|
|
|
/* Clear the installed colormap flag */
|
|
pScreenPriv->pcmapInstalled = NULL;
|
|
|
|
/*
|
|
* NOTE: The default colormap does not get "uninstalled" before
|
|
* it is destroyed.
|
|
*/
|
|
|
|
/* Install the default cmap in place of the cmap to be uninstalled */
|
|
if (pmap->mid != pmap->pScreen->defColormap) {
|
|
dixLookupResourceByType((pointer) &curpmap, pmap->pScreen->defColormap,
|
|
RT_COLORMAP, NullClient, DixUnknownAccess);
|
|
(*pmap->pScreen->InstallColormap) (curpmap);
|
|
}
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 30 */
|
|
static void
|
|
winStoreColors(ColormapPtr pmap, int ndef, xColorItem * pdefs)
|
|
{
|
|
ScreenPtr pScreen = pmap->pScreen;
|
|
|
|
winScreenPriv(pScreen);
|
|
winCmapPriv(pmap);
|
|
int i;
|
|
unsigned short nRed, nGreen, nBlue;
|
|
|
|
#if CYGDEBUG
|
|
if (ndef != 1)
|
|
winDebug("winStoreColors - ndef: %d\n", ndef);
|
|
#endif
|
|
|
|
/* Save the new colors in the colormap privates */
|
|
for (i = 0; i < ndef; ++i) {
|
|
/* Adjust the colors from the X color spec to the Windows color spec */
|
|
nRed = pdefs[i].red >> 8;
|
|
nGreen = pdefs[i].green >> 8;
|
|
nBlue = pdefs[i].blue >> 8;
|
|
|
|
/* Copy the colors to a palette entry table */
|
|
pCmapPriv->peColors[pdefs[0].pixel + i].peRed = nRed;
|
|
pCmapPriv->peColors[pdefs[0].pixel + i].peGreen = nGreen;
|
|
pCmapPriv->peColors[pdefs[0].pixel + i].peBlue = nBlue;
|
|
|
|
/* Copy the colors to a RGBQUAD table */
|
|
pCmapPriv->rgbColors[pdefs[0].pixel + i].rgbRed = nRed;
|
|
pCmapPriv->rgbColors[pdefs[0].pixel + i].rgbGreen = nGreen;
|
|
pCmapPriv->rgbColors[pdefs[0].pixel + i].rgbBlue = nBlue;
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winStoreColors - nRed %d nGreen %d nBlue %d\n",
|
|
nRed, nGreen, nBlue);
|
|
#endif
|
|
}
|
|
|
|
/* Call the engine specific store colors procedure */
|
|
if (!((pScreenPriv->pwinStoreColors) (pmap, ndef, pdefs))) {
|
|
winErrorFVerb(2,
|
|
"winStoreColors - Engine cpecific color storage procedure "
|
|
"failed. Continuing, but colors may be messed up from now "
|
|
"on.\n");
|
|
}
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 30 */
|
|
static void
|
|
winResolveColor(unsigned short *pred,
|
|
unsigned short *pgreen,
|
|
unsigned short *pblue, VisualPtr pVisual)
|
|
{
|
|
#if CYGDEBUG
|
|
winDebug("winResolveColor ()\n");
|
|
#endif
|
|
|
|
miResolveColor(pred, pgreen, pblue, pVisual);
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 29 */
|
|
static Bool
|
|
winCreateColormap(ColormapPtr pmap)
|
|
{
|
|
winPrivCmapPtr pCmapPriv = NULL;
|
|
ScreenPtr pScreen = pmap->pScreen;
|
|
|
|
winScreenPriv(pScreen);
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winCreateColormap\n");
|
|
#endif
|
|
|
|
/* Allocate colormap privates */
|
|
if (!winAllocateCmapPrivates(pmap)) {
|
|
ErrorF("winCreateColorma - Couldn't allocate cmap privates\n");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Get a pointer to the newly allocated privates */
|
|
pCmapPriv = winGetCmapPriv(pmap);
|
|
|
|
/*
|
|
* FIXME: This is some evil hackery to help in handling some X clients
|
|
* that expect the top pixel to be white. This "help" only lasts until
|
|
* some client overwrites the top colormap entry.
|
|
*
|
|
* We don't want to actually allocate the top entry, as that causes
|
|
* problems with X clients that need 7 planes (128 colors) in the default
|
|
* colormap, such as Magic 7.1.
|
|
*/
|
|
pCmapPriv->rgbColors[WIN_NUM_PALETTE_ENTRIES - 1].rgbRed = 255;
|
|
pCmapPriv->rgbColors[WIN_NUM_PALETTE_ENTRIES - 1].rgbGreen = 255;
|
|
pCmapPriv->rgbColors[WIN_NUM_PALETTE_ENTRIES - 1].rgbBlue = 255;
|
|
pCmapPriv->peColors[WIN_NUM_PALETTE_ENTRIES - 1].peRed = 255;
|
|
pCmapPriv->peColors[WIN_NUM_PALETTE_ENTRIES - 1].peGreen = 255;
|
|
pCmapPriv->peColors[WIN_NUM_PALETTE_ENTRIES - 1].peBlue = 255;
|
|
|
|
/* Call the engine specific colormap initialization procedure */
|
|
if (!((*pScreenPriv->pwinCreateColormap) (pmap))) {
|
|
ErrorF("winCreateColormap - Engine specific colormap creation "
|
|
"procedure failed. Aborting.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* See Porting Layer Definition - p. 29, 30 */
|
|
static void
|
|
winDestroyColormap(ColormapPtr pColormap)
|
|
{
|
|
winScreenPriv(pColormap->pScreen);
|
|
winCmapPriv(pColormap);
|
|
|
|
/* Call the engine specific colormap destruction procedure */
|
|
if (!((*pScreenPriv->pwinDestroyColormap) (pColormap))) {
|
|
winErrorFVerb(2,
|
|
"winDestroyColormap - Engine specific colormap destruction "
|
|
"procedure failed. Continuing, but it is possible that memory "
|
|
"was leaked, or that colors will be messed up from now on.\n");
|
|
}
|
|
|
|
/* Free the colormap privates */
|
|
free(pCmapPriv);
|
|
winSetCmapPriv(pColormap, NULL);
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winDestroyColormap - Returning\n");
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Internal function to load the palette used by the Shadow DIB
|
|
*/
|
|
|
|
static Bool
|
|
winGetPaletteDIB(ScreenPtr pScreen, ColormapPtr pcmap)
|
|
{
|
|
winScreenPriv(pScreen);
|
|
int i;
|
|
Pixel pixel; /* Pixel == CARD32 */
|
|
CARD16 nRed, nGreen, nBlue; /* CARD16 == unsigned short */
|
|
UINT uiColorsRetrieved = 0;
|
|
RGBQUAD rgbColors[WIN_NUM_PALETTE_ENTRIES];
|
|
|
|
/* Get the color table for the screen */
|
|
uiColorsRetrieved = GetDIBColorTable(pScreenPriv->hdcScreen,
|
|
0, WIN_NUM_PALETTE_ENTRIES, rgbColors);
|
|
if (uiColorsRetrieved == 0) {
|
|
ErrorF("winGetPaletteDIB - Could not retrieve screen color table\n");
|
|
return FALSE;
|
|
}
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winGetPaletteDIB - Retrieved %d colors from DIB\n",
|
|
uiColorsRetrieved);
|
|
#endif
|
|
|
|
/* Set the DIB color table to the default screen palette */
|
|
if (SetDIBColorTable(pScreenPriv->hdcShadow,
|
|
0, uiColorsRetrieved, rgbColors) == 0) {
|
|
ErrorF("winGetPaletteDIB - SetDIBColorTable () failed\n");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Alloc each color in the DIB color table */
|
|
for (i = 0; i < uiColorsRetrieved; ++i) {
|
|
pixel = i;
|
|
|
|
/* Extract the color values for current palette entry */
|
|
nRed = rgbColors[i].rgbRed << 8;
|
|
nGreen = rgbColors[i].rgbGreen << 8;
|
|
nBlue = rgbColors[i].rgbBlue << 8;
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winGetPaletteDIB - Allocating a color: %d; "
|
|
"%d %d %d\n", pixel, nRed, nGreen, nBlue);
|
|
#endif
|
|
|
|
/* Allocate a entry in the X colormap */
|
|
if (AllocColor(pcmap, &nRed, &nGreen, &nBlue, &pixel, 0) != Success) {
|
|
ErrorF("winGetPaletteDIB - AllocColor () failed, pixel %d\n", i);
|
|
return FALSE;
|
|
}
|
|
|
|
if (i != pixel
|
|
|| nRed != rgbColors[i].rgbRed
|
|
|| nGreen != rgbColors[i].rgbGreen
|
|
|| nBlue != rgbColors[i].rgbBlue) {
|
|
winDebug("winGetPaletteDIB - Got: %d; "
|
|
"%d %d %d\n", (int) pixel, nRed, nGreen, nBlue);
|
|
}
|
|
|
|
/* FIXME: Not sure that this bit is needed at all */
|
|
pcmap->red[i].co.local.red = nRed;
|
|
pcmap->red[i].co.local.green = nGreen;
|
|
pcmap->red[i].co.local.blue = nBlue;
|
|
}
|
|
|
|
/* System is using a colormap */
|
|
/* Set the black and white pixel indices */
|
|
pScreen->whitePixel = uiColorsRetrieved - 1;
|
|
pScreen->blackPixel = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Internal function to load the standard system palette being used by DD
|
|
*/
|
|
|
|
static Bool
|
|
winGetPaletteDD(ScreenPtr pScreen, ColormapPtr pcmap)
|
|
{
|
|
int i;
|
|
Pixel pixel; /* Pixel == CARD32 */
|
|
CARD16 nRed, nGreen, nBlue; /* CARD16 == unsigned short */
|
|
UINT uiSystemPaletteEntries;
|
|
LPPALETTEENTRY ppeColors = NULL;
|
|
HDC hdc = NULL;
|
|
|
|
/* Get a DC to obtain the default palette */
|
|
hdc = GetDC(NULL);
|
|
if (hdc == NULL) {
|
|
ErrorF("winGetPaletteDD - Couldn't get a DC\n");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Get the number of entries in the system palette */
|
|
uiSystemPaletteEntries = GetSystemPaletteEntries(hdc, 0, 0, NULL);
|
|
if (uiSystemPaletteEntries == 0) {
|
|
ErrorF("winGetPaletteDD - Unable to determine number of "
|
|
"system palette entries\n");
|
|
return FALSE;
|
|
}
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winGetPaletteDD - uiSystemPaletteEntries %d\n",
|
|
uiSystemPaletteEntries);
|
|
#endif
|
|
|
|
/* Allocate palette entries structure */
|
|
ppeColors = malloc(uiSystemPaletteEntries * sizeof(PALETTEENTRY));
|
|
if (ppeColors == NULL) {
|
|
ErrorF("winGetPaletteDD - malloc () for colormap failed\n");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Get system palette entries */
|
|
GetSystemPaletteEntries(hdc, 0, uiSystemPaletteEntries, ppeColors);
|
|
|
|
/* Allocate an X colormap entry for every system palette entry */
|
|
for (i = 0; i < uiSystemPaletteEntries; ++i) {
|
|
pixel = i;
|
|
|
|
/* Extract the color values for current palette entry */
|
|
nRed = ppeColors[i].peRed << 8;
|
|
nGreen = ppeColors[i].peGreen << 8;
|
|
nBlue = ppeColors[i].peBlue << 8;
|
|
#if CYGDEBUG
|
|
winDebug("winGetPaletteDD - Allocating a color: %d; "
|
|
"%d %d %d\n", pixel, nRed, nGreen, nBlue);
|
|
#endif
|
|
if (AllocColor(pcmap, &nRed, &nGreen, &nBlue, &pixel, 0) != Success) {
|
|
ErrorF("winGetPaletteDD - AllocColor () failed, pixel %d\n", i);
|
|
free(ppeColors);
|
|
ppeColors = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
pcmap->red[i].co.local.red = nRed;
|
|
pcmap->red[i].co.local.green = nGreen;
|
|
pcmap->red[i].co.local.blue = nBlue;
|
|
}
|
|
|
|
/* System is using a colormap */
|
|
/* Set the black and white pixel indices */
|
|
pScreen->whitePixel = uiSystemPaletteEntries - 1;
|
|
pScreen->blackPixel = 0;
|
|
|
|
/* Free colormap */
|
|
free(ppeColors);
|
|
ppeColors = NULL;
|
|
|
|
/* Free the DC */
|
|
if (hdc != NULL) {
|
|
ReleaseDC(NULL, hdc);
|
|
hdc = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Install the standard fb colormap, or the GDI colormap,
|
|
* depending on the current screen depth.
|
|
*/
|
|
|
|
Bool
|
|
winCreateDefColormap(ScreenPtr pScreen)
|
|
{
|
|
winScreenPriv(pScreen);
|
|
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
|
|
unsigned short zero = 0, ones = 0xFFFF;
|
|
VisualPtr pVisual = pScreenPriv->pRootVisual;
|
|
ColormapPtr pcmap = NULL;
|
|
Pixel wp, bp;
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winCreateDefColormap\n");
|
|
#endif
|
|
|
|
/* Use standard fb colormaps for non palettized color modes */
|
|
if (pScreenInfo->dwBPP > 8) {
|
|
winDebug("winCreateDefColormap - Deferring to "
|
|
"fbCreateDefColormap ()\n");
|
|
return fbCreateDefColormap(pScreen);
|
|
}
|
|
|
|
/*
|
|
* AllocAll for non-Dynamic visual classes,
|
|
* AllocNone for Dynamic visual classes.
|
|
*/
|
|
|
|
/*
|
|
* Dynamic visual classes allow the colors of the color map
|
|
* to be changed by clients.
|
|
*/
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winCreateDefColormap - defColormap: %d\n", pScreen->defColormap);
|
|
#endif
|
|
|
|
/* Allocate an X colormap, owned by client 0 */
|
|
if (CreateColormap(pScreen->defColormap,
|
|
pScreen,
|
|
pVisual,
|
|
&pcmap,
|
|
(pVisual->class & DynamicClass) ? AllocNone : AllocAll,
|
|
0) != Success) {
|
|
ErrorF("winCreateDefColormap - CreateColormap failed\n");
|
|
return FALSE;
|
|
}
|
|
if (pcmap == NULL) {
|
|
ErrorF("winCreateDefColormap - Colormap could not be created\n");
|
|
return FALSE;
|
|
}
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winCreateDefColormap - Created a colormap\n");
|
|
#endif
|
|
|
|
/* Branch on the visual class */
|
|
if (!(pVisual->class & DynamicClass)) {
|
|
/* Branch on engine type */
|
|
if (pScreenInfo->dwEngine == WIN_SERVER_SHADOW_GDI) {
|
|
/* Load the colors being used by the Shadow DIB */
|
|
if (!winGetPaletteDIB(pScreen, pcmap)) {
|
|
ErrorF("winCreateDefColormap - Couldn't get DIB colors\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else {
|
|
/* Load the colors from the default system palette */
|
|
if (!winGetPaletteDD(pScreen, pcmap)) {
|
|
ErrorF("winCreateDefColormap - Couldn't get colors "
|
|
"for DD\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
wp = pScreen->whitePixel;
|
|
bp = pScreen->blackPixel;
|
|
|
|
/* Allocate a black and white pixel */
|
|
if ((AllocColor(pcmap, &ones, &ones, &ones, &wp, 0) != Success)
|
|
|| (AllocColor(pcmap, &zero, &zero, &zero, &bp, 0) != Success)) {
|
|
ErrorF("winCreateDefColormap - Couldn't allocate bp or wp\n");
|
|
return FALSE;
|
|
}
|
|
|
|
pScreen->whitePixel = wp;
|
|
pScreen->blackPixel = bp;
|
|
|
|
#if 0
|
|
/* Have to reserve first 10 and last ten pixels in DirectDraw windowed */
|
|
if (pScreenInfo->dwEngine != WIN_SERVER_SHADOW_GDI) {
|
|
int k;
|
|
Pixel p;
|
|
|
|
for (k = 1; k < 10; ++k) {
|
|
p = k;
|
|
if (AllocColor(pcmap, &ones, &ones, &ones, &p, 0) != Success)
|
|
FatalError("Foo!\n");
|
|
}
|
|
|
|
for (k = 245; k < 255; ++k) {
|
|
p = k;
|
|
if (AllocColor(pcmap, &zero, &zero, &zero, &p, 0) != Success)
|
|
FatalError("Baz!\n");
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* Install the created colormap */
|
|
(*pScreen->InstallColormap) (pcmap);
|
|
|
|
#if CYGDEBUG
|
|
winDebug("winCreateDefColormap - Returning\n");
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|