This is tkwndws.c in view mode; [Download] [Up]
/* $Id */
/*
* $Log: tkwndws.c,v $
* Revision 1.3 1997/05/03 03:05:07 brianp
* added & to tkhpalette parameter to WMesaCreateContext()
*
* Revision 1.2 1997/04/14 21:58:35 brianp
* fixed C++ style comments
* added Cygnus-Win32 changes from Stephane
*
*/
/*
* This is the MS Window version of tk.
* Based on SGI code. See copyright below.
*/
/*
* (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.
*/
/* Mesa Tweaking by: Mark E. Peterson (markp@ic.mankato.mn.us) */
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gltk.h"
#include "gl\wmesa.h"
#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 */
/******************************************************************************/
#ifdef __CYGWIN32__
#define WNDCLASSW WNDCLASS
#endif
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
};
static HWND tkhwnd = NULL;
static HDC tkhdc = NULL;
static HPALETTE tkhpalette = NULL;
GLboolean tkPopupEnable = TRUE;
/* Fixed palette support.*/
#define BLACK PALETTERGB(0,0,0)
#define WHITE PALETTERGB(255,255,255)
#define NUM_STATIC_COLORS (COLOR_BTNHIGHLIGHT - COLOR_SCROLLBAR + 1)
static void (*ExposeFunc)(int, int) = NULL;
static void (*ReshapeFunc)(GLsizei, GLsizei) = 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";
long FAR PASCAL _export tkWndProc(HWND hWnd, UINT message, DWORD wParam, LONG 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);
static void ForceRedraw( HWND Window );
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
#define NCOLORS 17
float tkRGBMap[NCOLORS][3] = {
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{0,0,0},
{1,0,0},
{0,1,0},
{1,1,0},
{0,0,1},
{1,0,1},
{0,1,1},
{1,1,1}
};
/***************************************************************
* *
* Exported Functions go here *
* *
***************************************************************/
void tkErrorPopups(GLboolean bEnable)
{
tkPopupEnable = bEnable;
}
void tkCloseWindow(void)
{
DestroyThisWindow(tkhwnd);
/*
if (w.cMain) {
XMesaDestroyContext(w.cMain);
}
*/
#ifdef FX
fxMesaDestroyContext(NULL);
#else
WMesaDestroyContext();
#endif
}
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
*/
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)();
/* Code added by Li Wei (liwei@aiar.xjtu.edu.cn)*/
ForceRedraw(tkhwnd);
/* End modification by Li Wei */
}
}
}
void tkExposeFunc(void (*Func)(int, int))
{
ExposeFunc = Func;
}
void tkReshapeFunc(void (*Func)(GLsizei, GLsizei))
{
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;
}
GLenum tkInitWindowAW(char *title, BOOL bUnicode)
{
#ifdef FX
fxMesaContext Cur;
#else
WMesaContext Cur;
#endif
WNDCLASS wndclass;
RECT WinRect;
HANDLE hInstance;
ATOM aRegister;
GLenum Result = GL_FALSE,RGB_Flag=GL_TRUE,DB_Flag=GL_FALSE;
GLint attribs[100];
/* Build fxMesa attribute list */
i = 0;
if (TK_IS_DOUBLE(w.type)) {
attribs[i] = FXMESA_DOUBLEBUFFER;
i++;
}
if (TK_HAS_DEPTH(w.type)) {
attribs[i] = FXMESA_DEPTH_SIZE;
i++;
attribs[i] = 1;
i++;
}
if (TK_HAS_ALPHA(w.type)) {
attribs[i] = FXMESA_ALPHA_SIZE;
i++;
attribs[i] = 1;
i++;
}
if (TK_HAS_ACCUM(w.type)) {
attribs[i] = FXMESA_ACCUM_SIZE;
i++;
attribs[i] = 1;
i++;
}
if (TK_HAS_STENCIL(w.type)) {
attribs[i] = FXMESA_STENCIL_SIZE;
i++;
attribs[i] = 1;
i++;
}
attribs[i] = FXMESA_NONE; /* end of list */
hInstance = GetModuleHandle(NULL);
/* Must not define CS_CS_PARENTDC style.*/
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = (WNDPROC)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);
else
PrintMessage("Could not get an HDC for window 0x%08lX\n", tkhwnd );
}
else
PrintMessage("create window failed\n");
if (windInfo.type & TK_INDEX)
{
RGB_Flag=GL_FALSE;
tkSetRGBMap(NCOLORS,(float *) tkRGBMap);
}
if (windInfo.type & TK_DOUBLE)
DB_Flag=GL_TRUE;
#ifdef FX
/* XXX something's wrong here! */
Cur=fxMesaCreateContext(tkhwnd,tkhpalette,RGB_Flag,DB_Flag, attribs);
fxMesaMakeCurrent(Cur);
#else
Cur=WMesaCreateContext(tkhwnd,&tkhpalette,RGB_Flag,DB_Flag);
WMesaMakeCurrent(Cur);
#endif
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);
}
/******************************************************************************/
/*
* 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 )) )
{
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 = 0;
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 (intensity > 0xFF)
intensity = 0xFF;
pPalEntry[k].peRed =pPalEntry[k].peGreen = pPalEntry[k].peBlue = (BYTE) intensity;
pPalEntry[k].peFlags = 0;
}
}
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 = 0;
}
SetPaletteEntries( CurrentPal, 0, Count, Entries );
FreeMemory( Entries );
DelayPaletteRealization();
}
}
}
void tkSetRGBMap( int Size, float *Values )
{
HPALETTE CurrentPal;
int i;
if ( NULL != (CurrentPal = CreateCIPalette( tkhdc )) )
{
for (i=0; i<Size; i++)
tkSetOneColor(i,Values[i*3],Values[i*3+1],Values[i*3+2]);
}
}
/******************************************************************************/
void tkSwapBuffers(void)
{
#ifdef FX
fxMesaSwapBuffers();
#else
WMesaSwapBuffers();
#endif
}
/******************************************************************************/
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;
}
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) *
* *
***********************************************************************/
long FAR PASCAL _export
tkWndProc(HWND hWnd, UINT message, DWORD wParam, LONG lParam)
{
int key;
PAINTSTRUCT paint;
HDC hdc;
switch (message)
{
case WM_USER:
if ( RealizePaletteNow( tkhdc, tkhpalette) > 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_PALETTECHANGED:
if ( hWnd != (HWND) wParam )
RealizePaletteNow(tkhdc,tkhpalette);
return (0);
case WM_QUERYNEWPALETTE:
/* In the foreground! Let RealizePaletteNow do the work--*/
/* if management of the static system color usage is needed,*/
/* RealizePaletteNow will take care of it.*/
if ( NULL != tkhpalette )
{
if ( RealizePaletteNow(tkhdc, tkhpalette) > 0 )
ForceRedraw( hWnd );
return (1);
}
return (0);
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) > 0 )
ForceRedraw( hWnd );
}
}
/* 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 = 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));
}
static HPALETTE CreateCIPalette( HDC Dc )
{
LOGPALETTE *LogicalPalette;
HPALETTE StockPalette;
UINT PaletteSize, StockPaletteSize, EntriesToCopy;
if ( (Dc != NULL) && (NULL == tkhpalette) )
{
PaletteSize = 256; /*(Pfd.cColorBits >= 8) ? 256 : (1 << Pfd.cColorBits);*/
LogicalPalette = AllocateZeroedMemory( sizeof(LOGPALETTE) +
(PaletteSize * sizeof(PALETTEENTRY)) );
if ( NULL != LogicalPalette )
{
LogicalPalette->palVersion = 0x300;
LogicalPalette->palNumEntries = 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).
*/
tkhpalette = CreatePalette(LogicalPalette);
FreeMemory(LogicalPalette);
RealizePaletteNow( Dc, tkhpalette);
}
}
return( tkhpalette );
}
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.
\**************************************************************************/
static long RealizePaletteNow( HDC Dc, HPALETTE Palette)
{
long Result = -1;
TKASSERT( NULL!=Dc );
TKASSERT( NULL!=Palette );
if ( NULL != SelectPalette( Dc, Palette, FALSE ) )
{
Result = RealizePalette( Dc );
#ifndef FX
WMesaPaletteChange(Palette);
#endif
}
return( Result );
}
static void
ForceRedraw( HWND Window )
{
MSG Message;
if (!PeekMessage(&Message, Window, WM_PAINT, WM_PAINT, PM_NOREMOVE) )
{
InvalidateRect( Window, NULL, FALSE );
}
}
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 ((hStock = GetStockObject( DEFAULT_PALETTE ))!=NULL)
SelectPalette( tkhdc, hStock, FALSE );
DeleteObject( tkhpalette );
}
/* Cleanup the DC.*/
if ( NULL != tkhdc )
ReleaseDC( tkhwnd, tkhdc );
/* Be really nice and reset global values.*/
tkhwnd = NULL;
tkhdc = 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 );
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.