static void set_palette(ui_palette pal1, int start, int end)
{
PUCHAR pal = (PUCHAR) pal1;
HDC hDC;
int i;
// store new palette entries locally
memcpy(backpalette + 4 * start, pal, (end - start) * 4);
for (i = start; i <= end; i++) {
bmp->bmiColors[i].rgbRed = *(pal + 4 * (i - start) + 0);
bmp->bmiColors[i].rgbGreen = *(pal + 4 * (i - start) + 1);
bmp->bmiColors[i].rgbBlue = *(pal + 4 * (i - start) + 2);
bmp->bmiColors[i].rgbReserved = 0;
}
// update window/screen
#ifdef DDRAW_DRIVER
if (directX) {
IDirectDrawPalette_SetEntries(dxPalette, 0, start, end - start + 1,
(PALETTEENTRY *) pal);
} else
#endif
{
SetPaletteEntries(hPalette, start, end - start + 1,
(PALETTEENTRY *) pal);
hDC = GetDC(hWnd);
UnrealizeObject(hPalette);
RealizePalette(hDC);
ReleaseDC(hWnd, hDC);
win32_display();
}
}
void IupGLPalette(Ihandle* ih, int index, float r, float g, float b)
{
IGlControlData* gldata;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be an IupGLCanvas */
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
!IupClassMatch(ih, "glcanvas"))
return;
/* must be mapped */
gldata = (IGlControlData*)iupAttribGet(ih, "_IUP_GLCONTROLDATA");
if (!gldata->window)
return;
/* must have a palette */
if (gldata->palette)
{
PALETTEENTRY entry;
entry.peRed = (BYTE)(r*255);
entry.peGreen = (BYTE)(g*255);
entry.peBlue = (BYTE)(b*255);
entry.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(gldata->palette,index,1,&entry);
UnrealizeObject(gldata->device);
SelectPalette(gldata->device,gldata->palette,FALSE);
RealizePalette(gldata->device);
}
}
/***********************************************************************
* SetPaletteEntries [GDI32.@]
*
* Sets color values for range in palette.
*
* RETURNS
* Success: Number of entries that were set
* Failure: 0
*/
UINT WINAPI SetPaletteEntries(
HPALETTE hpalette, /* [in] Handle of logical palette */
UINT start, /* [in] Index of first entry to set */
UINT count, /* [in] Number of entries to set */
const PALETTEENTRY *entries) /* [in] Address of array of structures */
{
PALETTEOBJ * palPtr;
UINT numEntries;
TRACE("hpal=%p,start=%i,count=%i\n",hpalette,start,count );
hpalette = get_full_gdi_handle( hpalette );
if (hpalette == GetStockObject(DEFAULT_PALETTE)) return 0;
palPtr = GDI_GetObjPtr( hpalette, OBJ_PAL );
if (!palPtr) return 0;
numEntries = palPtr->count;
if (start >= numEntries)
{
GDI_ReleaseObj( hpalette );
return 0;
}
if (start+count > numEntries) count = numEntries - start;
memcpy( &palPtr->entries[start], entries, count * sizeof(PALETTEENTRY) );
GDI_ReleaseObj( hpalette );
UnrealizeObject( hpalette );
return count;
}
void IupGLPalette(Ihandle* ih, int index, float r, float g, float b)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be a IupGLCanvas */
if (!iupStrEqual(ih->iclass->name, "glcanvas"))
return;
/* must be mapped */
if (!ih->handle)
return;
/* must have a palette */
if (ih->data->palette)
{
PALETTEENTRY entry;
entry.peRed = (BYTE)(r*255);
entry.peGreen = (BYTE)(g*255);
entry.peBlue = (BYTE)(b*255);
entry.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(ih->data->palette,index,1,&entry);
UnrealizeObject(ih->data->device);
SelectPalette(ih->data->device,ih->data->palette,FALSE);
RealizePalette(ih->data->device);
}
}
/***********************************************************************
* DefWndControlColor
*
* Default colors for control painting.
*/
HBRUSH
DefWndControlColor(HDC hDC, UINT ctlType)
{
if (ctlType == CTLCOLOR_SCROLLBAR)
{
HBRUSH hb = GetSysColorBrush(COLOR_SCROLLBAR);
COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
SetTextColor(hDC, GetSysColor(COLOR_3DFACE));
SetBkColor(hDC, bk);
/* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
* we better use 0x55aa bitmap brush to make scrollbar's background
* look different from the window background.
*/
if ( bk == GetSysColor(COLOR_WINDOW))
return gpsi->hbrGray;
UnrealizeObject( hb );
return hb;
}
SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
{
SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
}
else
{
SetBkColor(hDC, GetSysColor(COLOR_3DFACE));
return GetSysColorBrush(COLOR_3DFACE);
}
return GetSysColorBrush(COLOR_WINDOW);
}
LONG WINAPI
WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static PAINTSTRUCT ps;
switch(uMsg) {
case WM_PAINT:
display();
BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
return 0;
case WM_SIZE:
glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));
PostMessage(hWnd, WM_PAINT, 0, 0);
return 0;
case WM_CHAR:
switch (wParam) {
case 27: /* ESC key */
PostQuitMessage(0);
break;
case ' ':
animate = !animate;
break;
}
return 0;
case WM_ACTIVATE:
if (IsIconic(hWnd))
animate = GL_FALSE;
else
animate = GL_TRUE;
return 0;
case WM_PALETTECHANGED:
if (hWnd == (HWND)wParam)
break;
/* fall through to WM_QUERYNEWPALETTE */
case WM_QUERYNEWPALETTE:
if (hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
return TRUE;
}
return FALSE;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
void OGLWindow::makePaletteChanged(WPARAM wParam)
{
if (hRC_ && hPalette_ && (HWND)wParam != hWND_)
{
wglMakeCurrent(hDC (), hRC_);
UnrealizeObject(hPalette_);
SelectPalette(hDC (), hPalette_, FALSE);
RealizePalette(hDC ());
}
}
void __fastcall TfrmAbout::WMQueryNewPalette(TMessage& /* Msg */)
{
if (hPalette != NULL) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
}
}
void __fastcall TfrmAbout::WMPaletteChanged(TMessage& Msg)
{
if (hPalette != NULL && (HWND) Msg.WParam != Handle) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
}
}
void
setPaletteIndex(int i, float r, float g, float b)
{
PALETTEENTRY pe;
pe.peRed = (BYTE) (255.0F * r);
pe.peGreen = (BYTE) (255.0F * g);
pe.peBlue = (BYTE) (255.0F * b);
pe.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(hPalette, i, 1, &pe);
UnrealizeObject(hPalette);
}
static void DrawDragDropRectRaw(Draw& draw, const Rect& rc, HBRUSH brush, int width)
{
#ifdef SYSTEMDRAW
SystemDraw *w = dynamic_cast<SystemDraw *>(&draw);
if(w) {
SystemDraw& draw = *w;
UnrealizeObject(brush);
HGDIOBJ old_brush = SelectObject(draw, brush);
SetBrushOrgEx(draw, ~rc.left, ~rc.top, NULL);
Size size = rc.Size();
enum { NOTPATINVERT = 0x00A50065 };
if(2 * width >= min(size.cx, size.cy))
::PatBlt(draw, rc.left, rc.top, size.cx, size.cy, NOTPATINVERT);
else
{
::PatBlt(draw, rc.left, rc.top, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.bottom - width, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
::PatBlt(draw, rc.right - width, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
}
SelectObject(draw, old_brush);
}
#else
UnrealizeObject(brush);
HGDIOBJ old_brush = SelectObject(draw, brush);
SetBrushOrgEx(draw, ~rc.left, ~rc.top, NULL);
Size size = rc.Size();
enum { NOTPATINVERT = 0x00A50065 };
if(2 * width >= min(size.cx, size.cy))
::PatBlt(draw, rc.left, rc.top, size.cx, size.cy, NOTPATINVERT);
else
{
::PatBlt(draw, rc.left, rc.top, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.bottom - width, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
::PatBlt(draw, rc.right - width, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
}
SelectObject(draw, old_brush);
#endif
}
BOOL OGLWindow::queryNewPalette()
{
if (hRC_ && hPalette_)
{
wglMakeCurrent(hDC (), hRC_);
UnrealizeObject(hPalette_);
SelectPalette(hDC (), hPalette_, FALSE);
RealizePalette(hDC ());
return TRUE;
}
return FALSE;
}
/*
* _ClearWindow - erase a window
*/
void _ClearWindow( LPWDATA w )
{
HWND hwnd;
hwnd = w->hwnd;
/*** Clear the w->image array ***/
#ifdef _MBCS
{
mb_char mbc;
int count;
mbc = _mbsnextc( (unsigned char *)" " );
for( count=0; count < w->width * w->height; count++ ) {
w->image[count] = mbc; /* store space in w->image */
}
}
#else
FARmemset( w->image, 0x20, w->width*w->height );
#endif
#if defined( __OS2__ )
{
HPS ps;
RECTL rcl;
ps = WinGetPS( hwnd );
WinQueryWindowRect( hwnd, &rcl );
WinFillRect( ps, &rcl, CLR_WHITE );
WinReleasePS( ps );
}
#else
{
RECT rect;
HDC dc;
dc = GetDC( hwnd );
#ifndef __NT__
UnrealizeObject( w->brush );
#endif
SelectObject( dc, w->brush );
#ifdef __NT__
SetBrushOrgEx( dc, 0, 0, NULL );
#endif
GetClientRect( hwnd, &rect );
FillRect( dc, &rect, w->brush );
ReleaseDC( hwnd, dc );
}
#endif
} /* _ClearWindow */
/*
* _DisplayAllLines - show all visible lines...
*/
void _DisplayAllLines( LPWDATA w, int clearFlag )
{
LPLDATA ld;
int i,end;
DWORD ln;
#ifdef __OS2__
#else
HDC dc;
RECT rect;
HBRUSH oldBrush;
#endif
/*** If needed, clear the window to avoid residue ***/
if( clearFlag ) {
#ifdef __OS2__
/* Clearing done for OS/2 in _DisplayLineInWindowWithColor */
#else
/* Clearing doesn't always work as with OS/2, so it's done here */
dc = GetDC( w->hwnd );
#ifndef __NT__
UnrealizeObject( w->brush );
#endif
oldBrush = SelectObject( dc, w->brush );
#ifdef __NT__
SetBrushOrgEx( dc, 0, 0, NULL );
#endif
GetClientRect( w->hwnd, &rect );
FillRect( dc, &rect, w->brush );
SelectObject( dc, oldBrush );
ReleaseDC( w->hwnd, dc );
#endif
}
ln = w->TopLineNumber;
ld = _GetLineDataPointer( w, ln );
end = w->height;
for( i=1; i<end; i++ ) {
if( ld == NULL ) {
_DisplayLineInWindow( w, i, " " );
} else {
_DisplayLineInWindow( w, i, ld->data );
ln++;
ld = _GetLineDataPointer( w, ln );
}
}
} /* _DisplayAllLines */
void IupGLPalette (Ihandle* self, int index, float r, float g, float b)
{
GLData* d = (GLData*)IupGetAttribute(self,"_IUPGL_DATA");
if (d && d->palette)
{
PALETTEENTRY entry;
entry.peRed = (BYTE)(r*255);
entry.peGreen = (BYTE)(g*255);
entry.peBlue = (BYTE)(b*255);
entry.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(d->palette,index,1,&entry);
UnrealizeObject(d->device);
SelectPalette(d->device,d->palette,FALSE);
RealizePalette(d->device);
}
}
static void DIB_RealizePalette(_THIS)
{
if ( screen_pal != NULL ) {
HDC hdc;
hdc = GetDC(SDL_Window);
#ifndef _WIN32_WCE
UnrealizeObject(screen_pal);
#endif
SelectPalette(hdc, screen_pal, FALSE);
if ( RealizePalette(hdc) ) {
InvalidateRect(SDL_Window, NULL, FALSE);
}
ReleaseDC(SDL_Window, hdc);
}
}
void GifDecoder::Clean()
{
mNbImages = 0;
if(mGlobalPalette != NULL) {
UnrealizeObject(mGlobalPalette);
DeleteObject(mGlobalPalette);
mGlobalPalette = NULL;
}
for(int lCounter = 0; lCounter < MR_MAX_IMAGES; lCounter++) {
if(mBitmap[lCounter] != NULL) {
DeleteObject(mBitmap[lCounter]);
mBitmap[lCounter] = NULL;
mDelay[lCounter] = 0;
}
}
}
Standard_EXPORTEXTERN long InterfaceGraphic_RealizePalette ( HDC hdc, HPALETTE hPal, BOOL fBkg, BOOL fUseStatic ) {
int i;
long retVal = 0;
if ( fUseStatic ) {
if ( !s_sysUse )
for ( i = 0; i < NB_STATIC_COLORS; ++i ) s_sysPal[ i ] = GetSysColor ( s_sysPalIdx[ i ] );
SetSystemPaletteUse ( hdc, fBkg ? SYSPAL_STATIC : SYSPAL_NOSTATIC );
if ( UnrealizeObject ( hPal ) && SelectPalette ( hdc, hPal, fBkg ) ) retVal = RealizePalette ( hdc );
if ( fBkg ) {
SetSysColors ( NB_STATIC_COLORS, s_sysPalIdx, s_sysPal );
s_sysUse = FALSE;
} else {
SetSysColors ( NB_STATIC_COLORS, s_sysPalIdx, s_sysPalBW );
s_sysUse = TRUE;
} // end else
#pragma warning(push)
#pragma warning(disable:4306) /* level 4 warning on cast of int to HWND in HWND_BROADCAST macro */
PostMessage ( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0 );
#pragma warning(pop)
} else {
SelectPalette ( hdc, hPal, FALSE );
retVal = RealizePalette ( hdc );
} // end else
return retVal;
} // end RealizePaletteNow
__declspec( dllexport ) long InterfaceGraphic_RealizePalette ( HDC hdc, HPALETTE hPal, BOOL fBkg, BOOL fUseStatic ) {
int i;
long retVal = 0;
if ( fUseStatic ) {
if ( !s_sysUse )
for ( i = 0; i < NB_STATIC_COLORS; ++i ) s_sysPal[ i ] = GetSysColor ( s_sysPalIdx[ i ] );
SetSystemPaletteUse ( hdc, fBkg ? SYSPAL_STATIC : SYSPAL_NOSTATIC );
if ( UnrealizeObject ( hPal ) && SelectPalette ( hdc, hPal, fBkg ) ) retVal = RealizePalette ( hdc );
if ( fBkg ) {
SetSysColors ( NB_STATIC_COLORS, s_sysPalIdx, s_sysPal );
s_sysUse = FALSE;
} else {
SetSysColors ( NB_STATIC_COLORS, s_sysPalIdx, s_sysPalBW );
s_sysUse = TRUE;
} // end else
PostMessage ( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0 );
} else {
SelectPalette ( hdc, hPal, FALSE );
retVal = RealizePalette ( hdc );
} // end else
return retVal;
} // end RealizePaletteNow
WINEXPORT BOOL CALLBACK WdeInfoWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
WORD w;
RECT r;
HDC dc;
_wde_touch( lParam );
switch( message ) {
#if defined( __NT__ )
case WM_INITDIALOG:
SetWindowLong( hWnd, GWL_STYLE, WS_CHILD );
break;
#endif
case WM_SYSCOLORCHANGE:
#if defined( __NT__ )
WdeInfoColor = GetSysColor( COLOR_BTNFACE );
DeleteObject( WdeInfoBrush );
WdeInfoBrush = CreateSolidBrush( WdeInfoColor );
#endif
WdeCtl3dColorChange ();
break;
#ifdef __NT__
case WM_CTLCOLORBTN:
case WM_CTLCOLORSTATIC:
dc = (HDC)wParam;
SetBkColor( dc, WdeInfoColor );
return( WdeInfoBrush != NULL );
case WM_CTLCOLORMSGBOX:
case WM_CTLCOLOREDIT:
break;
#else
case WM_CTLCOLOR:
w = HIWORD( lParam );
if( w != CTLCOLOR_MSGBOX && w != CTLCOLOR_EDIT ) {
dc = (HDC)wParam;
SetBkColor( dc, WdeInfoColor );
return( WdeInfoBrush != NULL );
}
break;
#endif
case WM_ERASEBKGND:
#if defined( __NT__ )
if( WdeInfoColor != GetSysColor( COLOR_BTNFACE ) ) {
/* Fake it, this proc does not get it ... */
SendMessage( hWnd, WM_SYSCOLORCHANGE, (WPARAM)0, (LPARAM)0 );
}
#endif
GetClientRect( hWnd, &r );
UnrealizeObject( WdeInfoBrush );
FillRect( (HDC)wParam, &r, WdeInfoBrush );
return( TRUE );
case WM_COMMAND:
w = GET_WM_COMMAND_CMD( wParam, lParam );
switch( LOWORD( wParam ) ) {
case IDB_INFO_IDSTR:
if( w == CBN_EDITCHANGE || w == CBN_SELCHANGE ) {
WdeInfoLookupComboEntry( hWnd, w );
}
break;
case IDB_INFO_SET:
WdeChangeInfo();
SetFocus( WdeGetMainWindowHandle() );
break;
case IDB_INFO_RESET:
WdeResetInfo();
break;
case IDCANCEL:
WdeResetInfo();
SetFocus( WdeGetMainWindowHandle() );
break;
}
break;
}
return( FALSE );
}
void CRectTracker::Draw(CDC* pDC) const
{
// set initial DC state
VERIFY(pDC->SaveDC() != 0);
pDC->SetMapMode(MM_TEXT);
pDC->SetViewportOrg(0, 0);
pDC->SetWindowOrg(0, 0);
// get normalized rectangle
CRect rect = m_rect;
rect.NormalizeRect();
CPen* pOldPen = NULL;
CBrush* pOldBrush = NULL;
CGdiObject* pTemp;
int nOldROP;
// draw lines
if ((m_nStyle & (dottedLine|solidLine)) != 0)
{
if (m_nStyle & dottedLine)
pOldPen = pDC->SelectObject(CPen::FromHandle(blackDottedPen));
else
pOldPen = (CPen*)pDC->SelectStockObject(BLACK_PEN);
pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
nOldROP = pDC->SetROP2(R2_COPYPEN);
rect.InflateRect(+1, +1); // borders are one pixel outside
pDC->Rectangle(rect.left, rect.top, rect.right, rect.bottom);
pDC->SetROP2(nOldROP);
}
// if hatchBrush is going to be used, need to unrealize it
if ((m_nStyle & (hatchInside|hatchedBorder)) != 0)
UnrealizeObject(hatchBrush);
// hatch inside
if ((m_nStyle & hatchInside) != 0)
{
pTemp = pDC->SelectStockObject(NULL_PEN);
if (pOldPen == NULL)
pOldPen = (CPen*)pTemp;
pTemp = pDC->SelectObject(CBrush::FromHandle(hatchBrush));
if (pOldBrush == NULL)
pOldBrush = (CBrush*)pTemp;
pDC->SetBkMode(TRANSPARENT);
#ifndef _MAC
nOldROP = pDC->SetROP2(R2_MASKNOTPEN);
#else _MAC
nOldROP = pDC->SetROP2(R2_MERGENOTPEN);
#endif // _MAC
pDC->Rectangle(rect.left+1, rect.top+1, rect.right, rect.bottom);
pDC->SetROP2(nOldROP);
}
// draw hatched border
if ((m_nStyle & hatchedBorder) != 0)
{
pTemp = pDC->SelectObject(CBrush::FromHandle(hatchBrush));
if (pOldBrush == NULL)
pOldBrush = (CBrush*)pTemp;
pDC->SetBkMode(OPAQUE);
CRect rectTrue;
GetTrueRect(&rectTrue);
pDC->PatBlt(rectTrue.left, rectTrue.top, rectTrue.Width(),
rect.top-rectTrue.top, 0x000F0001 /* Pn */);
pDC->PatBlt(rectTrue.left, rect.bottom,
rectTrue.Width(), rectTrue.bottom-rect.bottom, 0x000F0001 /* Pn */);
pDC->PatBlt(rectTrue.left, rect.top, rect.left-rectTrue.left,
rect.Height(), 0x000F0001 /* Pn */);
pDC->PatBlt(rect.right, rect.top, rectTrue.right-rect.right,
rect.Height(), 0x000F0001 /* Pn */);
}
// draw resize handles
if ((m_nStyle & (resizeInside|resizeOutside)) != 0)
{
UINT mask = GetHandleMask();
for (int i = 0; i < 8; ++i)
{
if (mask & (1<<i))
{
GetHandleRect((TrackerHit)i, &rect);
pDC->FillSolidRect(rect, RGB(0, 0, 0));
}
}
}
// cleanup pDC state
if (pOldPen != NULL)
pDC->SelectObject(pOldPen);
if (pOldBrush != NULL)
pDC->SelectObject(pOldBrush);
VERIFY(pDC->RestoreDC(-1));
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Message
//////////////////////////////////////////////////////////////////////////////////////////////////////
LRESULT CLoginProcess::DefMainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch ( uMsg )
{
case WM_CTLCOLOREDIT:
{
if ((HWND)lParam == g_xChatEditBox.GetSafehWnd())
{
SetBkColor((HDC)wParam, RGB(0, 0, 0));
SetTextColor((HDC)wParam, RGB(255, 255, 255));
UnrealizeObject(m_hBrush);
POINT pt;
SetBrushOrgEx((HDC)wParam, 0, 0, &pt);
return (LRESULT)m_hBrush;
}
break;
}
case WM_LBUTTONDOWN:
OnLButtonDown(wParam, lParam);
break;
case WM_LBUTTONUP:
OnLButtonUp(wParam, lParam);
break;
case ID_SOCKCLIENT_EVENT_MSG:
g_xClientSocket.OnSocketMessage(wParam, lParam);
break;
case WM_KEYDOWN:
UpdateWindow(g_xMainWnd.GetSafehWnd());
OnKeyDown(wParam, lParam);
break;
case WM_SYSKEYDOWN:
{
if ( wParam == VK_RETURN )
{
g_xMainWnd.OnSysKeyDown(wParam, lParam);
}
return 0L;
}
case WM_MOVE:
{
OnWindowMove(wParam,lParam);
return 0L;
}
case WM_MOUSEMOVE:
OnMouseMove(wParam,lParam);
break;
case _WM_USER_MSG_INPUTTED:
{
switch(m_Progress)
{
case PRG_LOGIN:
case PRG_NEW_ACCOUNT:
OnKeyDown((WPARAM)VK_RETURN,NULL);
break;
case PRG_CHANGE_PASS:
break;
}
}
//case WM_PAINT:
// {
//if (m_Progress == PRG_PATCH)
// {
// RenderPatch(0);
//pPatch->DrawProgressImage();
// return 0l;
// }
// if (m_Progress == PRG_QUIT)
// {
//SendMessage(g_xMainWnd.GetSafehWnd(), WM_DESTROY, NULL, NULL);
// pPatch->DrawProgressImage();
// return 0l;
// }
// break;
// }
}
return CWHDefProcess::DefMainWndProc(hWnd, uMsg, wParam, lParam);
}
WINEXPORT BOOL CALLBACK WdeSplash( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
{
UINT msecs, timer, start;
HDC dc, tdc;
HBITMAP old;
HWND w666;
RECT rect, arect;
PAINTSTRUCT ps;
#ifdef __NT__
HINSTANCE hInstUser;
PFNLI pfnLoadImage;
#endif
static BITMAP bm;
static HBITMAP logo;
static HBRUSH brush;
static COLORREF color;
switch( message ) {
case WM_SYSCOLORCHANGE:
WdeCtl3dColorChange();
break;
case WM_DESTROY:
if( logo ) {
DeleteObject( logo );
}
if( brush ) {
DeleteObject( brush );
}
break;
case WM_INITDIALOG:
msecs = *(UINT *)lParam;
if( msecs ) {
timer = SetTimer( hDlg, ABOUT_TIMER, msecs, NULL );
if( timer ) {
SET_DLGDATA( hDlg, (LONG)timer );
}
}
#ifdef __NT__
hInstUser = GetModuleHandle( "USER32.DLL" );
pfnLoadImage = (PFNLI)GetProcAddress( hInstUser, "LoadImageA" );
if( pfnLoadImage != NULL ) {
logo = pfnLoadImage( hInstWde, "AboutLogo", IMAGE_BITMAP, 0, 0,
LR_LOADMAP3DCOLORS );
} else {
#endif
logo = LoadBitmap( hInstWde, "AboutLogo" );
#ifdef __NT__
}
#endif
#if 0
color = GetSysColor( COLOR_BTNFACE );
color = RGB( 128, 128, 128 );
#endif
color = GetSysColor( COLOR_BTNFACE );
brush = CreateSolidBrush( color );
GetObject( logo, sizeof( BITMAP ), &bm );
return( TRUE );
#if 0
#ifdef __NT__
case WM_CTLCOLORSTATIC:
if( brush != NULL ) {
dc = (HDC)wParam;
SetBkColor( dc, color );
return( (LRESULT)brush );
}
break;
#else
case WM_CTLCOLOR:
if( brush != NULL ) {
dc = (HDC)wParam;
if( HIWORD( lParam ) == CTLCOLOR_STATIC ) {
SetBkColor( dc, color );
}
return( (LRESULT)brush );
}
break;
#endif
case WM_ERASEBKGND:
if( brush != NULL ) {
GetClientRect( hDlg, &rect );
UnrealizeObject( brush );
FillRect( (HDC)wParam, &rect, brush );
return( TRUE );
}
break;
#endif
case WM_PAINT:
dc = BeginPaint( hDlg, &ps );
if( dc != NULL ) {
w666 = GetDlgItem( hDlg, 666 );
GetClientRect( w666, &rect );
GetClientRect( hDlg, &arect );
start = (arect.right - arect.left - bm.bmWidth) / 2;
MapWindowPoints( w666, hDlg, (POINT *)&rect, 2 );
tdc = CreateCompatibleDC( dc );
old = SelectObject( tdc, logo );
BitBlt( dc, start, rect.top + 20, bm.bmWidth, bm.bmHeight, tdc, 0, 0, SRCCOPY );
SelectObject( tdc, old );
DeleteDC( tdc );
EndPaint( hDlg, &ps );
}
break;
case WM_TIMER:
timer = (UINT)GET_DLGDATA( hDlg );
if( timer ) {
KillTimer( hDlg, timer );
}
EndDialog( hDlg, TRUE );
return( TRUE );
}
return( FALSE );
}
LRESULT APIENTRY
WndProc(
HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message) {
case WM_CREATE:
/*
** Set up for OpenGL rendering. Bind the rendering context to
** the same device context that the palette will be selected into.
*/
hDC = GetDC(hWnd);
setupPixelFormat(hDC);
setupPalette(hDC);
hGLRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hGLRC);
if (!checkExtension("SGI_index_texture")) {
char message[1024];
sprintf(message,
"SGI_index_texture is required by this application\n"
"but is not supported by the current OpenGL renderer.\n\n"
"Vendor: %s\nRenderer: %s\nVersion: %s",
glGetString(GL_VENDOR),
glGetString(GL_RENDERER),
glGetString(GL_VERSION));
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
hGLRC = NULL;
MessageBox(hWnd, message, "OpenGL Extension Required",
MB_ICONERROR | MB_OK);
exit(1);
}
init();
idleFunc = doRedraw;
return 0;
case WM_DESTROY:
/*
** Finish OpenGL rendering.
*/
idleFunc = NULL;
if (hGLRC) {
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
}
ReleaseDC(hWnd, hDC);
PostQuitMessage(0);
return 0;
case WM_SIZE:
if (hGLRC) {
winWidth = (int) LOWORD(lParam);
winHeight = (int) HIWORD(lParam);
resize();
return 0;
}
case WM_PALETTECHANGED:
/*
** Update palette mapping if this *is not* the active window.
*/
if (hGLRC && hPalette && (HWND) wParam != hWnd) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return 0;
}
break;
case WM_QUERYNEWPALETTE:
/*
** Update palette mapping if this *is* the active window.
*/
if (hGLRC && hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return TRUE;
}
break;
case WM_PAINT:
/*
** Update the window. Don't use the device context returned by
** BeginPaint as it won't have the right palette selected into it.
*/
if (hGLRC) {
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
redraw();
EndPaint(hWnd, &ps);
return 0;
}
break;
case WM_CHAR:
switch ((int)wParam) {
case VK_ESCAPE:
DestroyWindow(hWnd);
return 0;
default:
break;
}
break;
default:
break;
}
/* Deal with any unprocessed messages */
return DefWindowProc(hWnd, message, wParam, lParam);
}
/***********************************************************************
* UnrealizeObject (GDI.150)
*/
BOOL16 WINAPI UnrealizeObject16( HGDIOBJ16 obj )
{
return UnrealizeObject( obj );
}
/////////////////////////////////////////////////////////////////////////////
// AppWndProc( hwnd, uiMessage, wParam, lParam )
//
// The window proc for the app's main (tiled) window. This processes all
// of the parent window's messages.
//
LONG FAR PASCAL _export AppWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
BOOL f;
//is it the registered message? (this proc is called after the creation
//of the msgApp).
if (msg == msgApp) {
if (bShowRendering) {
HDC hdc = GetDC(hwndApp);
AppPaint(hwndApp, hdc);
ReleaseDC(hwndApp, hdc);
bShowRendering = (int)wParam; //sent a 0 to turn off bShowRendering.
}
return 0L;
}
//well, how about standard Windows messages?
switch (msg)
{
case WM_CREATE:
//let WM_SIZE do all the work.
break;
case WM_ACTIVATEAPP:
bAppActive = (BOOL)wParam;
wt_reset_input();
// *** Remap the system colors and deal with the palette
AppActivate(bAppActive);
if (hpalApp)
{
HDC hdc = GetDC(hwnd);
UnrealizeObject(hpalApp);
SelectPalette(hdc, hpalApp, FALSE);
RealizePalette(hdc);
ReleaseDC(hwnd, hdc);
}
break;
case WM_SIZE:
wt_reset_input();
nBitmapW = LOWORD(lParam); //new size.
nBitmapH = HIWORD(lParam);
nBitmapW /= StretchFactor;
nBitmapH /= StretchFactor;
//Windows DIBs, including WinG bitmaps, are always a multiple of
//32-bits wide. For us, using the typical 8-bit per pixel bitmap,
//that means we need to ensure the width is a multiple of 4. This
//is important because the WT engine treats a bitmap's width and
//pitch as one - there is no way for WT to draw into a bitmap
//using a width different than the pitch. So we force the bitmap's
//width to be a multiple of 4, to be both Windows and WT compatible.
//Note we could have patched WT to deal with the concept of a
//bitmap pitch, but that's too much change.
nBitmapW = ((nBitmapW+3)/4)*4;
if(Buffer)
{ //resizing, minimizing, maximizing.
HBITMAP hbm;
int Counter;
//Create a new 8-bit WinGBitmap with the new size
BufferHeader.Header.biWidth = nBitmapW;
BufferHeader.Header.biHeight = nBitmapH * Orientation;
//probably don't need to do this, but do it anyway.
for(Counter = 0;Counter < 256;Counter++) {
BufferHeader.aColors[Counter].rgbRed = ColorTable[Counter].rgbRed;
BufferHeader.aColors[Counter].rgbGreen = ColorTable[Counter].rgbGreen;
BufferHeader.aColors[Counter].rgbBlue = ColorTable[Counter].rgbBlue;
BufferHeader.aColors[Counter].rgbReserved = 0;
}
hbm = WinG.pCreateBitmap(Buffer,
(BITMAPINFO *)&BufferHeader, &pBuffer);
// Select it in and delete the old one
hbm = (HBITMAP)SelectObject(Buffer, hbm);
DeleteObject(hbm);
PatBlt(Buffer, 0,0,nBitmapW,nBitmapH, BLACKNESS);
wt_set_fb_mem(pBuffer); //tell WT about new bitmap address.
wt_reinit(nBitmapW,nBitmapH); //and about new bitmap size.
wt_render(); //and have WT render a frame.
}
else //first time.
{
// Create a new WinGDC and 8-bit WinGBitmap
HBITMAP hbm;
int Counter;
// Get WinG to recommend the fastest DIB format
if(WinG.pRecommendDIBFormat((BITMAPINFO *)&BufferHeader))
{
// make sure it's 8bpp and remember the orientation
BufferHeader.Header.biBitCount = 8;
BufferHeader.Header.biCompression = BI_RGB;
Orientation = BufferHeader.Header.biHeight;
if (Orientation > 0) {
DebugMsg("WT requires a top-down bitmap!\nYou are about to hit a brick wall at 90 MPH!");
PostQuitMessage(1); //works but slams palette. bummer.
}
}
else
{
// set it up ourselves
BufferHeader.Header.biSize = sizeof(BITMAPINFOHEADER);
BufferHeader.Header.biPlanes = 1;
BufferHeader.Header.biBitCount = 8;
BufferHeader.Header.biCompression = BI_RGB;
BufferHeader.Header.biSizeImage = 0;
BufferHeader.Header.biClrUsed = 0;
BufferHeader.Header.biClrImportant = 0;
}
BufferHeader.Header.biWidth = nBitmapW;
BufferHeader.Header.biHeight = nBitmapH * Orientation;
//#define BAD_PALETTE_CODE
#ifdef BAD_PALETTE_CODE
//This code sets an incorrect palette, but at least you can still use
//regular windows tools. Good for debugging.
HDC Screen;
RGBQUAD *pColorTable;
// create an identity palette from the DIB's color table
// get the 20 system colors as PALETTEENTRIES
Screen = GetDC(0);
GetSystemPaletteEntries(Screen,0,10,LogicalPalette.aEntries);
GetSystemPaletteEntries(Screen,246,10,
LogicalPalette.aEntries + 246);
ReleaseDC(0,Screen);
// initialize the logical palette and DIB color table
for(Counter = 0;Counter < 10;Counter++)
{
// copy the system colors into the DIB header
// WinG will do this in WinGRecommendDIBFormat,
// but it may have failed above so do it here anyway
BufferHeader.aColors[Counter].rgbRed =
LogicalPalette.aEntries[Counter].peRed;
BufferHeader.aColors[Counter].rgbGreen =
LogicalPalette.aEntries[Counter].peGreen;
BufferHeader.aColors[Counter].rgbBlue =
LogicalPalette.aEntries[Counter].peBlue;
BufferHeader.aColors[Counter].rgbReserved = 0;
LogicalPalette.aEntries[Counter].peFlags = 0;
BufferHeader.aColors[Counter + 246].rgbRed =
LogicalPalette.aEntries[Counter + 246].peRed;
BufferHeader.aColors[Counter + 246].rgbGreen =
LogicalPalette.aEntries[Counter + 246].peGreen;
BufferHeader.aColors[Counter + 246].rgbBlue =
LogicalPalette.aEntries[Counter + 246].peBlue;
BufferHeader.aColors[Counter + 246].rgbReserved = 0;
LogicalPalette.aEntries[Counter + 246].peFlags = 0;
}
for (i=0; i<256; i++) {
ColorTable[i].rgbRed = 0;
ColorTable[i].rgbGreen = 0;
ColorTable[i].rgbBlue = 0;
}
nColors = wt_load_palette();
for (i=0; i<nColors; i++) {
int r,g,b;
wt_get_palette_entry(i,&r,&g,&b);
ColorTable[i].rgbRed = r;
ColorTable[i].rgbGreen = g;
ColorTable[i].rgbBlue = b;
}
pColorTable = &ColorTable[0];
for(Counter = 10;Counter < 246;Counter++)
{
// copy from the original color table to the WinGBitmap's
// color table and the logical palette
BufferHeader.aColors[Counter].rgbRed =
LogicalPalette.aEntries[Counter].peRed =
pColorTable[Counter].rgbRed;
BufferHeader.aColors[Counter].rgbGreen =
LogicalPalette.aEntries[Counter].peGreen =
pColorTable[Counter].rgbGreen;
BufferHeader.aColors[Counter].rgbBlue =
LogicalPalette.aEntries[Counter].peBlue =
pColorTable[Counter].rgbBlue;
BufferHeader.aColors[Counter].rgbReserved = 0;
LogicalPalette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
}
hpalApp = CreatePalette((LOGPALETTE *)&LogicalPalette);
#else
//GOOD_PALETTE_CODE
//Working palette code. Has correct colors. And identity. Same frame
//rate as bad palette code. This really hoses Windows colors, so
//a GUI debugger's windows are really hard to read. I couldn't read the
//Symantec IDDE's windows - so I #ifdef'd the bad palette code in for
//debugging.
//Anyway, this code works. Need 3 things for identity, as far as I can tell:
//1. you have to be writing to your bitmap using a specific palette,
//2. this palette has to be made into a Windows palette, and selected.
//3. this palette has to be copied into the BitmapInfo header of the WinG
// bitmap, before creating it (actually as a parameter to creating it).
//
ClearSystemPalette();
CreateWTPalette();
for(Counter = 0;Counter < 256;Counter++) {
BufferHeader.aColors[Counter].rgbRed = ColorTable[Counter].rgbRed;
BufferHeader.aColors[Counter].rgbGreen = ColorTable[Counter].rgbGreen;
BufferHeader.aColors[Counter].rgbBlue = ColorTable[Counter].rgbBlue;
BufferHeader.aColors[Counter].rgbReserved = 0;
}
#endif
// Create a WinGDC and Bitmap, then select away
Buffer = WinG.pCreateDC();
hbm = WinG.pCreateBitmap(Buffer,
(BITMAPINFO *)&BufferHeader, &pBuffer);
// Store the old hbitmap to select back in before deleting
gbmOldMonoBitmap = (HBITMAP)SelectObject(Buffer, hbm);
PatBlt(Buffer, 0,0,nBitmapW,nBitmapH, BLACKNESS);
wt_set_fb_mem(pBuffer); //hack to get around WT's code.
strcpy(szDefaultWorldFileName, szModulePath);
strcat(szDefaultWorldFileName, DEFAULT_WORLD_FILEPATH);
wt_init(szDefaultWorldFileName, nBitmapW,nBitmapH);
AppSetCaption(DEFAULT_WORLD_FILETITLE);
wt_render();
}
bWTinitialized = TRUE;
break;
case WM_KEYDOWN:
//set WT's keyboard array, then do a WT cycle.
switch (wParam) {
case VK_UP:
kbPressed[kbUpArrow] = 1; break;
case VK_DOWN:
kbPressed[kbDownArrow] = 1; break;
case VK_LEFT:
kbPressed[kbLeftArrow] = 1; break;
case VK_RIGHT:
kbPressed[kbRightArrow] = 1; break;
case VK_CONTROL:
kbPressed[kbCtrl] = 1; break;
case VK_ESCAPE:
kbPressed[kbEsc] = 1;
//DestroyWindow() here? let's check to ensure that func
// will send the proper msgs to close stuff.
break;
case VK_SPACE:
kbPressed[kbSpace] = 1; break;
case VK_SHIFT:
kbPressed[kbLeftShift] = 1; break;
case VK_TAB:
kbPressed[kbAlt] = 1; break;
}
//tried using wt_input/wt_render/InvalidateRect sequence
//here, but was sometimes jerky (missed frames, actually),
//if there was too much keyboard activity.
//I think windows was collapsing queued/pending
//WM_PAINT messages, so that the app got one instead of a
//sudden stream. Anyhow now I draw immediately, and it works
//great. Note that AppIdle() processing is required to
//have acceleration/deceleration/monsters/events occur without
//keyboard input. I guess a timer could also be used.
//So I ended up using this helper routine to repaint.
AppDoCycle();
break;
case WM_KEYUP:
//set WT's keyboard array, then do a WT cycle.
switch (wParam) {
case VK_UP:
kbPressed[kbUpArrow] = 0; break;
case VK_DOWN:
kbPressed[kbDownArrow] = 0; break;
case VK_LEFT:
kbPressed[kbLeftArrow] = 0; break;
case VK_RIGHT:
kbPressed[kbRightArrow] = 0; break;
case VK_CONTROL:
kbPressed[kbCtrl] = 0; break;
case VK_ESCAPE:
kbPressed[kbEsc] = 0; break;
case VK_SPACE:
kbPressed[kbSpace] = 0; break;
case VK_SHIFT:
kbPressed[kbLeftShift] = 0; break;
case VK_TAB:
kbPressed[kbAlt] = 0; break;
}
AppDoCycle();
break;
case WM_LBUTTONDOWN:
break;
case WM_RBUTTONDOWN:
break;
case WM_MOUSEMOVE:
break;
case WM_COMMAND:
return AppCommand(hwnd,msg,wParam,lParam);
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_CLOSE:
break;
case WM_PALETTECHANGED:
if ((HWND)wParam == hwnd)
break;
// fall through to WM_QUERYNEWPALETTE
case WM_QUERYNEWPALETTE:
hdc = GetDC(hwnd);
if (hpalApp)
SelectPalette(hdc, hpalApp, FALSE);
f = RealizePalette(hdc);
ReleaseDC(hwnd,hdc);
if (f)
InvalidateRect(hwnd,NULL,TRUE);
return f;
case WM_PAINT:
hdc = BeginPaint(hwnd,&ps);
SelectPalette(hdc, hpalApp, FALSE);
RealizePalette(hdc);
AppPaint (hwnd,hdc);
EndPaint(hwnd,&ps);
return 0L;
}
return DefWindowProc(hwnd,msg,wParam,lParam);
}
LONG WINAPI __glutWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
POINT point; /* Point structure. */
PAINTSTRUCT ps; /* Paint structure. */
LPMINMAXINFO minmax; /* Minimum/maximum info structure. */
GLUTwindow* window; /* GLUT window associated with message. */
GLUTmenu* menu; /* GLUT menu associated with message. */
int x, y, width, height, key;
int button = -1;
switch(msg) {
case WM_CREATE:
return 0;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
case WM_DESTROY:
#if 0
/* TODO: need to add this. */
purgeStaleWindow(hwnd);
#endif
return 0;
case WM_PAINT:
window = __glutGetWindow(hwnd);
if (window) {
BeginPaint(hwnd, &ps); /* Must have this for some Win32 reason. */
#if TAKE_THIS_OUT
if (window->colormap) {
SelectPalette(window->hdc, window->colormap->cmap, FORCE_FOREGROUND);
RealizePalette(window->hdc); /* Remap the custom palette. */
}
#endif
EndPaint(hwnd, &ps);
if (window->win == hwnd) {
__glutPostRedisplay(window, GLUT_REPAIR_WORK);
} else if (window->overlay && window->overlay->win == hwnd) {
__glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
}
}
return 0;
case WM_SYSCHAR:
case WM_CHAR:
window = __glutGetWindow(hwnd);
if (!window) {
break;
}
/* Win32 is dumb and sends these messages only to the parent
window. Therefore, find out if we're in a child window and
call the child windows keyboard callback if we are. */
if (window->parent) {
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
hwnd = ChildWindowFromPoint(hwnd, point);
window = __glutGetWindow(hwnd);
}
if (window->keyboard) {
GetCursorPos(&point);
ScreenToClient(window->win, &point);
__glutSetWindow(window);
__glutModifierMask = 0;
if (GetKeyState(VK_SHIFT) < 0) /* < 0 = high order bit is on */
__glutModifierMask |= ShiftMask;
if (GetKeyState(VK_CONTROL) < 0)
__glutModifierMask |= ControlMask;
if (GetKeyState(VK_MENU) < 0)
__glutModifierMask |= Mod1Mask;
window->keyboard((char)wParam, point.x, point.y);
__glutModifierMask = (unsigned int) ~0;
}
return 0;
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
window = __glutGetWindow(hwnd);
if (!window) {
break;
}
/* Win32 is dumb and sends these messages only to the parent
window. Therefore, find out if we're in a child window and
call the child windows keyboard callback if we are. */
if (window->parent) {
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
hwnd = ChildWindowFromPoint(hwnd, point);
window = __glutGetWindow(hwnd);
}
if (window->special) {
switch (wParam) {
/* *INDENT-OFF* */
/* function keys */
case VK_F1: key = GLUT_KEY_F1; break;
case VK_F2: key = GLUT_KEY_F2; break;
case VK_F3: key = GLUT_KEY_F3; break;
case VK_F4: key = GLUT_KEY_F4; break;
case VK_F5: key = GLUT_KEY_F5; break;
case VK_F6: key = GLUT_KEY_F6; break;
case VK_F7: key = GLUT_KEY_F7; break;
case VK_F8: key = GLUT_KEY_F8; break;
case VK_F9: key = GLUT_KEY_F9; break;
case VK_F10: key = GLUT_KEY_F10; break;
case VK_F11: key = GLUT_KEY_F11; break;
case VK_F12: key = GLUT_KEY_F12; break;
/* directional keys */
case VK_LEFT: key = GLUT_KEY_LEFT; break;
case VK_UP: key = GLUT_KEY_UP; break;
case VK_RIGHT: key = GLUT_KEY_RIGHT; break;
case VK_DOWN: key = GLUT_KEY_DOWN; break;
/* *INDENT-ON* */
case VK_PRIOR:
/* VK_PRIOR is Win32's Page Up */
key = GLUT_KEY_PAGE_UP;
break;
case VK_NEXT:
/* VK_NEXT is Win32's Page Down */
key = GLUT_KEY_PAGE_DOWN;
break;
case VK_HOME:
key = GLUT_KEY_HOME;
break;
case VK_END:
key = GLUT_KEY_END;
break;
case VK_INSERT:
key = GLUT_KEY_INSERT;
break;
default:
goto defproc;
}
GetCursorPos(&point);
ScreenToClient(window->win, &point);
__glutSetWindow(window);
__glutModifierMask = 0;
if (GetKeyState(VK_SHIFT) < 0) /* < 0 = high order bit is on */
__glutModifierMask |= ShiftMask;
if (GetKeyState(VK_CONTROL) < 0)
__glutModifierMask |= ControlMask;
if (GetKeyState(VK_MENU) < 0)
__glutModifierMask |= Mod1Mask;
window->special(key, point.x, point.y);
__glutModifierMask = (unsigned int) ~0;
}
return 0;
case WM_LBUTTONDOWN:
button = GLUT_LEFT_BUTTON;
case WM_MBUTTONDOWN:
if (button < 0)
button = GLUT_MIDDLE_BUTTON;
case WM_RBUTTONDOWN:
if (button < 0)
button = GLUT_RIGHT_BUTTON;
/* finish the menu if we get a button down message (user must have
cancelled the menu). */
if (__glutMappedMenu) {
/* TODO: take this out once the menu on middle mouse stuff works
properly. */
if (button == GLUT_MIDDLE_BUTTON)
return 0;
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
__glutItemSelected = NULL;
__glutFinishMenu(hwnd, point.x, point.y);
return 0;
}
/* set the capture so we can get mouse events outside the window */
SetCapture(hwnd);
/* Win32 doesn't return the same numbers as X does when the mouse
goes beyond the upper or left side of the window. roll the
Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
x = LOWORD(lParam);
y = HIWORD(lParam);
if(x & 1 << 15) x -= (1 << 16);
if(y & 1 << 15) y -= (1 << 16);
window = __glutGetWindow(hwnd);
if (window) {
menu = __glutGetMenuByNum(window->menu[button]);
if (menu) {
point.x = LOWORD(lParam); point.y = HIWORD(lParam);
ClientToScreen(window->win, &point);
__glutMenuButton = button == GLUT_RIGHT_BUTTON ? TPM_RIGHTBUTTON :
button == GLUT_LEFT_BUTTON ? TPM_LEFTBUTTON :
0x0001;
__glutStartMenu(menu, window, point.x, point.y, x, y);
} else if (window->mouse) {
__glutSetWindow(window);
__glutModifierMask = 0;
if (GetKeyState(VK_SHIFT) < 0) /* < 0 = high order bit is on. */
__glutModifierMask |= ShiftMask;
if (GetKeyState(VK_CONTROL) < 0)
__glutModifierMask |= ControlMask;
if (GetKeyState(VK_MENU) < 0)
__glutModifierMask |= Mod1Mask;
window->mouse(button, GLUT_DOWN, x, y);
__glutModifierMask = (unsigned int)~0;
} else {
/* Stray mouse events. Ignore. */
}
}
return 0;
case WM_LBUTTONUP:
button = GLUT_LEFT_BUTTON;
case WM_MBUTTONUP:
if (button < 0)
button = GLUT_MIDDLE_BUTTON;
case WM_RBUTTONUP:
if (button < 0)
button = GLUT_RIGHT_BUTTON;
/* Bail out if we're processing a menu. */
if (__glutMappedMenu) {
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
/* if we're getting the middle button up signal, then something
on the menu was selected. */
if (button == GLUT_MIDDLE_BUTTON) {
return 0;
/* For some reason, the code below always returns -1 even
though the point IS IN THE ITEM! Therefore, just bail out if
we get a middle mouse up. The user must select using the
left mouse button. Stupid Win32. */
#if 0
int item = MenuItemFromPoint(hwnd, __glutHMenu, point);
printf("item = %d %d %d\n", item, point.x, point.y);
if (item != -1)
__glutItemSelected = (GLUTmenuItem*)GetMenuItemID(__glutHMenu, item);
else
__glutItemSelected = NULL;
__glutFinishMenu(hwnd, point.x, point.y);
#endif
} else {
__glutItemSelected = NULL;
__glutFinishMenu(hwnd, point.x, point.y);
}
return 0;
}
/* Release the mouse capture. */
ReleaseCapture();
window = __glutGetWindow(hwnd);
if (window && window->mouse) {
/* Win32 doesn't return the same numbers as X does when the
mouse goes beyond the upper or left side of the window. roll
the Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
x = LOWORD(lParam);
y = HIWORD(lParam);
if(x & 1 << 15) x -= (1 << 16);
if(y & 1 << 15) y -= (1 << 16);
__glutSetWindow(window);
__glutModifierMask = 0;
if (GetKeyState(VK_SHIFT) < 0) /* < 0 = high order bit is on */
__glutModifierMask |= ShiftMask;
if (GetKeyState(VK_CONTROL) < 0)
__glutModifierMask |= ControlMask;
if (GetKeyState(VK_MENU) < 0)
__glutModifierMask |= Mod1Mask;
window->mouse(button, GLUT_UP, x, y);
__glutModifierMask = (unsigned int)~0;
} else {
/* Window might have been destroyed and all the
events for the window may not yet be received. */
}
return 0;
case WM_ENTERMENULOOP:
/* KLUDGE: create a timer that fires every 100 ms when we start a
menu so that we can still process the idle & timer events (that
way, the timers will fire during a menu pick and so will the
idle func. */
SetTimer(hwnd, 1, 1, NULL);
return 0;
case WM_TIMER:
#if 0
/* if the timer id is 2, then this is the timer that is set up in
the main glut message processing loop, and we don't want to do
anything but acknowledge that we got it. It is used to prevent
CPU spiking when an idle function is installed. */
if (wParam == 2)
return 0;
#endif
/* only worry about the idle function and the timeouts, since
these are the only events we expect to process during
processing of a menu. */
/* we no longer process the idle functions (as outlined in the
README), since drawing can't be done until the menu has
finished...it's pretty lame when the animation goes on, but
doesn't update, so you get this weird jerkiness. */
#if 0
if (__glutIdleFunc)
__glutIdleFunc();
#endif
if (__glutTimerList)
handleTimeouts();
return 0;
case WM_EXITMENULOOP:
/* nuke the above created timer...we don't need it anymore, since
the menu is gone now. */
KillTimer(hwnd, 1);
return 0;
case WM_MENUSELECT:
if (lParam != 0)
__glutHMenu = (HMENU)lParam;
return 0;
case WM_COMMAND:
if (__glutMappedMenu) {
if (GetSubMenu(__glutHMenu, LOWORD(wParam)))
__glutItemSelected = NULL;
else
__glutItemSelected =
__glutGetUniqueMenuItem(__glutMappedMenu, LOWORD(wParam));
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
__glutFinishMenu(hwnd, point.x, point.y);
}
return 0;
case WM_MOUSEMOVE:
if (!__glutMappedMenu) {
window = __glutGetWindow(hwnd);
if (window) {
/* If motion function registered _and_ buttons held *
down, call motion function... */
x = LOWORD(lParam);
y = HIWORD(lParam);
/* Win32 doesn't return the same numbers as X does when the
mouse goes beyond the upper or left side of the window.
roll the Win32's 0..2^16 pointer co-ord range to 0..+/-2^15. */
if(x & 1 << 15) x -= (1 << 16);
if(y & 1 << 15) y -= (1 << 16);
if (window->motion && wParam &
(MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
__glutSetWindow(window);
window->motion(x, y);
}
/* If passive motion function registered _and_
buttons not held down, call passive motion
function... */
else if (window->passive &&
((wParam &
(MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) ==
0)) {
__glutSetWindow(window);
window->passive(x, y);
}
}
} else {
/* Motion events are thrown away when a pop up menu is
active. */
}
return 0;
case WM_GETMINMAXINFO:
/* this voodoo is brought to you by Win32 (again). It allows the
window to be bigger than the screen, and smaller than 100x100
(although it doesn't seem to help the y minimum). */
minmax = (LPMINMAXINFO)lParam;
minmax->ptMaxSize.x = __glutScreenWidth;
minmax->ptMaxSize.y = __glutScreenHeight;
minmax->ptMinTrackSize.x = 0;
minmax->ptMinTrackSize.y = 0;
minmax->ptMaxTrackSize.x = __glutScreenWidth +
GetSystemMetrics(SM_CXSIZE) * 2;
minmax->ptMaxTrackSize.y = __glutScreenHeight +
GetSystemMetrics(SM_CXSIZE) * 2 + GetSystemMetrics(SM_CYCAPTION);
return 0;
case WM_SIZE:
window = __glutGetWindow(hwnd);
if (window) {
#if 0
if (window->win != hwnd) {
/* Ignore ConfigureNotify sent to the overlay planes.
GLUT could get here because overlays select for
StructureNotify events to receive DestroyNotify. */
break;
}
#endif
width = LOWORD(lParam);
height = HIWORD(lParam);
if (width != window->width || height != window->height) {
#if 0
if (window->overlay) {
XResizeWindow(__glutDisplay, window->overlay->win, width, height);
}
#endif
window->width = width;
window->height = height;
__glutSetWindow(window);
/* Do not execute OpenGL out of sequence with respect
to the SetWindowPos request! */
GdiFlush();
window->reshape(width, height);
window->forceReshape = FALSE;
/* A reshape should be considered like posting a
repair request. */
__glutPostRedisplay(window, GLUT_REPAIR_WORK);
}
}
return 0;
case WM_SETCURSOR:
/* If the cursor is not in the client area, then we want to send
this message to the default window procedure ('cause its
probably in the border or title, and we don't handle that
cursor. otherwise, set our cursor. Win32 makes us set the
cursor every time the mouse moves (DUMB!). */
if(LOWORD(lParam) != HTCLIENT)
goto defproc;
window = __glutGetWindow(hwnd);
if (window) {
/* Since Win32 allows the parent to control a child windows
cursor, if the cursor is in a child of this window, bail
out. */
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
if (hwnd != ChildWindowFromPoint(hwnd, point))
break;
__glutCurrentWindow = window;
glutSetCursor(window->cursor);
}
/* TODO: check out the info in DevStudio on WM_SETCURSOR in the
DefaultAction section. */
return 1;
case WM_SETFOCUS:
window = __glutGetWindow(hwnd);
if (window) {
if (window->entry) {
window->entryState = WM_SETFOCUS;
__glutSetWindow(window);
window->entry(GLUT_ENTERED);
/* XXX Generation of fake passive notify? See how much
work the X11 code does to support fake passive notify
callbacks. */
}
}
return 0;
case WM_KILLFOCUS:
window = __glutGetWindow(hwnd);
if (window) {
if (window->entry) {
window->entryState = WM_KILLFOCUS;
__glutSetWindow(window);
window->entry(GLUT_LEFT);
}
}
return 0;
case WM_ACTIVATE:
window = __glutGetWindow(hwnd);
/* make sure we re-select the correct palette if needed */
if (LOWORD(wParam)) {
PostMessage(hwnd, WM_PALETTECHANGED, 0, 0);
}
if (window) {
GLUTwindow* child;
int visState;
visState = !IsIconic(window->win);
if (visState) { /* Not iconic. */
visState = IsWindowVisible(window->win);
}
if (visState != window->visState) {
if (window->windowStatus) {
window->visState = visState;
__glutSetWindow(window);
window->windowStatus(visState);
}
/* Since Win32 only sends an activate for the toplevel window,
update the visibility for all the child windows. */
child = window->children;
while (child) {
child->visState = visState;
if (child->windowStatus) {
child->visState = visState;
__glutSetWindow(child);
child->windowStatus(visState);
}
child = child->siblings;
}
}
}
return 0;
/* Colour Palette Management */
case WM_PALETTECHANGED:
if (hwnd == (HWND)wParam) /* don't respond to the message that we sent! */
break;
/* fall through to WM_QUERYNEWPALETTE */
case WM_QUERYNEWPALETTE:
window = __glutGetWindow(hwnd);
if (window && window->colormap) {
UnrealizeObject(window->colormap->cmap);
SelectPalette(window->hdc, window->colormap->cmap, FALSE);
RealizePalette(window->hdc);
return TRUE;
}
return FALSE;
#if 0
/* Miscellaneous messages (don't really need to enumerate them,
but it's good to know what you're not getting sometimes.) */
case WM_NCHITTEST:
/* this event is generated by every mouse move event. */
goto defproc;
case WM_NCMOUSEMOVE:
goto defproc;
case WM_NCACTIVATE:
goto defproc;
case WM_NCPAINT:
goto defproc;
case WM_NCCALCSIZE:
goto defproc;
case WM_NCCREATE:
goto defproc;
case WM_NCDESTROY:
goto defproc;
case WM_NCLBUTTONDOWN:
goto defproc;
case WM_SETTEXT:
goto defproc;
case WM_GETTEXT:
goto defproc;
case WM_ACTIVATEAPP:
goto defproc;
case WM_GETICON:
goto defproc;
case WM_ERASEBKGND:
goto defproc;
case WM_WINDOWPOSCHANGING:
goto defproc;
case WM_WINDOWPOSCHANGED:
goto defproc;
case WM_MOUSEACTIVATE:
goto defproc;
case WM_SHOWWINDOW:
goto defproc;
case WM_MOVING:
goto defproc;
case WM_MOVE:
goto defproc;
case WM_KEYUP:
goto defproc;
case WM_CAPTURECHANGED:
goto defproc;
case WM_SYSCOMMAND:
goto defproc;
case WM_ENTERSIZEMOVE:
goto defproc;
case WM_ENTERIDLE:
goto defproc;
#endif
default:
goto defproc;
}
defproc:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static PAINTSTRUCT ps;
static GLboolean left = GL_FALSE; /* left button currently down? */
static GLboolean right = GL_FALSE; /* right button currently down? */
static int omx, omy, mx, my;
switch(uMsg) {
case WM_PAINT:
BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
return 0;
case WM_SIZE:
Reshape(LOWORD(lParam), HIWORD(lParam));
PostMessage(hWnd, WM_PAINT, 0, 0);
return 0;
case WM_CHAR:
switch (wParam) {
case 27: /* ESC key */
PostQuitMessage(0);
break;
}
return 0;
case WM_LBUTTONDOWN:
/* if we don't set the capture we won't get mouse move
messages when the mouse moves outside the window. */
SetCapture(hWnd);
MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam);
ComputeMouseVector();
MouseState = 1;
return 0;
case WM_LBUTTONUP:
MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam);
if(MouseX & 1 << 15) MouseX -= (1 << 16);
if(MouseY & 1 << 15) MouseY -= (1 << 16);
ComputeMouseVector();
if(MouseState) SpinIt();
MouseState=0;
/* remember to release the capture when we are finished. */
ReleaseCapture();
return 0;
case WM_MOUSEMOVE:
MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam);
/* Win32 is pretty braindead about the x, y position that
it returns when the mouse is off the left or top edge
of the window (due to them being unsigned). therefore,
roll the Win32's 0..2^16 pointer co-ord range to the
more amenable (and useful) 0..+/-2^15. */
if(MouseX & 1 << 15) MouseX -= (1 << 16);
if(MouseY & 1 << 15) MouseY -= (1 << 16);
ComputeMouseVector();
if(MouseState) SpinIt();
return 0;
case WM_PALETTECHANGED:
if (hWnd == (HWND)wParam) break;
/* fall through to WM_QUERYNEWPALETTE */
case WM_QUERYNEWPALETTE:
if (hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
return TRUE;
}
return FALSE;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
static void test_gdi_objects(void)
{
BYTE buff[256];
HDC hdc = GetDC(NULL);
HPEN hp;
int i;
BOOL ret;
/* SelectObject() with a NULL DC returns 0 and sets ERROR_INVALID_HANDLE.
* Note: Under XP at least invalid ptrs can also be passed, not just NULL;
* Don't test that here in case it crashes earlier win versions.
*/
SetLastError(0);
hp = SelectObject(NULL, GetStockObject(BLACK_PEN));
ok(!hp && (GetLastError() == ERROR_INVALID_HANDLE || broken(!GetLastError())),
"SelectObject(NULL DC) expected 0, ERROR_INVALID_HANDLE, got %p, %u\n",
hp, GetLastError());
/* With a valid DC and a NULL object, the call returns 0 but does not SetLastError() */
SetLastError(0);
hp = SelectObject(hdc, NULL);
ok(!hp && !GetLastError(),
"SelectObject(NULL obj) expected 0, NO_ERROR, got %p, %u\n",
hp, GetLastError());
/* The DC is unaffected by the NULL SelectObject */
SetLastError(0);
hp = SelectObject(hdc, GetStockObject(BLACK_PEN));
ok(hp && !GetLastError(),
"SelectObject(post NULL) expected non-null, NO_ERROR, got %p, %u\n",
hp, GetLastError());
/* GetCurrentObject does not SetLastError() on a null object */
SetLastError(0);
hp = GetCurrentObject(NULL, OBJ_PEN);
ok(!hp && !GetLastError(),
"GetCurrentObject(NULL DC) expected 0, NO_ERROR, got %p, %u\n",
hp, GetLastError());
/* DeleteObject does not SetLastError() on a null object */
ret = DeleteObject(NULL);
ok( !ret && !GetLastError(),
"DeleteObject(NULL obj), expected 0, NO_ERROR, got %d, %u\n",
ret, GetLastError());
/* GetObject does not SetLastError() on a null object */
SetLastError(0);
i = GetObjectA(NULL, sizeof(buff), buff);
ok (!i && (GetLastError() == 0 || GetLastError() == ERROR_INVALID_PARAMETER),
"GetObject(NULL obj), expected 0, NO_ERROR, got %d, %u\n",
i, GetLastError());
/* GetObject expects ERROR_NOACCESS when passed an invalid buffer */
hp = SelectObject(hdc, GetStockObject(BLACK_PEN));
SetLastError(0);
i = GetObjectA(hp, (INT_PTR)buff, (LPVOID)sizeof(buff));
ok (!i && (GetLastError() == 0 || GetLastError() == ERROR_NOACCESS),
"GetObject(invalid buff), expected 0, ERROR_NOACCESS, got %d, %u\n",
i, GetLastError());
/* GetObjectType does SetLastError() on a null object */
SetLastError(0);
i = GetObjectType(NULL);
ok (!i && GetLastError() == ERROR_INVALID_HANDLE,
"GetObjectType(NULL obj), expected 0, ERROR_INVALID_HANDLE, got %d, %u\n",
i, GetLastError());
/* UnrealizeObject does not SetLastError() on a null object */
SetLastError(0);
i = UnrealizeObject(NULL);
ok (!i && !GetLastError(),
"UnrealizeObject(NULL obj), expected 0, NO_ERROR, got %d, %u\n",
i, GetLastError());
ReleaseDC(NULL, hdc);
}
LRESULT APIENTRY
WndProc(
HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message) {
case WM_CREATE:
/* initialize OpenGL rendering */
hDC = GetDC(hWnd);
setupPixelFormat(hDC);
setupPalette(hDC);
hGLRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hGLRC);
init();
return 0;
case WM_DESTROY:
/* finish OpenGL rendering */
if (hGLRC) {
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
}
if (hPalette) {
DeleteObject(hPalette);
}
ReleaseDC(hWnd, hDC);
PostQuitMessage(0);
return 0;
case WM_SIZE:
/* track window size changes */
if (hGLRC) {
winWidth = (int) LOWORD(lParam);
winHeight = (int) HIWORD(lParam);
resize();
return 0;
}
case WM_PALETTECHANGED:
/* realize palette if this is *not* the current window */
if (hGLRC && hPalette && (HWND) wParam != hWnd) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
break;
}
break;
case WM_QUERYNEWPALETTE:
/* realize palette if this is the current window */
if (hGLRC && hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return TRUE;
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
if (hGLRC) {
redraw();
}
EndPaint(hWnd, &ps);
return 0;
}
break;
case WM_CHAR:
/* handle keyboard input */
switch ((int)wParam) {
case VK_ESCAPE:
DestroyWindow(hWnd);
return 0;
default:
break;
}
break;
default:
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}