Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/multimedia/opengl/toolkits/libaux/tk.c

2624 lines
82 KiB
C
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*
* (c) Copyright 1993, Silicon Graphics, Inc.
* ALL RIGHTS RESERVED
* Permission to use, copy, modify, and distribute this software for
* any purpose and without fee is hereby granted, provided that the above
* copyright notice appear in all copies and that both the copyright notice
* and this permission notice appear in supporting documentation, and that
* the name of Silicon Graphics, Inc. not be used in advertising
* or publicity pertaining to distribution of the software without specific,
* written prior permission.
*
* THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
* AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
* FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
* GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
* SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
* KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
* LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
* THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN
* ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
* POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
*
* US Government Users Restricted Rights
* Use, duplication, or disclosure by the Government is subject to
* restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
* (c)(1)(ii) of the Rights in Technical Data and Computer Software
* clause at DFARS 252.227-7013 and/or in similar or successor
* clauses in the FAR or the DOD or NASA FAR Supplement.
* Unpublished-- rights reserved under the copyright laws of the
* United States. Contractor/manufacturer is Silicon Graphics,
* Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311.
*
* OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tk.h"
#include "windows.h"
#if(WINVER < 0x0400)
// Ordinarily not defined for versions before 4.00.
#define COLOR_3DDKSHADOW 21
#define COLOR_3DLIGHT 22
#define COLOR_INFOTEXT 23
#define COLOR_INFOBK 24
#endif
#define static
#if defined(__cplusplus) || defined(c_plusplus)
#define class c_class
#endif
#if DBG
#define TKASSERT(x) \
if ( !(x) ) { \
PrintMessage("%s(%d) Assertion failed %s\n", \
__FILE__, __LINE__, #x); \
}
#else
#define TKASSERT(x)
#endif /* DBG */
/******************************************************************************/
static struct _WINDOWINFO {
int x, y;
int width, height;
GLenum type;
GLenum dmPolicy;
int ipfd;
BOOL bDefPos;
} windInfo = {
0, 0, 100, 100, TK_INDEX | TK_SINGLE, TK_MINIMUM_CRITERIA, 0, TRUE
};
HWND tkhwnd = NULL;
HDC tkhdc = NULL;
static HGLRC tkhrc = NULL;
HPALETTE tkhpalette = NULL;
static OSVERSIONINFO tkOSVerInfo;
GLboolean tkPopupEnable = TRUE;
// Fixed palette support.
#define BLACK PALETTERGB(0,0,0)
#define WHITE PALETTERGB(255,255,255)
#define MAX_STATIC_COLORS (COLOR_INFOBK - COLOR_SCROLLBAR + 1)
static int tkNumStaticColors = MAX_STATIC_COLORS;
// TRUE if app wants to take over palette
static BOOL tkUseStaticColors = FALSE;
// TRUE if static system color settings have been replaced with B&W settings.
BOOL tkSystemColorsInUse = FALSE;
// TRUE if original static colors saved
static BOOL tkStaticColorsSaved = FALSE;
// saved system static colors (initialize with default colors)
static COLORREF gacrSave[MAX_STATIC_COLORS];
// new B&W system static colors
static COLORREF gacrBlackAndWhite[] = {
WHITE, // COLOR_SCROLLBAR
BLACK, // COLOR_BACKGROUND
BLACK, // COLOR_ACTIVECAPTION
WHITE, // COLOR_INACTIVECAPTION
WHITE, // COLOR_MENU
WHITE, // COLOR_WINDOW
BLACK, // COLOR_WINDOWFRAME
BLACK, // COLOR_MENUTEXT
BLACK, // COLOR_WINDOWTEXT
WHITE, // COLOR_CAPTIONTEXT
WHITE, // COLOR_ACTIVEBORDER
WHITE, // COLOR_INACTIVEBORDER
WHITE, // COLOR_APPWORKSPACE
BLACK, // COLOR_HIGHLIGHT
WHITE, // COLOR_HIGHLIGHTTEXT
WHITE, // COLOR_BTNFACE
BLACK, // COLOR_BTNSHADOW
BLACK, // COLOR_GRAYTEXT
BLACK, // COLOR_BTNTEXT
BLACK, // COLOR_INACTIVECAPTIONTEXT
BLACK, // COLOR_BTNHIGHLIGHT
BLACK, // COLOR_3DDKSHADOW
WHITE, // COLOR_3DLIGHT
BLACK, // COLOR_INFOTEXT
WHITE // COLOR_INFOBK
};
static INT gaiStaticIndex[] = {
COLOR_SCROLLBAR ,
COLOR_BACKGROUND ,
COLOR_ACTIVECAPTION ,
COLOR_INACTIVECAPTION ,
COLOR_MENU ,
COLOR_WINDOW ,
COLOR_WINDOWFRAME ,
COLOR_MENUTEXT ,
COLOR_WINDOWTEXT ,
COLOR_CAPTIONTEXT ,
COLOR_ACTIVEBORDER ,
COLOR_INACTIVEBORDER ,
COLOR_APPWORKSPACE ,
COLOR_HIGHLIGHT ,
COLOR_HIGHLIGHTTEXT ,
COLOR_BTNFACE ,
COLOR_BTNSHADOW ,
COLOR_GRAYTEXT ,
COLOR_BTNTEXT ,
COLOR_INACTIVECAPTIONTEXT,
COLOR_BTNHIGHLIGHT ,
COLOR_3DDKSHADOW ,
COLOR_3DLIGHT ,
COLOR_INFOTEXT ,
COLOR_INFOBK
};
static BOOL GrabStaticEntries(HDC);
static BOOL ReleaseStaticEntries(HDC);
#define RESTORE_FROM_REGISTRY 1
#if RESTORE_FROM_REGISTRY
// Registry names for the system colors.
CHAR *gaszSysClrNames[] = {
"Scrollbar", // COLOR_SCROLLBAR 0
"Background", // COLOR_BACKGROUND 1 (also COLOR_DESKTOP)
"ActiveTitle", // COLOR_ACTIVECAPTION 2
"InactiveTitle", // COLOR_INACTIVECAPTION 3
"Menu", // COLOR_MENU 4
"Window", // COLOR_WINDOW 5
"WindowFrame", // COLOR_WINDOWFRAME 6
"MenuText", // COLOR_MENUTEXT 7
"WindowText", // COLOR_WINDOWTEXT 8
"TitleText", // COLOR_CAPTIONTEXT 9
"ActiveBorder", // COLOR_ACTIVEBORDER 10
"InactiveBorder", // COLOR_INACTIVEBORDER 11
"AppWorkspace", // COLOR_APPWORKSPACE 12
"Hilight", // COLOR_HIGHLIGHT 13
"HilightText", // COLOR_HIGHLIGHTTEXT 14
"ButtonFace", // COLOR_BTNFACE 15 (also COLOR_3DFACE)
"ButtonShadow", // COLOR_BTNSHADOW 16 (also COLOR_3DSHADOW)
"GrayText", // COLOR_GRAYTEXT 17
"ButtonText", // COLOR_BTNTEXT 18
"InactiveTitleText", // COLOR_INACTIVECAPTIONTEXT 19
"ButtonHilight", // COLOR_BTNHIGHLIGHT 20 (also COLOR_3DHILIGHT)
"ButtonDkShadow", // COLOR_3DDKSHADOW 21
"ButtonLight", // COLOR_3DLIGHT 22
"InfoText", // COLOR_INFOTEXT 23
"InfoWindow" // COLOR_INFOBK 24
};
static BOOL GetRegistrySysColors(COLORREF *, int);
#endif
static void (*ExposeFunc)(int, int) = NULL;
static void (*ReshapeFunc)(int, int) = NULL;
static void (*DisplayFunc)(void) = NULL;
static GLenum (*KeyDownFunc)(int, GLenum) = NULL;
static GLenum (*MouseDownFunc)(int, int, GLenum) = NULL;
static GLenum (*MouseUpFunc)(int, int, GLenum) = NULL;
static GLenum (*MouseMoveFunc)(int, int, GLenum) = NULL;
static void (*IdleFunc)(void) = NULL;
static char *lpszClassName = "tkLibWClass";
static WCHAR *lpszClassNameW = L"tkLibWClass";
static LRESULT tkWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
static unsigned char ComponentFromIndex(int i, int nbits, int shift );
static void PrintMessage( const char *Format, ... );
static PALETTEENTRY *FillRgbPaletteEntries( PIXELFORMATDESCRIPTOR *Pfd, PALETTEENTRY *Entries, UINT Count );
static HPALETTE CreateCIPalette( HDC Dc );
static HPALETTE CreateRGBPalette( HDC hdc );
static void DestroyThisWindow( HWND Window );
static void CleanUp( void );
static void DelayPaletteRealization( void );
static long RealizePaletteNow( HDC Dc, HPALETTE Palette, BOOL bForceBackground );
static void ForceRedraw( HWND Window );
static BOOL FindPixelFormat(HDC hdc, GLenum type);
static int FindBestPixelFormat(HDC hdc, GLenum type, PIXELFORMATDESCRIPTOR *ppfd);
static int FindExactPixelFormat(HDC hdc, GLenum type, PIXELFORMATDESCRIPTOR *ppfd);
static BOOL IsPixelFormatValid(HDC hdc, int ipfd, PIXELFORMATDESCRIPTOR *ppfd);
static int PixelFormatDescriptorFromDc( HDC Dc, PIXELFORMATDESCRIPTOR *Pfd );
static void *AllocateMemory( size_t Size );
static void *AllocateZeroedMemory( size_t Size );
static void FreeMemory( void *Chunk );
/*
* Prototypes for the debugging functions go here
*/
#define DBGFUNC 0
#if DBGFUNC
static void DbgPrintf( const char *Format, ... );
static void pwi( void );
static void pwr(RECT *pr);
static void ShowPixelFormat(HDC hdc);
#endif
static float colorMaps[] = {
0.000000F, 1.000000F, 0.000000F, 1.000000F, 0.000000F, 1.000000F,
0.000000F, 1.000000F, 0.333333F, 0.776471F, 0.443137F, 0.556863F,
0.443137F, 0.556863F, 0.219608F, 0.666667F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.039216F, 0.078431F, 0.117647F, 0.156863F,
0.200000F, 0.239216F, 0.278431F, 0.317647F, 0.356863F, 0.400000F,
0.439216F, 0.478431F, 0.517647F, 0.556863F, 0.600000F, 0.639216F,
0.678431F, 0.717647F, 0.756863F, 0.800000F, 0.839216F, 0.878431F,
0.917647F, 0.956863F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 0.000000F, 0.000000F,
1.000000F, 1.000000F, 0.000000F, 0.000000F, 1.000000F, 1.000000F,
0.333333F, 0.443137F, 0.776471F, 0.556863F, 0.443137F, 0.219608F,
0.556863F, 0.666667F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.039216F, 0.078431F, 0.117647F, 0.156863F, 0.200000F, 0.239216F,
0.278431F, 0.317647F, 0.356863F, 0.400000F, 0.439216F, 0.478431F,
0.517647F, 0.556863F, 0.600000F, 0.639216F, 0.678431F, 0.717647F,
0.756863F, 0.800000F, 0.839216F, 0.878431F, 0.917647F, 0.956863F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.141176F, 0.282353F, 0.427451F,
0.568627F, 0.713726F, 0.854902F, 1.000000F, 0.000000F, 0.141176F,
0.282353F, 0.427451F, 0.568627F, 0.713726F, 0.854902F, 1.000000F,
0.000000F, 0.141176F, 0.282353F, 0.427451F, 0.568627F, 0.713726F,
0.854902F, 1.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 0.333333F, 0.443137F,
0.443137F, 0.219608F, 0.776471F, 0.556863F, 0.556863F, 0.666667F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.666667F, 0.333333F,
0.666667F, 0.333333F, 0.666667F, 0.333333F, 0.039216F, 0.078431F,
0.117647F, 0.156863F, 0.200000F, 0.239216F, 0.278431F, 0.317647F,
0.356863F, 0.400000F, 0.439216F, 0.478431F, 0.517647F, 0.556863F,
0.600000F, 0.639216F, 0.678431F, 0.717647F, 0.756863F, 0.800000F,
0.839216F, 0.878431F, 0.917647F, 0.956863F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F, 0.000000F,
0.000000F, 0.000000F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F, 0.247059F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.498039F,
0.498039F, 0.498039F, 0.498039F, 0.498039F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F, 0.749020F,
0.749020F, 0.749020F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F, 1.000000F,
};
/* Default Palette */
float auxRGBMap[20][3] = {
{ 0.0F, 0.0F, 0.0F }, /* 0: black */
{ 0x80/255.0F, 0.0F, 0.0F }, /* 1: Half red */
{ 0.0F, 0x80/255.0F, 0.0F }, /* 2: Half green */
{ 0x80/255.0F, 0x80/255.0F, 0.0F }, /* 3: Half yellow */
{ 0.0F, 0.0F, 0x80/255.0F }, /* 4: Half blue */
{ 0x80/255.0F, 0.0F, 0x80/255.0F }, /* 5: Half magenta */
{ 0.0F, 0x80/255.0F, 0x80/255.0F }, /* 6: Half cyan */
{ 0xC0/255.0F, 0xC0/255.0F, 0xC0/255.0F }, /* 7: Light gray */
{ 0xC0/255.0F, 0xDC/255.0F, 0xC0/255.0F }, /* 8: Green gray */
{ 0xA6/255.0F, 0xCA/255.0F, 0xF0/255.0F }, /* 9: Half gray */
{ 1.0F, 0xFB/255.0F, 0xF0/255.0F }, /* 10: Pale */
{ 0xA0/255.0F, 0xA0/255.0F, 0xA4/255.0F }, /* 11: Med gray */
{ 0x80/255.0F, 0x80/255.0F, 0x80/255.0F }, /* 12: Dark gray */
{ 1.0F, 0.0F, 0.0F }, /* 13: red */
{ 0.0F, 1.0F, 0.0F }, /* 14: green */
{ 1.0F, 1.0F, 0.0F }, /* 15: yellow */
{ 0.0F, 0.0F, 1.0F }, /* 16: blue */
{ 1.0F, 0.0F, 1.0F }, /* 17: magenta */
{ 0.0F, 1.0F, 1.0F }, /* 18: cyan */
{ 1.0F, 1.0F, 1.0F }, /* 19: white */
};
/***************************************************************
* *
* Exported Functions go here *
* *
***************************************************************/
void tkErrorPopups(GLboolean bEnable)
{
tkPopupEnable = bEnable;
}
void tkCloseWindow(void)
{
DestroyThisWindow(tkhwnd);
}
void tkExec(void)
{
MSG Message;
/*
* WM_SIZE gets delivered before we get here!
*/
if (ReshapeFunc)
{
RECT ClientRect;
GetClientRect(tkhwnd, &ClientRect);
(*ReshapeFunc)(ClientRect.right, ClientRect.bottom);
}
while (GL_TRUE)
{
/*
* Process all pending messages
*/
if (IdleFunc) {
while (PeekMessage(&Message, NULL, 0, 0, PM_NOREMOVE) == TRUE) {
if (GetMessage(&Message, NULL, 0, 0) ) {
TranslateMessage(&Message);
DispatchMessage(&Message);
} else {
/*
* Nothing else to do here, just return
*/
return;
}
}
/*
* If an idle function was defined, call it
*/
if (IdleFunc) {
(*IdleFunc)();
}
} else {
if (GetMessage(&Message, NULL, 0, 0)) {
TranslateMessage(&Message);
DispatchMessage(&Message);
} else {
return;
}
}
}
}
void tkExposeFunc(void (*Func)(int, int))
{
ExposeFunc = Func;
}
void tkReshapeFunc(void (*Func)(int, int))
{
ReshapeFunc = Func;
}
void tkDisplayFunc(void (*Func)(void))
{
DisplayFunc = Func;
}
void tkKeyDownFunc(GLenum (*Func)(int, GLenum))
{
KeyDownFunc = Func;
}
void tkMouseDownFunc(GLenum (*Func)(int, int, GLenum))
{
MouseDownFunc = Func;
}
void tkMouseUpFunc(GLenum (*Func)(int, int, GLenum))
{
MouseUpFunc = Func;
}
void tkMouseMoveFunc(GLenum (*Func)(int, int, GLenum))
{
MouseMoveFunc = Func;
}
void tkIdleFunc(void (*Func)(void))
{
IdleFunc = Func;
}
void tkInitPosition(int x, int y, int width, int height)
{
if (x == CW_USEDEFAULT)
{
x = 0;
y = 0;
windInfo.bDefPos = TRUE;
}
else
windInfo.bDefPos = FALSE;
windInfo.x = x + GetSystemMetrics(SM_CXFRAME);
windInfo.y = y + GetSystemMetrics(SM_CYCAPTION)
- GetSystemMetrics(SM_CYBORDER)
+ GetSystemMetrics(SM_CYFRAME);
windInfo.width = width;
windInfo.height = height;
}
void tkInitDisplayMode(GLenum type)
{
windInfo.type = type;
}
void tkInitDisplayModePolicy(GLenum type)
{
windInfo.dmPolicy = type;
}
GLenum tkInitDisplayModeID(GLint ipfd)
{
windInfo.ipfd = ipfd;
return GL_TRUE;
}
// Initialize a window, create a rendering context for that window
GLenum tkInitWindow(char *title)
{
TKASSERT( NULL==tkhwnd );
TKASSERT( NULL==tkhdc );
TKASSERT( NULL==tkhrc );
TKASSERT( NULL==tkhpalette );
return tkInitWindowAW(title, FALSE);
}
GLenum tkInitWindowAW(char *title, BOOL bUnicode)
{
WNDCLASS wndclass;
RECT WinRect;
HANDLE hInstance;
ATOM aRegister;
GLenum Result = GL_FALSE;
BOOL bGetVersionExRet;
hInstance = GetModuleHandle(NULL);
tkOSVerInfo.dwOSVersionInfoSize = sizeof(tkOSVerInfo);
bGetVersionExRet = GetVersionEx(&tkOSVerInfo);
TKASSERT(bGetVersionExRet);
if ( tkOSVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
tkOSVerInfo.dwMajorVersion == 3 &&
(tkOSVerInfo.dwMinorVersion == 5 || tkOSVerInfo.dwMinorVersion == 51) )
tkNumStaticColors = COLOR_BTNHIGHLIGHT - COLOR_SCROLLBAR + 1;
else
tkNumStaticColors = COLOR_INFOBK - COLOR_SCROLLBAR + 1;
// Must not define CS_PARENTDC style.
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = tkWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
wndclass.lpszMenuName = NULL;
if (bUnicode)
wndclass.lpszClassName = (LPCSTR)lpszClassNameW;
else
wndclass.lpszClassName = (LPCSTR)lpszClassName;
if (bUnicode)
{
aRegister = RegisterClassW((CONST WNDCLASSW *)&wndclass);
}
else
{
aRegister = RegisterClass(&wndclass);
}
/*
* If the window failed to register, then there's no
* need to continue further.
*/
if(0 == aRegister)
{
PrintMessage("Failed to register window class\n");
return(Result);
}
/*
* Make window large enough to hold a client area as large as windInfo
*/
WinRect.left = windInfo.x;
WinRect.right = windInfo.x + windInfo.width;
WinRect.top = windInfo.y;
WinRect.bottom = windInfo.y + windInfo.height;
AdjustWindowRect(&WinRect, WS_OVERLAPPEDWINDOW, FALSE);
/*
* Must use WS_CLIPCHILDREN and WS_CLIPSIBLINGS styles.
*/
if (bUnicode)
{
tkhwnd = CreateWindowW(
(LPCWSTR)lpszClassNameW,
(LPCWSTR)title,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
(windInfo.bDefPos) ? CW_USEDEFAULT : WinRect.left,
(windInfo.bDefPos) ? CW_USEDEFAULT : WinRect.top,
WinRect.right - WinRect.left,
WinRect.bottom - WinRect.top,
NULL,
NULL,
hInstance,
NULL);
}
else
{
tkhwnd = CreateWindow(
lpszClassName,
title,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
(windInfo.bDefPos) ? CW_USEDEFAULT : WinRect.left,
(windInfo.bDefPos) ? CW_USEDEFAULT : WinRect.top,
WinRect.right - WinRect.left,
WinRect.bottom - WinRect.top,
NULL,
NULL,
hInstance,
NULL);
}
if ( NULL != tkhwnd )
{
// If default window positioning used, find out window position and fix
// up the windInfo position info.
if (windInfo.bDefPos)
{
GetWindowRect(tkhwnd, &WinRect);
windInfo.x = WinRect.left + GetSystemMetrics(SM_CXFRAME);
windInfo.y = WinRect.top + GetSystemMetrics(SM_CYCAPTION)
- GetSystemMetrics(SM_CYBORDER)
+ GetSystemMetrics(SM_CYFRAME);
}
tkhdc = GetDC(tkhwnd);
if ( NULL != tkhdc )
{
ShowWindow(tkhwnd, SW_SHOWDEFAULT);
if ( FindPixelFormat(tkhdc, windInfo.type) )
{
/*
* Create a Rendering Context
*/
tkhrc = wglCreateContext(tkhdc);
if ( NULL != tkhrc )
{
/*
* Make it Current
*/
if ( wglMakeCurrent(tkhdc, tkhrc) )
{
Result = GL_TRUE;
}
else
{
PrintMessage("wglMakeCurrent Failed\n");
}
}
else
{
PrintMessage("wglCreateContext Failed\n");
}
}
}
else
{
PrintMessage("Could not get an HDC for window 0x%08lX\n", tkhwnd );
}
}
else
{
PrintMessage("create window failed\n");
}
if ( GL_FALSE == Result )
{
DestroyThisWindow(tkhwnd); // Something Failed, Destroy this window
}
return( Result );
}
/******************************************************************************/
/*
* You cannot just call DestroyWindow() here. The programs do not expect
* tkQuit() to return; DestroyWindow() just sends a WM_DESTROY message
*/
void tkQuit(void)
{
DestroyThisWindow(tkhwnd);
ExitProcess(0);
}
/******************************************************************************/
void tkSetOneColor(int index, float r, float g, float b)
{
PALETTEENTRY PalEntry;
HPALETTE Palette;
if ( NULL != (Palette = CreateCIPalette( tkhdc )) )
{
if ( tkUseStaticColors && ( index == 0 || index == 255 ) )
return;
PalEntry.peRed = (BYTE)(r*(float)255.0 + (float)0.5);
PalEntry.peGreen = (BYTE)(g*(float)255.0 + (float)0.5);
PalEntry.peBlue = (BYTE)(b*(float)255.0 + (float)0.5);
PalEntry.peFlags = ( tkUseStaticColors ) ? PC_NOCOLLAPSE : 0;
// This is a workaround for a GDI palette "feature". If any of
// the static colors are repeated in the palette, those colors
// will map to the first occurance. So, for our case where there
// are only two static colors (black and white), if a white
// color appears anywhere in the palette other than in the last
// entry, the static white will remap to the first white. This
// destroys the nice one-to-one mapping we are trying to achieve.
//
// There are two ways to workaround this. The first is to
// simply not allow a pure white anywhere but in the last entry.
// Such requests are replaced with an attenuated white of
// (0xFE, 0xFE, 0xFE).
//
// The other way is to mark these extra whites with PC_RESERVED
// which will cause GDI to skip these entries when mapping colors.
// This way the app gets the actual colors requested, but can
// have side effects on other apps.
//
// Both solutions are included below. The PC_RESERVED solution is
// the one currently enabled. It may have side effects, but taking
// over the static colors as we are is a really big side effect that
// should swamp out the effects of using PC_RESERVED.
if ( tkUseStaticColors )
{
if ( PalEntry.peRed == 0xFF &&
PalEntry.peGreen == 0xFF &&
PalEntry.peBlue == 0xFF )
{
#define USE_PC_RESERVED_WORKAROUND 1
#if USE_PC_RESERVED_WORKAROUND
PalEntry.peFlags |= PC_RESERVED;
#else
PalEntry.peRed =
PalEntry.peGreen =
PalEntry.peBlue = 0xFE;
#endif
}
}
SetPaletteEntries( Palette, index, 1, &PalEntry);
DelayPaletteRealization();
}
}
void tkSetFogRamp(int density, int startIndex)
{
HPALETTE CurrentPal;
PALETTEENTRY *pPalEntry;
UINT n, i, j, k, intensity, fogValues, colorValues;
if ( NULL != (CurrentPal = CreateCIPalette(tkhdc)) )
{
n = GetPaletteEntries( CurrentPal, 0, 0, NULL );
pPalEntry = AllocateMemory( n * sizeof(PALETTEENTRY) );
if ( NULL != pPalEntry)
{
fogValues = 1 << density;
colorValues = 1 << startIndex;
for (i = 0; i < colorValues; i++) {
for (j = 0; j < fogValues; j++) {
k = i * fogValues + j;
intensity = i * fogValues + j * colorValues;
//mf: not sure what they're trying to do here
//intensity = (intensity << 8) | intensity; ???
// This is a workaround for a GDI palette "feature". If any of
// the static colors are repeated in the palette, those colors
// will map to the first occurance. So, for our case where there
// are only two static colors (black and white), if a white
// color appears anywhere in the palette other than in the last
// entry, the static white will remap to the first white. This
// destroys the nice one-to-one mapping we are trying to achieve.
//
// There are two ways to workaround this. The first is to
// simply not allow a pure white anywhere but in the last entry.
// Such requests are replaced with an attenuated white of
// (0xFE, 0xFE, 0xFE).
//
// The other way is to mark these extra whites with PC_RESERVED
// which will cause GDI to skip these entries when mapping colors.
// This way the app gets the actual colors requested, but can
// have side effects on other apps.
//
// Both solutions are included below. The PC_RESERVED solution is
// the one currently enabled. It may have side effects, but taking
// over the static colors as we are is a really big side effect that
// should swamp out the effects of using PC_RESERVED.
#if USE_PC_RESERVED_WORKAROUND
if (intensity > 0xFF)
intensity = 0xFF;
#else
if (intensity >= 0xFF)
intensity = ( tkUseStaticColors && k != 255) ? 0xFE : 0xFF;
#endif
pPalEntry[k].peRed =
pPalEntry[k].peGreen =
pPalEntry[k].peBlue = (BYTE) intensity;
pPalEntry[k].peFlags = ( tkUseStaticColors && k != 0 && k != 255 )
? PC_NOCOLLAPSE : 0;
#if USE_PC_RESERVED_WORKAROUND
if (tkUseStaticColors && intensity == 0xFF
&& k != 0 && k!= 255)
pPalEntry[k].peFlags |= PC_RESERVED;
#endif
}
}
SetPaletteEntries(CurrentPal, 0, n, pPalEntry);
FreeMemory( pPalEntry );
DelayPaletteRealization();
}
}
}
void tkSetGreyRamp(void)
{
HPALETTE CurrentPal;
PALETTEENTRY *Entries;
UINT Count, i;
float intensity;
if ( NULL != (CurrentPal = CreateCIPalette( tkhdc )) )
{
Count = GetPaletteEntries( CurrentPal, 0, 0, NULL );
Entries = AllocateMemory( Count * sizeof(PALETTEENTRY) );
if ( NULL != Entries )
{
for (i = 0; i < Count; i++)
{
intensity = (float)(((double)i / (double)(Count-1)) * (double)255.0 + (double)0.5);
Entries[i].peRed =
Entries[i].peGreen =
Entries[i].peBlue = (BYTE) intensity;
Entries[i].peFlags = ( tkUseStaticColors && i != 0 && i != 255 )
? PC_NOCOLLAPSE : 0;
}
SetPaletteEntries( CurrentPal, 0, Count, Entries );
FreeMemory( Entries );
DelayPaletteRealization();
}
}
}
void tkSetRGBMap( int Size, float *Values )
{
HPALETTE CurrentPal;
PIXELFORMATDESCRIPTOR Pfd, *pPfd;
PALETTEENTRY *Entries;
UINT Count;
if ( NULL != (CurrentPal = CreateCIPalette( tkhdc )) )
{
pPfd = &Pfd;
if ( PixelFormatDescriptorFromDc( tkhdc, pPfd ) )
{
Count = 1 << pPfd->cColorBits;
Entries = AllocateMemory( Count * sizeof(PALETTEENTRY) );
if ( NULL != Entries )
{
FillRgbPaletteEntries( pPfd, Entries, Count );
SetPaletteEntries( CurrentPal, 0, Count, Entries );
FreeMemory(Entries);
RealizePaletteNow( tkhdc, tkhpalette, FALSE );
}
}
}
}
/******************************************************************************/
void tkSwapBuffers(void)
{
SwapBuffers(tkhdc);
}
/******************************************************************************/
GLint tkGetColorMapSize(void)
{
CreateCIPalette( tkhdc );
if ( NULL == tkhpalette )
return( 0 );
return( GetPaletteEntries( tkhpalette, 0, 0, NULL ) );
}
void tkGetMouseLoc(int *x, int *y)
{
POINT Point;
*x = 0;
*y = 0;
GetCursorPos(&Point);
/*
* GetCursorPos returns screen coordinates,
* we want window coordinates
*/
*x = Point.x - windInfo.x;
*y = Point.y - windInfo.y;
}
HWND tkGetHWND(void)
{
return tkhwnd;
}
HDC tkGetHDC(void)
{
return tkhdc;
}
HGLRC tkGetHRC(void)
{
return tkhrc;
}
GLenum tkGetDisplayModePolicy(void)
{
return windInfo.dmPolicy;
}
GLint tkGetDisplayModeID(void)
{
return windInfo.ipfd;
}
GLenum tkGetDisplayMode(void)
{
return windInfo.type;
}
/***********************************************************************
* *
* The Following functions are for our own use only. (ie static) *
* *
***********************************************************************/
static LRESULT
tkWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int key;
PAINTSTRUCT paint;
HDC hdc;
PIXELFORMATDESCRIPTOR pfd;
switch (message) {
case WM_USER:
if ( RealizePaletteNow( tkhdc, tkhpalette, FALSE ) > 0 )
{
ForceRedraw( hWnd );
}
return(0);
case WM_SIZE:
windInfo.width = LOWORD(lParam);
windInfo.height = HIWORD(lParam);
if (ReshapeFunc)
{
(*ReshapeFunc)(windInfo.width, windInfo.height);
ForceRedraw( hWnd );
}
return (0);
case WM_MOVE:
windInfo.x = LOWORD(lParam);
windInfo.y = HIWORD(lParam);
return (0);
case WM_PAINT:
/*
* Validate the region even if there are no DisplayFunc.
* Otherwise, USER will not stop sending WM_PAINT messages.
*/
hdc = BeginPaint(tkhwnd, &paint);
if (DisplayFunc)
{
(*DisplayFunc)();
}
EndPaint(tkhwnd, &paint);
return (0);
case WM_QUERYNEWPALETTE:
// We don't actually realize the palette here (we do it at WM_ACTIVATE
// time), but we need the system to think that we have so that a
// WM_PALETTECHANGED message is generated.
return (1);
case WM_PALETTECHANGED:
// Respond to this message only if the window that changed the palette
// is not this app's window.
// We are not the foreground window, so realize palette in the
// background. We cannot call RealizePaletteNow to do this because
// we should not do any of the tkUseStaticColors processing while
// in background.
if ( hWnd != (HWND) wParam )
{
if ( !tkSystemColorsInUse &&
NULL != tkhpalette &&
NULL != SelectPalette( tkhdc, tkhpalette, TRUE ) )
RealizePalette( tkhdc );
}
return (0);
case WM_SYSCOLORCHANGE:
// If the system colors have changed and we have a palette
// for an RGB surface then we need to recompute the static
// color mapping because they might have been changed in
// the process of changing the system colors.
if (tkhdc != NULL && tkhpalette != NULL &&
PixelFormatDescriptorFromDc(tkhdc, &pfd) &&
(pfd.dwFlags & PFD_NEED_PALETTE) &&
pfd.iPixelType == PFD_TYPE_RGBA)
{
HPALETTE hpalTmp;
hpalTmp = tkhpalette;
tkhpalette = NULL;
if (CreateRGBPalette(tkhdc) != NULL)
{
DeleteObject(hpalTmp);
ForceRedraw(hWnd);
}
else
{
tkhpalette = hpalTmp;
}
}
break;
case WM_ACTIVATE:
// If the window is going inactive, the palette must be realized to
// the background. Cannot depend on WM_PALETTECHANGED to be sent since
// the window that comes to the foreground may or may not be palette
// managed.
if ( LOWORD(wParam) == WA_INACTIVE )
{
if ( NULL != tkhpalette )
{
// Realize as a background palette. Need to call
// RealizePaletteNow rather than RealizePalette directly to
// because it may be necessary to release usage of the static
// system colors.
if ( RealizePaletteNow( tkhdc, tkhpalette, TRUE ) > 0 )
ForceRedraw( hWnd );
}
}
// Window is going active. If we are not iconized, realize palette
// to the foreground. If management of the system static colors is
// needed, RealizePaletteNow will take care of it.
else if ( HIWORD(wParam) == 0 )
{
if ( NULL != tkhpalette )
{
if ( RealizePaletteNow( tkhdc, tkhpalette, FALSE ) > 0 )
ForceRedraw( hWnd );
return (1);
}
}
// Allow DefWindowProc() to finish the default processing (which includes
// changing the keyboard focus).
break;
case WM_MOUSEMOVE:
if (MouseMoveFunc)
{
GLenum mask;
mask = 0;
if (wParam & MK_LBUTTON) {
mask |= TK_LEFTBUTTON;
}
if (wParam & MK_MBUTTON) {
mask |= TK_MIDDLEBUTTON;
}
if (wParam & MK_RBUTTON) {
mask |= TK_RIGHTBUTTON;
}
if ((*MouseMoveFunc)( LOWORD(lParam), HIWORD(lParam), mask ))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_LBUTTONDOWN:
SetCapture(hWnd);
if (MouseDownFunc)
{
if ( (*MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
TK_LEFTBUTTON) )
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_LBUTTONUP:
ReleaseCapture();
if (MouseUpFunc)
{
if ((*MouseUpFunc)(LOWORD(lParam), HIWORD(lParam), TK_LEFTBUTTON))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_MBUTTONDOWN:
SetCapture(hWnd);
if (MouseDownFunc)
{
if ((*MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
TK_MIDDLEBUTTON))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_MBUTTONUP:
ReleaseCapture();
if (MouseUpFunc)
{
if ((*MouseUpFunc)(LOWORD(lParam), HIWORD(lParam),
TK_MIDDLEBUTTON))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_RBUTTONDOWN:
SetCapture(hWnd);
if (MouseDownFunc)
{
if ((*MouseDownFunc)(LOWORD(lParam), HIWORD(lParam),
TK_RIGHTBUTTON))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_RBUTTONUP:
ReleaseCapture();
if (MouseUpFunc)
{
if ((*MouseUpFunc)(LOWORD(lParam), HIWORD(lParam),
TK_RIGHTBUTTON))
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_KEYDOWN:
switch (wParam) {
case VK_SPACE: key = TK_SPACE; break;
case VK_RETURN: key = TK_RETURN; break;
case VK_ESCAPE: key = TK_ESCAPE; break;
case VK_LEFT: key = TK_LEFT; break;
case VK_UP: key = TK_UP; break;
case VK_RIGHT: key = TK_RIGHT; break;
case VK_DOWN: key = TK_DOWN; break;
default: key = GL_FALSE; break;
}
if (key && KeyDownFunc)
{
GLenum mask;
mask = 0;
if (GetKeyState(VK_CONTROL)) {
mask |= TK_CONTROL;
}
if (GetKeyState(VK_SHIFT)) {
mask |= TK_SHIFT;
}
if ( (*KeyDownFunc)(key, mask) )
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_CHAR:
if (('0' <= wParam && wParam <= '9') ||
('a' <= wParam && wParam <= 'z') ||
('A' <= wParam && wParam <= 'Z')) {
key = (int)wParam;
} else {
key = GL_FALSE;
}
if (key && KeyDownFunc) {
GLenum mask;
mask = 0;
if (GetKeyState(VK_CONTROL)) {
mask |= TK_CONTROL;
}
if (GetKeyState(VK_SHIFT)) {
mask |= TK_SHIFT;
}
if ( (*KeyDownFunc)(key, mask) )
{
ForceRedraw( hWnd );
}
}
return (0);
case WM_CLOSE:
DestroyWindow(tkhwnd);
return(0);
case WM_DESTROY:
CleanUp();
PostQuitMessage(TRUE);
return 0;
}
return(DefWindowProc( hWnd, message, wParam, lParam));
}
#if RESTORE_FROM_REGISTRY
/******************************Public*Routine******************************\
* GetRegistrySysColors
*
* Reads the Control Panel's color settings from the registry and stores
* those values in pcr. If we fail to get any value, then the corresponding
* entry in pcr is not modified.
*
* History:
* 12-Apr-1995 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static BOOL GetRegistrySysColors(COLORREF *pcr, int nColors)
{
BOOL bRet = FALSE;
long lRet;
HKEY hkSysColors = (HKEY) NULL;
int i;
DWORD dwDataType;
char achColor[64];
DWORD cjColor;
TKASSERT(nColors <= tkNumStaticColors);
// Open the key for the system color settings.
lRet = RegOpenKeyExA(HKEY_CURRENT_USER,
"Control Panel\\Colors",
0,
KEY_QUERY_VALUE,
&hkSysColors);
if ( lRet != ERROR_SUCCESS )
{
goto GetRegistrySysColors_exit;
}
// Read each system color value. The names are stored in the global
// array of char *, gaszSysClrNames.
for (i = 0; i < nColors; i++)
{
cjColor = sizeof(achColor);
lRet = RegQueryValueExA(hkSysColors,
(LPSTR) gaszSysClrNames[i],
(LPDWORD) NULL,
&dwDataType,
(LPBYTE) achColor,
&cjColor);
TKASSERT(lRet != ERROR_MORE_DATA);
if ( lRet == ERROR_SUCCESS && dwDataType == REG_SZ )
{
DWORD r, g, b;
sscanf(achColor, "%ld %ld %ld", &r, &g, &b);
pcr[i] = RGB(r, g, b);
}
}
bRet = TRUE;
GetRegistrySysColors_exit:
if (hkSysColors)
RegCloseKey(hkSysColors);
return bRet;
}
#endif
/******************************Public*Routine******************************\
* GrabStaticEntries
*
* Support routine for RealizePaletteNow to manage the static system color
* usage.
*
* This function will save the current static system color usage state.
* It will fail if:
*
* 1. TK is not in "sys color in use state but system palette is in
* SYSPAL_NOSTATIC mode. This means that another app still possesses
* the static system colors. This this happens, GrabStaticEntries
* will post a message to cause TK to try again (by calling
* DelayPaletteRealization).
*
* Side effect:
* If system colors are changed, then WM_SYSCOLORCHANGE message is
* broadcast to all top level windows.
*
* DelayPaletteRealization may be called in case 2 above, resulting in
* a WM_USER message being posted to our message queue.
*
* Returns:
* TRUE if successful, FALSE otherwise (see above).
*
* History:
* 26-Apr-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static BOOL GrabStaticEntries(HDC hdc)
{
int i;
BOOL bRet = FALSE;
// Do nothing if sys colors already in use.
if ( !tkSystemColorsInUse )
{
// Take possession only if no other app has the static colors.
// How can we tell? If the return from SetSystemPaletteUse is
// SYSPAL_STATIC, then no other app has the statics. If it is
// SYSPAL_NOSTATIC, someone else has them and we must fail.
//
// SetSystemPaletteUse is properly synchronized internally
// so that it is atomic.
//
// Because we are relying on SetSystemPaletteUse to synchronize TK,
// it is important to observe the following order for grabbing and
// releasing:
//
// Grab call SetSystemPaletteUse and check for SYSPAL_STATIC
// save sys color settings
// set new sys color settings
//
// Release restore sys color settings
// call SetSystemPaletteUse
if ( SetSystemPaletteUse( hdc, SYSPAL_NOSTATIC ) == SYSPAL_STATIC )
{
// Save current sys color settings.
for (i = COLOR_SCROLLBAR; i <= COLOR_BTNHIGHLIGHT; i++)
gacrSave[i - COLOR_SCROLLBAR] = GetSysColor(i);
// Set b&w sys color settings. Put TK in "sys colors in use" state.
SetSysColors(tkNumStaticColors, gaiStaticIndex, gacrBlackAndWhite);
tkSystemColorsInUse = TRUE;
// Inform all other top-level windows of the system color change.
PostMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
bRet = TRUE;
}
// Sleep a little and then post message to try palette realization again
// later.
else
{
Sleep(0L);
DelayPaletteRealization();
}
}
else
bRet = TRUE;
return bRet;
}
/******************************Public*Routine******************************\
* ReleaseStaticEntries
*
* Support routine for RealizePaletteNow to manage the static system color
* usage.
*
* This function will reset the current static system color usage state.
* It will fail if:
*
* 1. TK is not in a "sys colors in use" state. If we are in this case,
* then the static system colors do not need to be released.
*
* Side effect:
* If system colors are changed, then WM_SYSCOLORCHANGE message is
* broadcast to all top level windows.
*
* Returns:
* TRUE if successful, FALSE otherwise (see above).
*
* History:
* 21-Jul-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static BOOL ReleaseStaticEntries(HDC hdc)
{
BOOL bRet = FALSE;
// Do nothing if sys colors not in use.
if ( tkSystemColorsInUse )
{
#if RESTORE_FROM_REGISTRY
// Replace saved system colors with registry values. We do it now
// rather than earlier because someone may have changed registry while
// TK app was running in the foreground (very unlikely, but it could
// happen).
//
// Also, we still try to save current setting in GrabStaticEntries so
// that if for some reason we fail to grab one or more of the colors
// from the registry, we can still fall back on what we grabbed via
// GetSysColors (even though there is a chance its the wrong color).
GetRegistrySysColors(gacrSave, tkNumStaticColors);
#endif
// Restore the saved system color settings.
SetSysColors(tkNumStaticColors, gaiStaticIndex, gacrSave);
// Return the system palette to SYSPAL_STATIC.
SetSystemPaletteUse( hdc, SYSPAL_STATIC );
// Inform all other top-level windows of the system color change.
PostMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
// Reset the "sys colors in use" state and return success.
tkSystemColorsInUse = FALSE;
bRet = TRUE;
}
return bRet;
}
// Default palette entry flags
#define PALETTE_FLAGS PC_NOCOLLAPSE
// Gamma correction factor * 10
#define GAMMA_CORRECTION 14
// Maximum color distance with 8-bit components
#define MAX_COL_DIST (3*256*256L)
// Number of static colors
#define STATIC_COLORS 20
// Flags used when matching colors
#define EXACT_MATCH 1
#define COLOR_USED 1
// Conversion tables for n bits to eight bits
#if GAMMA_CORRECTION == 10
// These tables are corrected for a gamma of 1.0
static unsigned char abThreeToEight[8] =
{
0, 0111 >> 1, 0222 >> 1, 0333 >> 1, 0444 >> 1, 0555 >> 1, 0666 >> 1, 0377
};
static unsigned char abTwoToEight[4] =
{
0, 0x55, 0xaa, 0xff
};
static unsigned char abOneToEight[2] =
{
0, 255
};
#else
// These tables are corrected for a gamma of 1.4
static unsigned char abThreeToEight[8] =
{
0, 63, 104, 139, 171, 200, 229, 255
};
static unsigned char abTwoToEight[4] =
{
0, 116, 191, 255
};
static unsigned char abOneToEight[2] =
{
0, 255
};
#endif
// Table which indicates which colors in a 3-3-2 palette should be
// replaced with the system default colors
#if GAMMA_CORRECTION == 10
static int aiDefaultOverride[STATIC_COLORS] =
{
0, 4, 32, 36, 128, 132, 160, 173, 181, 245,
247, 164, 156, 7, 56, 63, 192, 199, 248, 255
};
#else
static int aiDefaultOverride[STATIC_COLORS] =
{
0, 3, 24, 27, 64, 67, 88, 173, 181, 236,
247, 164, 91, 7, 56, 63, 192, 199, 248, 255
};
#endif
static unsigned char
ComponentFromIndex(int i, int nbits, int shift)
{
unsigned char val;
TKASSERT(nbits >= 1 && nbits <= 3);
val = i >> shift;
switch (nbits)
{
case 1:
return abOneToEight[val & 1];
case 2:
return abTwoToEight[val & 3];
case 3:
return abThreeToEight[val & 7];
}
return 0;
}
// System default colors
static PALETTEENTRY apeDefaultPalEntry[STATIC_COLORS] =
{
{ 0, 0, 0, 0 },
{ 0x80,0, 0, 0 },
{ 0, 0x80,0, 0 },
{ 0x80,0x80,0, 0 },
{ 0, 0, 0x80, 0 },
{ 0x80,0, 0x80, 0 },
{ 0, 0x80,0x80, 0 },
{ 0xC0,0xC0,0xC0, 0 },
{ 192, 220, 192, 0 },
{ 166, 202, 240, 0 },
{ 255, 251, 240, 0 },
{ 160, 160, 164, 0 },
{ 0x80,0x80,0x80, 0 },
{ 0xFF,0, 0, 0 },
{ 0, 0xFF,0, 0 },
{ 0xFF,0xFF,0, 0 },
{ 0, 0, 0xFF, 0 },
{ 0xFF,0, 0xFF, 0 },
{ 0, 0xFF,0xFF, 0 },
{ 0xFF,0xFF,0xFF, 0 }
};
/******************************Public*Routine******************************\
*
* UpdateStaticMapping
*
* Computes the best match between the current system static colors
* and a 3-3-2 palette
*
* History:
* Tue Aug 01 18:18:12 1995 -by- Drew Bliss [drewb]
* Created
*
\**************************************************************************/
static void
UpdateStaticMapping(PALETTEENTRY *pe332Palette)
{
HPALETTE hpalStock;
int iStatic, i332;
int iMinDist, iDist;
int iDelta;
int iMinEntry;
PALETTEENTRY *peStatic, *pe332;
hpalStock = GetStockObject(DEFAULT_PALETTE);
// The system should always have one of these
TKASSERT(hpalStock != NULL);
// Make sure there's the correct number of entries
TKASSERT(GetPaletteEntries(hpalStock, 0, 0, NULL) == STATIC_COLORS);
// Get the current static colors
GetPaletteEntries(hpalStock, 0, STATIC_COLORS, apeDefaultPalEntry);
// Zero the flags in the static colors because they are used later
peStatic = apeDefaultPalEntry;
for (iStatic = 0; iStatic < STATIC_COLORS; iStatic++)
{
peStatic->peFlags = 0;
peStatic++;
}
// Zero the flags in the incoming palette because they are used later
pe332 = pe332Palette;
for (i332 = 0; i332 < 256; i332++)
{
pe332->peFlags = 0;
pe332++;
}
// Try to match each static color exactly
// This saves time by avoiding the least-squares match for each
// exact match
peStatic = apeDefaultPalEntry;
for (iStatic = 0; iStatic < STATIC_COLORS; iStatic++)
{
pe332 = pe332Palette;
for (i332 = 0; i332 < 256; i332++)
{
if (peStatic->peRed == pe332->peRed &&
peStatic->peGreen == pe332->peGreen &&
peStatic->peBlue == pe332->peBlue)
{
TKASSERT(pe332->peFlags != COLOR_USED);
peStatic->peFlags = EXACT_MATCH;
pe332->peFlags = COLOR_USED;
aiDefaultOverride[iStatic] = i332;
break;
}
pe332++;
}
peStatic++;
}
// Match each static color as closely as possible to an entry
// in the 332 palette by minimized the square of the distance
peStatic = apeDefaultPalEntry;
for (iStatic = 0; iStatic < STATIC_COLORS; iStatic++)
{
// Skip colors already matched exactly
if (peStatic->peFlags == EXACT_MATCH)
{
peStatic++;
continue;
}
iMinDist = MAX_COL_DIST+1;
#if DBG
iMinEntry = -1;
#endif
pe332 = pe332Palette;
for (i332 = 0; i332 < 256; i332++)
{
// Skip colors already used
if (pe332->peFlags == COLOR_USED)
{
pe332++;
continue;
}
// Compute Euclidean distance squared
iDelta = pe332->peRed-peStatic->peRed;
iDist = iDelta*iDelta;
iDelta = pe332->peGreen-peStatic->peGreen;
iDist += iDelta*iDelta;
iDelta = pe332->peBlue-peStatic->peBlue;
iDist += iDelta*iDelta;
if (iDist < iMinDist)
{
iMinDist = iDist;
iMinEntry = i332;
}
pe332++;
}
TKASSERT(iMinEntry != -1);
// Remember the best match
aiDefaultOverride[iStatic] = iMinEntry;
pe332Palette[iMinEntry].peFlags = COLOR_USED;
peStatic++;
}
// Zero the flags in the static colors because they may have been
// set. We want them to be zero so the colors can be remapped
peStatic = apeDefaultPalEntry;
for (iStatic = 0; iStatic < STATIC_COLORS; iStatic++)
{
peStatic->peFlags = 0;
peStatic++;
}
// Reset the 332 flags because we may have set them
pe332 = pe332Palette;
for (i332 = 0; i332 < 256; i332++)
{
pe332->peFlags = PALETTE_FLAGS;
pe332++;
}
#if 0
for (iStatic = 0; iStatic < STATIC_COLORS; iStatic++)
{
PrintMessage("Static color %2d maps to %d\n",
iStatic, aiDefaultOverride[iStatic]);
}
#endif
}
/******************************Public*Routine******************************\
* FillRgbPaletteEntries
*
* Fills a PALETTEENTRY array with values required for a logical rgb palette.
* If tkSetStaticColorUsage has been called with TRUE, the static system
* colors will be overridden. Otherwise, the PALETTEENTRY array will be
* fixed up to contain the default static system colors.
*
* History:
* 26-Apr-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static PALETTEENTRY *
FillRgbPaletteEntries( PIXELFORMATDESCRIPTOR *Pfd,
PALETTEENTRY *Entries,
UINT Count
)
{
PALETTEENTRY *Entry;
UINT i;
if ( NULL != Entries )
{
for ( i = 0, Entry = Entries ; i < Count ; i++, Entry++ )
{
Entry->peRed = ComponentFromIndex(i, Pfd->cRedBits,
Pfd->cRedShift);
Entry->peGreen = ComponentFromIndex(i, Pfd->cGreenBits,
Pfd->cGreenShift);
Entry->peBlue = ComponentFromIndex(i, Pfd->cBlueBits,
Pfd->cBlueShift);
Entry->peFlags = PALETTE_FLAGS;
}
if ( 256 == Count)
{
// If app set static system color usage for fixed palette support,
// setup to take over the static colors. Otherwise, fixup the
// static system colors.
if ( tkUseStaticColors )
{
// Black and white already exist as the only remaining static
// colors. Let those remap. All others should be put into
// the palette (i.e., set PC_NOCOLLAPSE).
Entries[0].peFlags = 0;
Entries[255].peFlags = 0;
}
else
{
// The defaultOverride array is computed assuming a 332
// palette where red has zero shift, etc.
if ( (3 == Pfd->cRedBits) && (0 == Pfd->cRedShift) &&
(3 == Pfd->cGreenBits) && (3 == Pfd->cGreenShift) &&
(2 == Pfd->cBlueBits) && (6 == Pfd->cBlueShift) )
{
UpdateStaticMapping(Entries);
for ( i = 0 ; i < STATIC_COLORS ; i++)
{
Entries[aiDefaultOverride[i]] = apeDefaultPalEntry[i];
}
}
}
}
}
return( Entries );
}
/******************************Public*Routine******************************\
* FlushPalette
*
* Because of Win 3.1 compatibility, GDI palette mapping always starts
* at zero and stops at the first exact match. So if there are duplicates,
* the higher colors aren't mapped to--which is often a problem if we
* are trying to make to any of the upper 10 static colors. To work around
* this, we flush the palette to all black.
*
* This only needs to be done for the 8BPP (256 color) case.
*
\**************************************************************************/
static void
FlushPalette(HDC hdc, int nColors)
{
LOGPALETTE *pPal;
HPALETTE hpal, hpalOld;
int i;
if (nColors == 256)
{
pPal = (LOGPALETTE *) LocalAlloc(LMEM_FIXED|LMEM_ZEROINIT,
sizeof(LOGPALETTE) + nColors * sizeof(PALETTEENTRY));
if (pPal)
{
pPal->palVersion = 0x300;
pPal->palNumEntries = (WORD)nColors;
// Mark everything PC_NOCOLLAPSE and PC_RESERVED to force every thing
// into the palette. Colors are already black because we zero initialized
// during memory allocation.
for (i = 0; i < nColors; i++)
{
pPal->palPalEntry[i].peFlags = PC_NOCOLLAPSE | PC_RESERVED;
}
hpal = CreatePalette(pPal);
LocalFree(pPal);
hpalOld = SelectPalette(hdc, hpal, FALSE);
RealizePalette(hdc);
SelectPalette(hdc, hpalOld, FALSE);
DeleteObject(hpal);
}
}
}
static HPALETTE
CreateRGBPalette( HDC Dc )
{
PIXELFORMATDESCRIPTOR Pfd, *pPfd;
LOGPALETTE *LogPalette;
UINT Count;
if ( NULL == tkhpalette )
{
pPfd = &Pfd;
if ( PixelFormatDescriptorFromDc( Dc, pPfd ) )
{
/*
* Make sure we need a palette
*/
if ( (pPfd->iPixelType == PFD_TYPE_RGBA) &&
(pPfd->dwFlags & PFD_NEED_PALETTE) )
{
/*
* Note how palette is to be realized. Take over the
* system colors if either the pixel format requires it
* or the app wants it.
*/
tkUseStaticColors = ( pPfd->dwFlags & PFD_NEED_SYSTEM_PALETTE )
|| TK_USE_FIXED_332_PAL(windInfo.type);
Count = 1 << pPfd->cColorBits;
LogPalette = AllocateMemory( sizeof(LOGPALETTE) +
Count * sizeof(PALETTEENTRY));
if ( NULL != LogPalette )
{
LogPalette->palVersion = 0x300;
LogPalette->palNumEntries = (WORD)Count;
FillRgbPaletteEntries( pPfd,
&LogPalette->palPalEntry[0],
Count );
tkhpalette = CreatePalette(LogPalette);
FreeMemory(LogPalette);
FlushPalette(Dc, Count);
RealizePaletteNow( Dc, tkhpalette, FALSE );
}
}
}
}
return( tkhpalette );
}
static HPALETTE
CreateCIPalette( HDC Dc )
{
PIXELFORMATDESCRIPTOR Pfd;
LOGPALETTE *LogicalPalette;
HPALETTE StockPalette;
UINT PaletteSize, StockPaletteSize, EntriesToCopy;
if ( (Dc != NULL) && (NULL == tkhpalette) )
{
if ( PixelFormatDescriptorFromDc( Dc, &Pfd ) )
{
if ( Pfd.iPixelType == PFD_TYPE_COLORINDEX )
{
/*
* Note how palette is to be realized (Is this the correct place to do this?)
*/
tkUseStaticColors = ( Pfd.dwFlags & PFD_NEED_SYSTEM_PALETTE )
|| TK_USE_FIXED_332_PAL(windInfo.type);
/*
* Limit the size of the palette to 256 colors.
* Why? Because this is what was decided.
*/
PaletteSize = (Pfd.cColorBits >= 8) ? 256 : (1 << Pfd.cColorBits);
LogicalPalette = AllocateZeroedMemory( sizeof(LOGPALETTE) +
(PaletteSize * sizeof(PALETTEENTRY)) );
if ( NULL != LogicalPalette )
{
LogicalPalette->palVersion = 0x300;
LogicalPalette->palNumEntries = (WORD)PaletteSize;
StockPalette = GetStockObject(DEFAULT_PALETTE);
StockPaletteSize = GetPaletteEntries( StockPalette, 0, 0, NULL );
/*
* start by copying default palette into new one
*/
EntriesToCopy = StockPaletteSize < PaletteSize ?
StockPaletteSize : PaletteSize;
GetPaletteEntries( StockPalette, 0, EntriesToCopy,
LogicalPalette->palPalEntry );
/*
* If we are taking possession of the system colors,
* must guarantee that 0 and 255 are black and white
* (respectively).
*/
if ( tkUseStaticColors && PaletteSize == 256 )
{
int i;
LogicalPalette->palPalEntry[0].peRed =
LogicalPalette->palPalEntry[0].peGreen =
LogicalPalette->palPalEntry[0].peBlue = 0x00;
LogicalPalette->palPalEntry[255].peRed =
LogicalPalette->palPalEntry[255].peGreen =
LogicalPalette->palPalEntry[255].peBlue = 0xFF;
LogicalPalette->palPalEntry[0].peFlags =
LogicalPalette->palPalEntry[255].peFlags = 0;
/*
* All other entries should be remappable,
* so mark them as PC_NOCOLLAPSE.
*/
for ( i = 1; i < 255; i++ )
LogicalPalette->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
}
tkhpalette = CreatePalette(LogicalPalette);
FreeMemory(LogicalPalette);
RealizePaletteNow( Dc, tkhpalette, FALSE );
}
}
}
}
return( tkhpalette );
}
static BOOL
FindPixelFormat(HDC hdc, GLenum type)
{
PIXELFORMATDESCRIPTOR pfd;
int PfdIndex;
BOOL Result = FALSE;
if ( TK_MINIMUM_CRITERIA == windInfo.dmPolicy )
PfdIndex = FindBestPixelFormat(hdc, type, &pfd);
else if ( TK_EXACT_MATCH == windInfo.dmPolicy )
PfdIndex = FindExactPixelFormat(hdc, type, &pfd);
else if ( IsPixelFormatValid(hdc, windInfo.ipfd, &pfd) )
PfdIndex = windInfo.ipfd;
else
PfdIndex = 0;
if ( PfdIndex )
{
if ( SetPixelFormat(hdc, PfdIndex, &pfd) )
{
/*
* If this pixel format requires a palette do it now.
* In colorindex mode, create a logical palette only
* if the application needs to modify it.
*/
CreateRGBPalette( hdc );
Result = TRUE;
}
else
{
PrintMessage("SetPixelFormat failed\n");
}
}
else
{
PrintMessage("Selecting a pixel format failed\n");
}
return(Result);
}
static int
FindBestPixelFormat(HDC hdc, GLenum type, PIXELFORMATDESCRIPTOR *ppfd)
{
PIXELFORMATDESCRIPTOR pfd;
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
if (TK_IS_DOUBLE(type))
pfd.dwFlags |= PFD_DOUBLEBUFFER;
if (TK_IS_INDEX(type)) {
pfd.iPixelType = PFD_TYPE_COLORINDEX;
pfd.cColorBits = 8;
} else {
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
}
if (TK_HAS_ALPHA(type))
pfd.cAlphaBits = 8;
else
pfd.cAlphaBits = 0;
if (TK_HAS_ACCUM(type))
pfd.cAccumBits = pfd.cColorBits + pfd.cAlphaBits;
else
pfd.cAccumBits = 0;
if (TK_HAS_DEPTH(type)) {
if (TK_IS_DEPTH16(type))
pfd.cDepthBits = 16;
else
pfd.cDepthBits = 24;
} else {
pfd.cDepthBits = 0;
}
if (TK_HAS_STENCIL(type))
pfd.cStencilBits = 4;
else
pfd.cStencilBits = 0;
pfd.cAuxBuffers = 0;
pfd.iLayerType = PFD_MAIN_PLANE;
*ppfd = pfd;
return ( ChoosePixelFormat(hdc, &pfd) );
}
static int
FindExactPixelFormat(HDC hdc, GLenum type, PIXELFORMATDESCRIPTOR *ppfd)
{
int i, MaxPFDs, Score, BestScore, BestPFD;
PIXELFORMATDESCRIPTOR pfd;
i = 1;
BestPFD = BestScore = 0;
do
{
MaxPFDs = DescribePixelFormat(hdc, i, sizeof(pfd), &pfd);
if ( MaxPFDs <= 0 )
return ( 0 );
Score = 0;
if ( !( ( pfd.dwFlags & PFD_DRAW_TO_WINDOW ) &&
( pfd.dwFlags & PFD_SUPPORT_OPENGL ) ) )
continue;
if ( pfd.iLayerType != PFD_MAIN_PLANE )
continue;
if ( ( pfd.iPixelType == PFD_TYPE_RGBA ) && ( TK_IS_INDEX(type) ) )
continue;
if ( ( pfd.iPixelType == PFD_TYPE_COLORINDEX ) && ( TK_IS_RGB(type) ) )
continue;
if ( ( pfd.dwFlags & PFD_DOUBLEBUFFER ) && ( TK_IS_SINGLE(type) ) )
continue;
if ( !( pfd.dwFlags & PFD_DOUBLEBUFFER ) && ( TK_IS_DOUBLE(type) ) )
continue;
/* If accum requested then accum rgb size must be > 0 */
/* If alpha requested then alpha size must be > 0 */
/* if accum & alpha requested then accum alpha size must be > 0 */
if ( TK_IS_RGB(type) )
{
if ( TK_HAS_ACCUM(type) )
{
if ( pfd.cAccumBits <= 0 )
continue;
}
else
{
if ( pfd.cAccumBits > 0 )
continue;
}
if ( TK_HAS_ALPHA(type) )
{
if ( pfd.cAlphaBits <= 0 )
continue;
if ( TK_HAS_ACCUM(type) && pfd.cAccumAlphaBits <= 0 )
continue;
}
else
{
if ( pfd.cAlphaBits > 0 )
continue;
}
}
if ( TK_HAS_DEPTH(type) )
{
if ( pfd.cDepthBits <= 0 )
continue;
}
else
{
if ( pfd.cDepthBits > 0 )
continue;
}
if ( TK_HAS_STENCIL(type) )
{
if ( pfd.cStencilBits <= 0 )
continue;
}
else
{
if ( pfd.cStencilBits > 0 )
continue;
}
Score = pfd.cColorBits;
if (Score > BestScore)
{
BestScore = Score;
BestPFD = i;
*ppfd = pfd;
}
} while (++i <= MaxPFDs);
return ( BestPFD );
}
static BOOL IsPixelFormatValid(HDC hdc, int ipfd, PIXELFORMATDESCRIPTOR *ppfd)
{
if ( ipfd > 0 )
{
if ( ipfd <= DescribePixelFormat(hdc, ipfd, sizeof(*ppfd), ppfd) )
{
if ( ( ppfd->dwFlags & PFD_DRAW_TO_WINDOW ) &&
( ppfd->dwFlags & PFD_SUPPORT_OPENGL ) )
{
return ( TRUE );
}
}
}
return ( FALSE );
}
static void
PrintMessage( const char *Format, ... )
{
va_list ArgList;
char Buffer[256];
va_start(ArgList, Format);
vsprintf(Buffer, Format, ArgList);
va_end(ArgList);
MESSAGEBOX(GetFocus(), Buffer, "Error", MB_OK);
}
static void
DelayPaletteRealization( void )
{
MSG Message;
TKASSERT(NULL!=tkhwnd);
/*
* Add a WM_USER message to the queue, if there isn't one there already.
*/
if (!PeekMessage(&Message, tkhwnd, WM_USER, WM_USER, PM_NOREMOVE) )
{
PostMessage( tkhwnd, WM_USER, 0, 0);
}
}
/******************************Public*Routine******************************\
* RealizePaletteNow
*
* Select the given palette in background or foreground mode (as specified
* by the bForceBackground flag), and realize the palette.
*
* If static system color usage is set, the system colors are replaced.
*
* History:
* 26-Apr-1994 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
long
RealizePaletteNow( HDC Dc, HPALETTE Palette, BOOL bForceBackground )
{
long Result = -1;
BOOL bHaveSysPal = TRUE;
TKASSERT( NULL!=Dc );
TKASSERT( NULL!=Palette );
// If static system color usage is set, prepare to take over the
// system palette.
if ( tkUseStaticColors )
{
// If foreground, take over the static colors. If background, release
// the static colors.
if ( !bForceBackground )
{
// If GrabStaticEntries succeeds, then it is OK to take over the
// static colors. If not, then GrabStaticEntries will have
// posted a WM_USER message for us to try again later.
bHaveSysPal = GrabStaticEntries( Dc );
}
else
{
// If we are currently using the system colors (tkSystemColorsInUse)
// and RealizePaletteNow was called with bForceBackground set, we
// are being deactivated and must release the static system colors.
ReleaseStaticEntries( Dc );
}
// Rerealize the palette.
//
// If set to TRUE, bForceBackground will force the palette to be realized
// as a background palette, regardless of focus. This will happen anyway
// if the TK window does not have the keyboard focus.
if ( (bForceBackground || bHaveSysPal) &&
UnrealizeObject( Palette ) &&
NULL != SelectPalette( Dc, Palette, bForceBackground ) )
{
Result = RealizePalette( Dc );
}
}
else
{
if ( NULL != SelectPalette( Dc, Palette, FALSE ) )
{
Result = RealizePalette( Dc );
}
}
return( Result );
}
static void
ForceRedraw( HWND Window )
{
MSG Message;
if (!PeekMessage(&Message, Window, WM_PAINT, WM_PAINT, PM_NOREMOVE) )
{
InvalidateRect( Window, NULL, FALSE );
}
}
static int
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 );
}
static void
DestroyThisWindow( HWND Window )
{
if ( NULL != Window )
{
DestroyWindow( Window );
}
}
/*
* This Should be called in response to a WM_DESTROY message
*/
static void
CleanUp( void )
{
HPALETTE hStock;
// Cleanup the palette.
if ( NULL != tkhpalette )
{
// If static system color usage is set, restore the system colors.
if ( tkUseStaticColors )
{
RealizePaletteNow( tkhdc, GetStockObject(DEFAULT_PALETTE), TRUE );
}
else
{
if ( hStock = GetStockObject( DEFAULT_PALETTE ) )
SelectPalette( tkhdc, hStock, FALSE );
}
DeleteObject( tkhpalette );
}
// Cleanup the RC.
if ( NULL != tkhrc )
{
wglMakeCurrent( tkhdc, NULL ); // Release first...
wglDeleteContext( tkhrc ); // then delete.
}
// Cleanup the DC.
if ( NULL != tkhdc )
{
ReleaseDC( tkhwnd, tkhdc );
}
// Be really nice and reset global values.
tkhwnd = NULL;
tkhdc = NULL;
tkhrc = NULL;
tkhpalette = NULL;
ExposeFunc = NULL;
ReshapeFunc = NULL;
IdleFunc = NULL;
DisplayFunc = NULL;
KeyDownFunc = NULL;
MouseDownFunc = NULL;
MouseUpFunc = NULL;
MouseMoveFunc = NULL;
}
static void *
AllocateMemory( size_t Size )
{
return( LocalAlloc( LMEM_FIXED, Size ) );
}
static void *
AllocateZeroedMemory( size_t Size )
{
return( LocalAlloc( LMEM_FIXED | LMEM_ZEROINIT, Size ) );
}
static void
FreeMemory( void *Chunk )
{
TKASSERT( NULL!=Chunk );
LocalFree( Chunk );
}
/*******************************************************************
* *
* Debugging functions go here *
* *
*******************************************************************/
#if DBGFUNC
static void
DbgPrintf( const char *Format, ... )
{
va_list ArgList;
char Buffer[256];
va_start(ArgList, Format);
vsprintf(Buffer, Format, ArgList);
va_end(ArgList);
printf("%s", Buffer );
fflush(stdout);
}
static void
pwi( void )
{
DbgPrintf("windInfo: x %d, y %d, w %d, h %d\n", windInfo.x, windInfo.y, windInfo.width, windInfo.height);
}
static void
pwr(RECT *pr)
{
DbgPrintf("Rect: left %d, top %d, right %d, bottom %d\n", pr->left, pr->top, pr->right, pr->bottom);
}
static void
ShowPixelFormat(HDC hdc)
{
PIXELFORMATDESCRIPTOR pfd, *ppfd;
int format;
ppfd = &pfd;
format = PixelFormatDescriptorFromDc( hdc, ppfd );
DbgPrintf("Pixel format %d\n", format);
DbgPrintf(" dwFlags - 0x%x", ppfd->dwFlags);
if (ppfd->dwFlags & PFD_DOUBLEBUFFER) DbgPrintf("PFD_DOUBLEBUFFER ");
if (ppfd->dwFlags & PFD_STEREO) DbgPrintf("PFD_STEREO ");
if (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) DbgPrintf("PFD_DRAW_TO_WINDOW ");
if (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) DbgPrintf("PFD_DRAW_TO_BITMAP ");
if (ppfd->dwFlags & PFD_SUPPORT_GDI) DbgPrintf("PFD_SUPPORT_GDI ");
if (ppfd->dwFlags & PFD_SUPPORT_OPENGL) DbgPrintf("PFD_SUPPORT_OPENGL ");
if (ppfd->dwFlags & PFD_GENERIC_FORMAT) DbgPrintf("PFD_GENERIC_FORMAT ");
if (ppfd->dwFlags & PFD_NEED_PALETTE) DbgPrintf("PFD_NEED_PALETTE ");
if (ppfd->dwFlags & PFD_NEED_SYSTEM_PALETTE) DbgPrintf("PFD_NEED_SYSTEM_PALETTE ");
DbgPrintf("\n");
DbgPrintf(" iPixelType - %d", ppfd->iPixelType);
if (ppfd->iPixelType == PFD_TYPE_RGBA) DbgPrintf("PGD_TYPE_RGBA\n");
if (ppfd->iPixelType == PFD_TYPE_COLORINDEX) DbgPrintf("PGD_TYPE_COLORINDEX\n");
DbgPrintf(" cColorBits - %d\n", ppfd->cColorBits);
DbgPrintf(" cRedBits - %d\n", ppfd->cRedBits);
DbgPrintf(" cRedShift - %d\n", ppfd->cRedShift);
DbgPrintf(" cGreenBits - %d\n", ppfd->cGreenBits);
DbgPrintf(" cGreenShift - %d\n", ppfd->cGreenShift);
DbgPrintf(" cBlueBits - %d\n", ppfd->cBlueBits);
DbgPrintf(" cBlueShift - %d\n", ppfd->cBlueShift);
DbgPrintf(" cAlphaBits - %d\n", ppfd->cAlphaBits);
DbgPrintf(" cAlphaShift - 0x%x\n", ppfd->cAlphaShift);
DbgPrintf(" cAccumBits - %d\n", ppfd->cAccumBits);
DbgPrintf(" cAccumRedBits - %d\n", ppfd->cAccumRedBits);
DbgPrintf(" cAccumGreenBits - %d\n", ppfd->cAccumGreenBits);
DbgPrintf(" cAccumBlueBits - %d\n", ppfd->cAccumBlueBits);
DbgPrintf(" cAccumAlphaBits - %d\n", ppfd->cAccumAlphaBits);
DbgPrintf(" cDepthBits - %d\n", ppfd->cDepthBits);
DbgPrintf(" cStencilBits - %d\n", ppfd->cStencilBits);
DbgPrintf(" cAuxBuffers - %d\n", ppfd->cAuxBuffers);
DbgPrintf(" iLayerType - %d\n", ppfd->iLayerType);
DbgPrintf(" bReserved - %d\n", ppfd->bReserved);
DbgPrintf(" dwLayerMask - 0x%x\n", ppfd->dwLayerMask);
DbgPrintf(" dwVisibleMask - 0x%x\n", ppfd->dwVisibleMask);
DbgPrintf(" dwDamageMask - 0x%x\n", ppfd->dwDamageMask);
}
#endif /* DBG */
Reference in New Issue Copy Permalink