JAWT Support JDK >=1.3rel-2-5-2-0-test1

1 files changed, 655 insertions, 0 deletions

diff --git a/CNativeCode/OpenGL_Win32_common.c b/CNativeCode/OpenGL_Win32_common.c
new file mode 100755
index 0000000..8727ca4
--- /dev/null
+++ b/CNativeCode/OpenGL_Win32_common.c
@@ -0,0 +1,655 @@
+/*

+ * Original Author: Leo Chan -- 1995

+ *

+ * Adam King 1997

+ *		Ported to Win32 from X

+ *

+ * This file takes care of the C implementation of finding the correct

+ * Win32 window, assigning an OpenGL graphics context to it, storing that

+ * graphics context in the java class data structure.

+ *

+ * also contains the use() and swap() functions for double buffering

+ *

+ * September 12, 1997	- Adam King

+ *		- Added support for rendering directly into a Canvas ( BIG rewrite )

+ */

+

+#include "OpenGL_Win32_common.h"

+

+// Color Palette handle

+static HPALETTE hPalette = NULL;

+static HGLRC tempRC;

+

+

+HGLRC LIBAPIENTRY get_GC( HDC * hDC, jboolean doubleBuffer, 

+		jboolean stereo, jint stencilBits, HGLRC shareWith, 

+		jboolean offScreenRenderer,

+		int width, int height, HBITMAP *pix,

+		jboolean verbose)

+

+{

+	const char * text=0;

+	HDC hDCOrig = 0;

+

+

+        if( *hDC == 0 && !offScreenRenderer)

+		printf( "get_GC: Error, HDC is zero\n");

+

+	// Select the pixel format

+	if(offScreenRenderer)

+	{

+		hDCOrig = *hDC;

+		*hDC = CreateCompatibleDC(hDCOrig);

+		// setupDIB(*hDC, pix, width, height);

+		setupDIB(hDCOrig, *hDC, pix, width, height);

+		/* SetDCPixelFormat(hDCOffScr, doubleBuffer, stereo, stencilBits, offScreenRenderer); */

+		/* setupPalette(hDC); USE MY PROC */

+	}

+

+	SetDCPixelFormat(*hDC, doubleBuffer, stereo, stencilBits, offScreenRenderer, verbose);

+

+	// Create palette if needed

+	hPalette = GetOpenGLPalette(*hDC);

+

+    tempRC = wglCreateContext( *hDC );

+

+	if(verbose==JNI_TRUE)

+	{

+		fprintf(stderr,"\n\nPIXELFORMAT OF GL-Context SETTINGS:\n");

+		text=GetTextualPixelFormatByHDC(*hDC);

+		fprintf(stderr,text);

+	}

+

+    /* check if the context could be created */

+    if( tempRC == NULL ) {

+        fprintf(stderr, "getGC context could NOT be created \n");

+        return( 0 );

+    }

+

+    /* associated the context with the X window */

+    if( wglMakeCurrent( *hDC, tempRC ) == FALSE) {

+		fprintf(stderr,"wglMakeCurrent(%d,%d) failed on new context!!!\n",(int)*hDC,(int)tempRC);

+		fprintf(stderr,"Error code = %d\n",(int)GetLastError());

+		wglMakeCurrent(NULL, NULL);

+		wglDeleteContext( tempRC );

+        return( 0 );

+    }

+

+	if(shareWith!=NULL && wglShareLists(shareWith, tempRC)==FALSE)

+	{

+		fprintf(stderr,"\nERROR: Could not share lists between the new and the given GLContext (Win32Native)!\n");

+		fprintf(stderr,"Error code = %d\n",(int)GetLastError());

+		wglMakeCurrent(NULL, NULL);

+		wglDeleteContext( tempRC );

+        return( 0 );

+	}

+

+    if(JNI_TRUE==verbose)

+			printf( "HGLRC (glContext) created: %d\n", tempRC );

+

+    return tempRC;

+}

+

+// Select the pixel format for a given device context

+void LIBAPIENTRY SetDCPixelFormat(HDC hDC, jboolean doubleBuffer, 

+		jboolean stereo, jint stencilBits, jboolean offScreenRenderer,

+		jboolean verbose)

+{

+    int nPixelFormat=0;

+	const char * text=0;

+

+    static PIXELFORMATDESCRIPTOR pfd = {

+			sizeof(PIXELFORMATDESCRIPTOR),  // Size of this structure

+			1,                              // Version of this structure

+			0,								// will be defined later !!!!

+			PFD_TYPE_RGBA,                  // RGBA Color mode

+			24,                             // Want 24bit color

+			0,0,0,0,0,0,                    // Not used to select mode

+			0,0,                            // Not used to select mode

+			0,0,0,0,0,                      // Not used to select mode

+			32,                             // Size of depth buffer

+			0,                              // Not used to select mode

+			0,                              // Not used to select mode

+			PFD_MAIN_PLANE,                 // Draw in main plane

+			0,                              // Not used to select mode

+			0,0,0 };                        // Not used to select mode

+

+

+	// customize dw_flags

+	DWORD dw_flags = PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED;	// Support accelerated OpenGL calls in window

+

+	if(offScreenRenderer)

+		dw_flags |= PFD_DRAW_TO_BITMAP;           // Draw to Bitmap

+	else

+		dw_flags |= PFD_DRAW_TO_WINDOW;           // Draw to Window (not to bitmap)

+

+

+	if(doubleBuffer==JNI_TRUE)

+		dw_flags |= PFD_DOUBLEBUFFER ;  // Double buffered is optional

+

+	if(stereo==JNI_TRUE)

+		dw_flags |= PFD_STEREO ;        // Stereo is optional

+

+	pfd.dwFlags = dw_flags;

+

+    pfd.cColorBits = GetDeviceCaps(hDC, BITSPIXEL);

+

+	if(stencilBits>0)

+		pfd.cStencilBits = (BYTE) stencilBits;

+

+	if(verbose==JNI_TRUE)

+	{

+		fprintf(stderr,"\n\nUSER CHOOSED PIXELFORMAT (TRYING):\n");

+		text=GetTextualPixelFormatByPFD(&pfd, 0);			

+		fprintf(stderr,text);

+	}

+

+    // Choose a pixel format that best matches that described in pfd

+    if( hDC == 0 )

+	    printf( "SetDCPixelFormat: Error, no HDC-Contex is given\n");

+    else

+	    nPixelFormat = ChoosePixelFormat(hDC, &pfd);

+

+    if( nPixelFormat == 0 )

+	    printf( "SetDCPixelFormat: Error with PixelFormat\n" );

+

+    // Set the pixel format for the device context

+    if( SetPixelFormat(hDC, nPixelFormat, &pfd) == FALSE)

+	    printf( "setpixel failed\n" );

+}

+

+

+// If necessary, creates a 3-3-2 palette for the device context listed.

+HPALETTE LIBAPIENTRY GetOpenGLPalette(HDC hDC)

+{

+    HPALETTE hRetPal = NULL;	// Handle to palette to be created

+    PIXELFORMATDESCRIPTOR pfd;	// Pixel Format Descriptor

+    LOGPALETTE *pPal;			// Pointer to memory for logical palette

+    int nPixelFormat;			// Pixel format index

+    int nColors;				// Number of entries in palette

+    int i;						// Counting variable

+    BYTE RedRange,GreenRange,BlueRange;

+							    // Range for each color entry (7,7,and 3)

+

+

+    // Get the pixel format index and retrieve the pixel format description

+    nPixelFormat = GetPixelFormat(hDC);

+    DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

+

+    // Does this pixel format require a palette?  If not, do not create a

+    // palette and just return NULL

+    if(!(pfd.dwFlags & PFD_NEED_PALETTE))

+	    return NULL;

+

+    // Number of entries in palette.  8 bits yeilds 256 entries

+    nColors = 1 << pfd.cColorBits;	

+

+    // Allocate space for a logical palette structure plus all the palette entries

+    pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) + nColors*sizeof(PALETTEENTRY));

+

+    // Fill in palette header

+    pPal->palVersion = 0x300;		// Windows 3.0

+    pPal->palNumEntries = nColors; // table size

+

+    // Build mask of all 1's.  This creates a number represented by having

+    // the low order x bits set, where x = pfd.cRedBits, pfd.cGreenBits, and

+    // pfd.cBlueBits.  

+    RedRange = (1 << pfd.cRedBits) -1;

+    GreenRange = (1 << pfd.cGreenBits) - 1;

+    BlueRange = (1 << pfd.cBlueBits) -1;

+

+    // Loop through all the palette entries

+    for(i = 0; i < nColors; i++)

+	    {

+	    // Fill in the 8-bit equivalents for each component

+	    pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange;

+	    pPal->palPalEntry[i].peRed = (unsigned char)(

+		    (double) pPal->palPalEntry[i].peRed * 255.0 / RedRange);

+

+	    pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange;

+	    pPal->palPalEntry[i].peGreen = (unsigned char)(

+		    (double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange);

+

+	    pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange;

+	    pPal->palPalEntry[i].peBlue = (unsigned char)(

+		    (double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange);

+

+	    pPal->palPalEntry[i].peFlags = (unsigned char) NULL;

+	    }

+	    

+

+    // Create the palette

+    hRetPal = CreatePalette(pPal);

+

+    // Go ahead and select and realize the palette for this device context

+    SelectPalette(hDC,hRetPal,FALSE);

+    RealizePalette(hDC);

+

+    // Free the memory used for the logical palette structure

+    free(pPal);

+

+    // Return the handle to the new palette

+    return hRetPal;

+}

+

+

+jboolean LIBAPIENTRY testWin32Java()

+{

+    jboolean ret=JNI_TRUE;

+

+    /* NON DEPENDENCE CHECKS */

+

+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR WIN32-TYPE FITS IN �jint� */

+

+    if( sizeof(jlong) < sizeof(int *) )

+    {

+        fprintf(stderr,"(int *) fits not in jlong\n");

+		  ret = JNI_FALSE;

+    }

+

+    if( sizeof(jlong) < sizeof(HDC) )

+    {

+        fprintf(stderr,"HDC fits not in jlong\n");

+        ret = JNI_FALSE;

+    }

+

+    if( sizeof(jlong) < sizeof(HGLRC) )

+    {

+        fprintf(stderr,"HGLRC fits not in jlong\n");

+        ret = JNI_FALSE;

+    }

+

+    if(ret==JNI_FALSE)

+    {

+			fflush(stderr);

+    }

+

+    return ret;

+}

+

+

+static void

+PrintMessage( const char *Format, ... )

+{

+    va_list ArgList;

+    char Buffer[256];

+

+    va_start(ArgList, Format);

+    vsprintf(Buffer, Format, ArgList);

+    va_end(ArgList);

+

+	fprintf(stderr, Buffer);

+}

+

+

+int LIBAPIENTRY

+PixelFormatDescriptorFromDc( HDC Dc, PIXELFORMATDESCRIPTOR *Pfd )

+{

+    int PfdIndex;

+

+    if ( 0 < (PfdIndex = GetPixelFormat( Dc )) )

+    {

+        if ( 0 < DescribePixelFormat( Dc, PfdIndex, sizeof(*Pfd), Pfd ) )

+        {

+            return(PfdIndex);

+        }

+        else

+        {

+            PrintMessage("Could not get a description of pixel format %d\n",

+                PfdIndex );

+        }

+    }

+    else

+    {

+        PrintMessage("Could not get pixel format for Dc 0x%08lX\n", Dc );

+    }

+    return( 0 );

+}

+

+

+const char * LIBAPIENTRY

+GetTextualPixelFormatByPFD(PIXELFORMATDESCRIPTOR *ppfd, int format)

+{

+	static char buffer[2000];

+	char line[200];

+

+    sprintf(buffer,"Pixel format %d\n", format);

+    sprintf(line,"  dwFlags - 0x%x\n", ppfd->dwFlags); 

+	if (ppfd->dwFlags & PFD_DOUBLEBUFFER) { strcat(buffer, line); sprintf(line,"\tPFD_DOUBLEBUFFER\n "); }

+	if (ppfd->dwFlags & PFD_STEREO) { strcat(buffer, line); sprintf(line,"\tPFD_STEREO\n "); }

+	if (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) { strcat(buffer, line); sprintf(line,"\tPFD_DRAW_TO_WINDOW\n "); }

+    if (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) { strcat(buffer, line); sprintf(line,"\tPFD_DRAW_TO_BITMAP\n "); }

+    if (ppfd->dwFlags & PFD_SUPPORT_GDI) { strcat(buffer, line); sprintf(line,"\tPFD_SUPPORT_GDI\n "); }

+    if (ppfd->dwFlags & PFD_SUPPORT_OPENGL) { strcat(buffer, line); sprintf(line,"\tPFD_SUPPORT_OPENGL\n "); }

+    if (ppfd->dwFlags & PFD_GENERIC_ACCELERATED) { strcat(buffer, line); sprintf(line,"\tPFD_GENERIC_ACCELERATED\n "); }

+    if (ppfd->dwFlags & PFD_GENERIC_FORMAT) { strcat(buffer, line); sprintf(line,"\tPFD_GENERIC_FORMAT\n "); }

+    if (ppfd->dwFlags & PFD_NEED_PALETTE) { strcat(buffer, line); sprintf(line,"\tPFD_NEED_PALETTE\n "); }

+    if (ppfd->dwFlags & PFD_NEED_SYSTEM_PALETTE) { strcat(buffer, line); sprintf(line,"\tPFD_NEED_SYSTEM_PALETTE\n "); }

+    strcat(buffer, line); sprintf(line,"\n");

+    strcat(buffer, line); sprintf(line,"  iPixelType - %d\n", ppfd->iPixelType); 

+    if (ppfd->iPixelType == PFD_TYPE_RGBA) { strcat(buffer, line); sprintf(line,"\tPGD_TYPE_RGBA\n"); }

+    if (ppfd->iPixelType == PFD_TYPE_COLORINDEX) { strcat(buffer, line); sprintf(line,"\tPGD_TYPE_COLORINDEX\n"); }

+    strcat(buffer, line); sprintf(line,"  cColorBits - %d\n", ppfd->cColorBits);

+    strcat(buffer, line); sprintf(line,"  cRedBits - %d\n", ppfd->cRedBits);

+    strcat(buffer, line); sprintf(line,"  cRedShift - %d\n", ppfd->cRedShift);

+    strcat(buffer, line); sprintf(line,"  cGreenBits - %d\n", ppfd->cGreenBits);

+    strcat(buffer, line); sprintf(line,"  cGreenShift - %d\n", ppfd->cGreenShift);

+    strcat(buffer, line); sprintf(line,"  cBlueBits - %d\n", ppfd->cBlueBits);

+    strcat(buffer, line); sprintf(line,"  cBlueShift - %d\n", ppfd->cBlueShift);

+    strcat(buffer, line); sprintf(line,"  cAlphaBits - %d\n", ppfd->cAlphaBits);

+    strcat(buffer, line); sprintf(line,"  cAlphaShift - 0x%x\n", ppfd->cAlphaShift);

+    strcat(buffer, line); sprintf(line,"  cAccumBits - %d\n", ppfd->cAccumBits);

+    strcat(buffer, line); sprintf(line,"  cAccumRedBits - %d\n", ppfd->cAccumRedBits);

+    strcat(buffer, line); sprintf(line,"  cAccumGreenBits - %d\n", ppfd->cAccumGreenBits);

+    strcat(buffer, line); sprintf(line,"  cAccumBlueBits - %d\n", ppfd->cAccumBlueBits);

+    strcat(buffer, line); sprintf(line,"  cAccumAlphaBits - %d\n", ppfd->cAccumAlphaBits);

+    strcat(buffer, line); sprintf(line,"  cDepthBits - %d\n", ppfd->cDepthBits);

+    strcat(buffer, line); sprintf(line,"  cStencilBits - %d\n", ppfd->cStencilBits);

+    strcat(buffer, line); sprintf(line,"  cAuxBuffers - %d\n", ppfd->cAuxBuffers);

+    strcat(buffer, line); sprintf(line,"  iLayerType - %d\n", ppfd->iLayerType);

+    strcat(buffer, line); sprintf(line,"  bReserved - %d\n", ppfd->bReserved);

+    strcat(buffer, line); sprintf(line,"  dwLayerMask - 0x%x\n", ppfd->dwLayerMask);

+    strcat(buffer, line); sprintf(line,"  dwVisibleMask - 0x%x\n", ppfd->dwVisibleMask);

+    strcat(buffer, line); sprintf(line,"  dwDamageMask - 0x%x\n", ppfd->dwDamageMask);

+	strcat(buffer, line); 

+	return buffer;

+}

+

+const char * LIBAPIENTRY GetTextualPixelFormatByHDC(HDC hdc)

+{

+    PIXELFORMATDESCRIPTOR pfd, *ppfd;

+    int format;

+

+    ppfd   = &pfd;

+    format = PixelFormatDescriptorFromDc( hdc, ppfd );

+

+	return GetTextualPixelFormatByPFD(ppfd, format);

+}

+

+/*****************************************************************/

+

+/* Struct used to manage color ramps */

+static struct colorIndexState {

+    GLfloat amb[3];	/* ambient color / bottom of ramp */

+    GLfloat diff[3];	/* diffuse color / middle of ramp */

+    GLfloat spec[3];	/* specular color / top of ramp */

+    GLfloat ratio;	/* ratio of diffuse to specular in ramp */

+    GLint indexes[3];	/* where ramp was placed in palette */

+};

+#define NUM_COLORS (sizeof(colors) / sizeof(colors[0]))

+static struct colorIndexState colors[] = {

+    {

+        { 0.0F, 0.0F, 0.0F },

+        { 0.1F, 0.6F, 0.3F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+    {

+        { 0.0F, 0.0F, 0.0F },

+        { 0.0F, 0.2F, 0.5F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+    {

+        { 0.0F, 0.05F, 0.05F },

+        { 0.6F, 0.0F, 0.8F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+};

+

+

+void LIBAPIENTRY

+setupDIB(HDC hDCOrig, HDC hDC, HBITMAP * hBitmap, int width, int height)

+{

+    BITMAPINFO *bmInfo;

+    BITMAPINFOHEADER *bmHeader;

+    UINT usage;

+    VOID *base;

+    int bmiSize;

+    int bitsPerPixel;

+	HBITMAP hOldBitmap=0;

+

+    bmiSize = sizeof(*bmInfo);

+    bitsPerPixel = GetDeviceCaps(hDC, BITSPIXEL);

+

+    switch (bitsPerPixel) {

+    case 8:

+	// bmiColors is 256 WORD palette indices 

+	bmiSize += (256 * sizeof(WORD)) - sizeof(RGBQUAD);

+	break;

+    case 16:

+	// bmiColors is 3 WORD component masks 

+	bmiSize += (3 * sizeof(DWORD)) - sizeof(RGBQUAD);

+	break;

+    case 24:

+    case 32:

+    default:

+	// bmiColors not used 

+	break;

+    }

+

+    bmInfo = (BITMAPINFO *) calloc(1, bmiSize);

+    bmHeader = &bmInfo->bmiHeader;

+

+    bmHeader->biSize = sizeof(*bmHeader);

+    bmHeader->biWidth = width;

+    bmHeader->biHeight = height;

+    bmHeader->biPlanes = 1;			// must be 1 

+    bmHeader->biBitCount = bitsPerPixel;

+    bmHeader->biXPelsPerMeter = 0;

+    bmHeader->biYPelsPerMeter = 0;

+    bmHeader->biClrUsed = 0;			// all are used 

+    bmHeader->biClrImportant = 0;		// all are important 

+

+    switch (bitsPerPixel) {

+    case 8:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_PAL_COLORS;

+	// bmiColors is 256 WORD palette indices 

+	{

+	    WORD *palIndex = (WORD *) &bmInfo->bmiColors[0];

+	    int i;

+

+	    for (i=0; i<256; i++) {

+		palIndex[i] = i;

+	    }

+	}

+	break;

+    case 16:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_RGB_COLORS;

+	// bmiColors is 3 WORD component masks 

+	{

+	    DWORD *compMask = (DWORD *) &bmInfo->bmiColors[0];

+

+	    compMask[0] = 0xF800;

+	    compMask[1] = 0x07E0;

+	    compMask[2] = 0x001F;

+	}

+	break;

+    case 24:

+    case 32:

+    default:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_RGB_COLORS;

+	// bmiColors not used 

+	break;

+    }

+

+    *hBitmap = CreateDIBSection(hDC, bmInfo, usage, &base, NULL, 0);

+    if (*hBitmap == NULL) {

+	(void) MessageBox(WindowFromDC(hDC),

+		"Failed to create DIBSection.",

+		"OpenGL application error",

+		MB_ICONERROR | MB_OK);

+	exit(1);

+    }

+

+    hOldBitmap = SelectObject(hDC, *hBitmap);

+	if(hOldBitmap!=0)

+		DeleteObject(hOldBitmap);

+

+    free(bmInfo);

+}

+

+

+/*

+static void

+setupDIB(HDC hDCOrig, HDC hDC, HBITMAP * hBitmap, int width, int height)

+{

+	HBITMAP hOldBitmap=0;

+

+	*hBitmap = CreateCompatibleBitmap(  hDCOrig, width, height );

+    if (*hBitmap == NULL) {

+        fprintf(stderr,"Failed to create CreateCompatibleBitmap! \n");

+		fflush(stderr);

+		return;

+    }

+

+    hOldBitmap = SelectObject(hDC, *hBitmap);

+	if(hOldBitmap!=0)

+		DeleteObject(hOldBitmap);

+}

+*/

+

+

+void LIBAPIENTRY resizeDIB(HDC hDC, HBITMAP *hOldBitmap, HBITMAP *hBitmap)

+{

+	/*

+    SelectObject(hDC, *hOldBitmap);

+    DeleteObject(*hBitmap);

+    setupDIB(hDC, hBitmap);

+	*/

+}

+

+void LIBAPIENTRY setupPalette(HDC hDC)

+{

+    PIXELFORMATDESCRIPTOR pfd;

+    LOGPALETTE* pPal;

+    int pixelFormat = GetPixelFormat(hDC);

+    int paletteSize;

+

+    DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

+

+    /*

+    ** Determine if a palette is needed and if so what size.

+    */

+    if (pfd.dwFlags & PFD_NEED_PALETTE) {

+	paletteSize = 1 << pfd.cColorBits;

+    } else if (pfd.iPixelType == PFD_TYPE_COLORINDEX) {

+	paletteSize = 4096;

+    } else {

+	return;

+    }

+

+    pPal = (LOGPALETTE*)

+	malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));

+    pPal->palVersion = 0x300;

+    pPal->palNumEntries = paletteSize;

+

+    if (pfd.iPixelType == PFD_TYPE_RGBA) {

+	/*

+	** Fill the logical paletee with RGB color ramps

+	*/

+	int redMask = (1 << pfd.cRedBits) - 1;

+	int greenMask = (1 << pfd.cGreenBits) - 1;

+	int blueMask = (1 << pfd.cBlueBits) - 1;

+	int i;

+

+	for (i=0; i<paletteSize; ++i) {

+	    pPal->palPalEntry[i].peRed =

+		    (((i >> pfd.cRedShift) & redMask) * 255) / redMask;

+	    pPal->palPalEntry[i].peGreen =

+		    (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;

+	    pPal->palPalEntry[i].peBlue =

+		    (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;

+	    pPal->palPalEntry[i].peFlags = 0;

+	}

+    } else {

+	/*

+	** Fill the logical palette with color ramps.

+	**

+	** Set up the logical palette so that it can be realized

+	** into the system palette as an identity palette.

+	**

+	** 1) The default static entries should be present and at the right

+	**    location.  The easiest way to do this is to grab them from

+	**    the current system palette.

+	**

+	** 2) All non-static entries should be initialized to unique values.

+	**    The easiest way to do this is to ensure that all of the non-static

+	**    entries have the PC_NOCOLLAPSE flag bit set.

+	*/

+	int numRamps = NUM_COLORS;

+	int rampSize = (paletteSize - 20) / numRamps;

+	int extra = (paletteSize - 20) - (numRamps * rampSize);

+	int i, r;

+

+	/*

+	** Initialize static entries by copying them from the

+	** current system palette.

+	*/

+	GetSystemPaletteEntries(hDC, 0, paletteSize, &pPal->palPalEntry[0]);

+

+	/*

+	** Fill in non-static entries with desired colors.

+	*/

+	for (r=0; r<numRamps; ++r) {

+	    int rampBase = r * rampSize + 10;

+	    PALETTEENTRY *pe = &pPal->palPalEntry[rampBase];

+	    int diffSize = (int) (rampSize * colors[r].ratio);

+	    int specSize = rampSize - diffSize;

+

+	    for (i=0; i<rampSize; ++i) {

+		GLfloat *c0, *c1;

+		GLint a;

+

+		if (i < diffSize) {

+		    c0 = colors[r].amb;

+		    c1 = colors[r].diff;

+		    a = (i * 255) / (diffSize - 1);

+		} else {

+		    c0 = colors[r].diff;

+		    c1 = colors[r].spec;

+		    a = ((i - diffSize) * 255) / (specSize - 1);

+		}

+

+		pe[i].peRed = (BYTE) (a * (c1[0] - c0[0]) + 255 * c0[0]);

+		pe[i].peGreen = (BYTE) (a * (c1[1] - c0[1]) + 255 * c0[1]);

+		pe[i].peBlue = (BYTE) (a * (c1[2] - c0[2]) + 255 * c0[2]);

+		pe[i].peFlags = PC_NOCOLLAPSE;

+	    }

+

+	    colors[r].indexes[0] = rampBase;

+	    colors[r].indexes[1] = rampBase + (diffSize-1);

+	    colors[r].indexes[2] = rampBase + (rampSize-1);

+	}

+

+	/*

+	** Initialize any remaining non-static entries.

+	*/

+	for (i=0; i<extra; ++i) {

+	    int index = numRamps*rampSize+10+i;

+	    PALETTEENTRY *pe = &pPal->palPalEntry[index];

+

+	    pe->peRed = (BYTE) 0;

+	    pe->peGreen = (BYTE) 0;

+	    pe->peBlue = (BYTE) 0;

+	    pe->peFlags = PC_NOCOLLAPSE;

+	}

+    }

+

+    hPalette = CreatePalette(pPal);

+    free(pPal);

+

+    if (hPalette) {

+	SelectPalette(hDC, hPalette, FALSE);

+	RealizePalette(hDC);

+    }

+}

+

+