static HBITMAP WRReadBitmap( BYTE *data, long offset, BOOL core, bitmap_info *info )
{
DWORD size; /* generic size - used repeatedly */
BYTE _HUGE *mask_ptr; /* pointer to bit array in memory */
HDC hdc;
HPALETTE new_palette, old_palette;
BITMAPINFO *bm_info = NULL;
BITMAPCOREINFO *bm_core = NULL;
HBITMAP bitmap_handle;
int pos;
bitmap_handle = (HBITMAP)NULL;
if( core ) {
bm_core = WRReadCoreInfo( &data );
if( bm_core == NULL ) {
return( bitmap_handle );
}
size = BITS_TO_BYTES( bm_core->bmciHeader.bcWidth * bm_core->bmciHeader.bcBitCount,
bm_core->bmciHeader.bcHeight );
} else {
bm_info = WRReadDIBInfo( &data );
if( bm_info == NULL ) {
return( bitmap_handle );
}
size = BITS_TO_BYTES( bm_info->bmiHeader.biWidth * bm_info->bmiHeader.biBitCount,
bm_info->bmiHeader.biHeight );
}
pos = offset;
mask_ptr = __halloc( size, 1 );
if( mask_ptr != NULL ) {
WRReadInPieces( mask_ptr, data, size );
if( core ) {
BITMAPCOREHEADER *h;
h = &bm_core->bmciHeader;
/*
* This will cause a GP Fault!
*/
bitmap_handle = CreateBitmap( h->bcWidth, h->bcHeight, h->bcPlanes,
h->bcBitCount, mask_ptr );
} else {
if( bm_info->bmiHeader.biBitCount < 9 ) {
/* Bitmap has palette, create it */
new_palette = CreateDIBPalette( bm_info );
if( new_palette != NULL ) {
hdc = GetDC( (HWND)NULL );
old_palette = SelectPalette( hdc, new_palette, FALSE );
RealizePalette( hdc );
bitmap_handle = CreateDIBitmap( hdc, &bm_info->bmiHeader, CBM_INIT,
mask_ptr, bm_info, DIB_RGB_COLORS );
SelectPalette( hdc, old_palette, FALSE );
DeleteObject( new_palette );
ReleaseDC( (HWND)NULL, hdc );
}
} else {
/* Bitmap with no palette*/
hdc = GetDC( (HWND)NULL );
bitmap_handle = CreateDIBitmap( hdc, &bm_info->bmiHeader, CBM_INIT,
mask_ptr, bm_info, DIB_RGB_COLORS );
ReleaseDC( (HWND)NULL, hdc );
}
}
__hfree( mask_ptr );
}
if( core ) {
if( info != NULL ) {
info->u.bm_core = bm_core;
} else {
MemFree( bm_core );
}
} else {
if( info != NULL ) {
info->u.bm_info = bm_info;
} else {
MemFree( bm_info );
}
}
return( bitmap_handle );
}
BOOL CClientCapture::DrawBitmap(CDC *dc, HDC hDC, CRect *rect, CRect *dest, CBitmap &bitmap){
//////////////////////////////////////////////////////
// Create logical palette if device support a palette
if( dc->GetDeviceCaps(RASTERCAPS) & RC_PALETTE )
{
UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256);
LOGPALETTE *pLP = (LOGPALETTE *) new BYTE[nSize];
pLP->palVersion = 0x300;
pLP->palNumEntries = GetSystemPaletteEntries( *dc, 0, 255, pLP->palPalEntry );
// Create the palette
pal.CreatePalette( pLP );
delete[] pLP;
}
// END CREATE PALETTE
//////////////////////////////////////////////////////
/////////////////////////////
/////////////////////////////
BITMAP bm;
BITMAPINFOHEADER bi;
DWORD dwLen;
HANDLE handle;
HDC hPDC;
HPALETTE hPal;
ASSERT( bitmap.GetSafeHandle() );
// If a palette has not been supplied use defaul palette
hPal = (HPALETTE) pal.GetSafeHandle();
if (hPal==NULL)
hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
// Get bitmap information
bitmap.GetObject(sizeof(bm),(LPSTR)&bm);
// Initialize the bitmapinfoheader
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = bm.bmWidth;
bi.biHeight = bm.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = bm.bmPlanes * bm.bmBitsPixel;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
// Compute the size of the infoheader and the color table
int nColors = (1 << bi.biBitCount);
if( nColors > 256 )
nColors = 0;
dwLen = bi.biSize + nColors * sizeof(RGBQUAD);
// We need a device context to get the DIB from
hPDC = dc->GetSafeHdc();
//hDC = GetDC(NULL);
hPal = SelectPalette(hPDC,hPal,FALSE);
RealizePalette(hPDC);
// Allocate enough memory to hold bitmapinfoheader and color table
if(hDIB) GlobalFree( hDIB );
hDIB = GlobalAlloc(GMEM_FIXED,dwLen);
if (!hDIB){
SelectPalette(hPDC,hPal,FALSE);
return NULL;
}
lpbi = (LPBITMAPINFOHEADER)hDIB;
*lpbi = bi;
// Call GetDIBits with a NULL lpBits param, so the device driver
// will calculate the biSizeImage field
GetDIBits(hPDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);
bi = *lpbi;
// If the driver did not fill in the biSizeImage field, then compute it
// Each scan line of the image is aligned on a DWORD (32bit) boundary
if (bi.biSizeImage == 0){
bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8)
* bi.biHeight;
}
// Realloc the buffer so that it can hold all the bits
dwLen += bi.biSizeImage;
if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
hDIB = handle;
else{
GlobalFree(hDIB);
hDIB = 0;
// Reselect the original palette
SelectPalette(hDC,hPal,FALSE);
return NULL;
}
// Get the bitmap bits
lpbi = (LPBITMAPINFOHEADER)hDIB;
m_pBMI = (LPBITMAPINFO)hDIB;
m_pBits = (LPBYTE)hDIB + (bi.biSize + nColors * sizeof(RGBQUAD));
///////////////////////////////////////////////
///////////////////////////////////////////////
HPALETTE hOldPal = NULL; // Previous palette
// Get the DIB's palette, then select it into DC
if (&pal != NULL)
{
hPal = (HPALETTE) pal.m_hObject;
// Select as background since we have
// already realized in forground if needed
hOldPal = ::SelectPalette(hDC, hPal, TRUE);
}
/* Make sure to use the stretching mode best for color pictures */
::SetStretchBltMode(hDC, COLORONCOLOR);
BOOL bSuccess = FALSE;
UINT start(0), end, step_size(1);//, offset_y(0);
end = step_size;
if((UINT)bm.bmHeight < step_size)
end = (int)bm.bmHeight;
while(start < (UINT)bm.bmHeight){
GetDIBits( hPDC, (HBITMAP)bitmap.GetSafeHandle(),
start, // Start scan line
end - start, // # of scan lines
(LPBYTE) m_pBits, //lpbi // address for bitmap bits
(LPBITMAPINFO)lpbi, // address of bitmapinfo
(DWORD)DIB_RGB_COLORS); // Use RGB for color table
bSuccess = ::SetDIBitsToDevice(hDC, // hDC
rect->left, // DestX
rect->top, // DestY
RECTWIDTH(rect), // nDestWidth
RECTHEIGHT(rect), // nDestHeight
rect->left, // SrcX
(int)Height() -
rect->top -
RECTHEIGHT(rect), // SrcY
start, // nStartScan
end - start, // nNumScans
m_pBits, // lpBits
m_pBMI, // lpBitsInfo
DIB_RGB_COLORS); // wUsage
start = end;
end = start + step_size;
if((UINT)bm.bmHeight < end)
end = (UINT)bm.bmHeight;
}
/* Reselect old palette */
if (hOldPal != NULL)
{
::SelectPalette(hDC, hOldPal, TRUE);
}
return bSuccess;
}
void Picker_HandleDrawItem(HWND hWnd, LPDRAWITEMSTRUCT lpDrawItemStruct)
{
struct PickerInfo *pPickerInfo;
HDC hDC = lpDrawItemStruct->hDC;
RECT rcItem = lpDrawItemStruct->rcItem;
UINT uiFlags = ILD_TRANSPARENT;
HIMAGELIST hImageList;
int nItem = lpDrawItemStruct->itemID;
COLORREF clrTextSave = 0;
COLORREF clrBkSave = 0;
COLORREF clrImage = GetSysColor(COLOR_WINDOW);
static TCHAR szBuff[MAX_PATH];
BOOL bFocus = (GetFocus() == hWnd);
LPCTSTR pszText;
UINT nStateImageMask = 0;
BOOL bSelected = 0;
LV_COLUMN lvc;
LV_ITEM lvi;
RECT rcAllLabels;
RECT rcLabel;
RECT rcIcon;
int offset = 0;
SIZE size;
int i = 0, j = 0;
int nColumn = 0;
int nColumnMax = 0;
int *order;
BOOL bDrawAsChild = 0;
int indent_space = 0;
BOOL bColorChild = FALSE;
BOOL bParentFound = FALSE;
int nParent = 0;
HBITMAP hBackground = GetBackgroundBitmap();
MYBITMAPINFO *pbmDesc = GetBackgroundInfo();
BOOL res = 0;
pPickerInfo = GetPickerInfo(hWnd);
order = (int*)malloc(pPickerInfo->nColumnCount * sizeof(*order));
if (!order)
return;
nColumnMax = Picker_GetNumColumns(hWnd);
if (GetUseOldControl())
{
pPickerInfo->pCallbacks->pfnGetColumnOrder(order);
}
else
{
/* Get the Column Order and save it */
res = ListView_GetColumnOrderArray(hWnd, nColumnMax, order);
/* Disallow moving column 0 */
if (order[0] != 0)
{
for (i = 0; i < nColumnMax; i++)
{
if (order[i] == 0)
{
order[i] = order[0];
order[0] = 0;
}
}
res = ListView_SetColumnOrderArray(hWnd, nColumnMax, order);
}
}
/* Labels are offset by a certain amount */
/* This offset is related to the width of a space character */
GetTextExtentPoint32(hDC, TEXT(" "), 1, &size);
offset = size.cx;
lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
lvi.iItem = nItem;
lvi.iSubItem = order[0];
lvi.pszText = szBuff;
lvi.cchTextMax = sizeof(szBuff) / sizeof(szBuff[0]);
lvi.stateMask = 0xFFFF; /* get all state flags */
res = ListView_GetItem(hWnd, &lvi);
bSelected = ((lvi.state & LVIS_DROPHILITED) || ( (lvi.state & LVIS_SELECTED)
&& ((bFocus) || (GetWindowLong(hWnd, GWL_STYLE) & LVS_SHOWSELALWAYS))));
/* figure out if we indent and draw grayed */
if (pPickerInfo->pCallbacks->pfnFindItemParent)
nParent = pPickerInfo->pCallbacks->pfnFindItemParent(hWnd, lvi.lParam);
else
nParent = -1;
bDrawAsChild = (pPickerInfo->pCallbacks->pfnGetViewMode() == VIEW_GROUPED && (nParent >= 0));
/* only indent if parent is also in this view */
if ((nParent >= 0) && bDrawAsChild)
{
for (i = 0; i < ListView_GetItemCount(hWnd); i++)
{
lvi.mask = LVIF_PARAM;
lvi.iItem = i;
res = ListView_GetItem(hWnd, &lvi);
if (lvi.lParam == nParent)
{
bParentFound = TRUE;
break;
}
}
}
if (pPickerInfo->pCallbacks->pfnGetOffsetChildren && pPickerInfo->pCallbacks->pfnGetOffsetChildren())
{
if (!bParentFound && bDrawAsChild)
{
/*Reset it, as no Parent is there*/
bDrawAsChild = FALSE;
bColorChild = TRUE;
}
else
{
nParent = -1;
bParentFound = FALSE;
}
}
res = ListView_GetItemRect_Modified(hWnd, nItem, &rcAllLabels, LVIR_BOUNDS);
res = ListView_GetItemRect_Modified(hWnd, nItem, &rcLabel, LVIR_LABEL);
rcAllLabels.left = rcLabel.left;
if (hBackground != NULL)
{
RECT rcClient;
HRGN rgnBitmap;
RECT rcTmpBmp = rcItem;
RECT rcFirstItem;
HPALETTE hPAL;
HDC htempDC;
HBITMAP oldBitmap;
htempDC = CreateCompatibleDC(hDC);
oldBitmap = (HBITMAP)SelectObject(htempDC, hBackground);
GetClientRect(hWnd, &rcClient);
rcTmpBmp.right = rcClient.right;
/* We also need to check whether it is the last item
The update region has to be extended to the bottom if it is */
if (nItem == ListView_GetItemCount(hWnd) - 1)
rcTmpBmp.bottom = rcClient.bottom;
rgnBitmap = CreateRectRgnIndirect(&rcTmpBmp);
SelectClipRgn(hDC, rgnBitmap);
DeleteBitmap(rgnBitmap);
hPAL = GetBackgroundPalette();
if (hPAL == NULL)
hPAL = CreateHalftonePalette(hDC);
if (GetDeviceCaps(htempDC, RASTERCAPS) & RC_PALETTE && hPAL != NULL)
{
SelectPalette(htempDC, hPAL, FALSE);
RealizePalette(htempDC);
}
res = ListView_GetItemRect_Modified(hWnd, 0, &rcFirstItem, LVIR_BOUNDS);
for (i = rcFirstItem.left; i < rcClient.right; i += pbmDesc->bmWidth)
for (j = rcFirstItem.top; j < rcClient.bottom; j += pbmDesc->bmHeight)
BitBlt(hDC, i, j, pbmDesc->bmWidth, pbmDesc->bmHeight, htempDC, 0, 0, SRCCOPY);
SelectObject(htempDC, oldBitmap);
DeleteDC(htempDC);
if (GetBackgroundPalette() == NULL)
{
DeletePalette(hPAL);
hPAL = NULL;
}
}
indent_space = 0;
if (bDrawAsChild)
{
RECT rect;
res = ListView_GetItemRect_Modified(hWnd, nItem, &rect, LVIR_ICON);
/* indent width of icon + the space between the icon and text
* so left of clone icon starts at text of parent
*/
indent_space = rect.right - rect.left + offset;
}
rcAllLabels.left += indent_space;
if (bSelected)
{
HBRUSH hBrush;
HBRUSH hOldBrush;
if (bFocus)
{
clrTextSave = SetTextColor(hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
clrBkSave = SetBkColor(hDC, GetSysColor(COLOR_HIGHLIGHT));
hBrush = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
}
else
{
clrTextSave = SetTextColor(hDC, GetSysColor(COLOR_BTNTEXT));
clrBkSave = SetBkColor(hDC, GetSysColor(COLOR_BTNFACE));
hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
}
hOldBrush = (HBRUSH)SelectObject(hDC, hBrush);
FillRect(hDC, &rcAllLabels, hBrush);
SelectObject(hDC, hOldBrush);
DeleteBrush(hBrush);
}
else
{
if (hBackground == NULL)
{
HBRUSH hBrush;
hBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
FillRect(hDC, &rcAllLabels, hBrush);
DeleteBrush(hBrush);
}
if (pPickerInfo->pCallbacks->pfnGetOffsetChildren && pPickerInfo->pCallbacks->pfnGetOffsetChildren())
{
if (bDrawAsChild || bColorChild)
clrTextSave = SetTextColor(hDC, GetListCloneColor());
else
clrTextSave = SetTextColor(hDC, GetListFontColor());
}
else
{
if (bDrawAsChild)
clrTextSave = SetTextColor(hDC, GetListCloneColor());
else
clrTextSave = SetTextColor(hDC, GetListFontColor());
}
clrBkSave = SetBkColor(hDC, GetSysColor(COLOR_WINDOW));
}
if (lvi.state & LVIS_CUT)
{
clrImage = GetSysColor(COLOR_WINDOW);
uiFlags |= ILD_BLEND50;
}
else if (bSelected)
{
if (bFocus)
clrImage = GetSysColor(COLOR_HIGHLIGHT);
else
clrImage = GetSysColor(COLOR_BTNFACE);
uiFlags |= ILD_BLEND50;
}
nStateImageMask = lvi.state & LVIS_STATEIMAGEMASK;
if (nStateImageMask)
{
int nImage = (nStateImageMask >> 12) - 1;
hImageList = ListView_GetImageList(hWnd, LVSIL_STATE);
if (hImageList)
ImageList_Draw(hImageList, nImage, hDC, rcItem.left, rcItem.top, ILD_TRANSPARENT);
}
res = ListView_GetItemRect_Modified(hWnd, nItem, &rcIcon, LVIR_ICON);
rcIcon.left += indent_space;
res = ListView_GetItemRect_Modified(hWnd, nItem, &rcItem, LVIR_LABEL);
hImageList = ListView_GetImageList(hWnd, LVSIL_SMALL);
if (hImageList)
{
UINT nOvlImageMask = lvi.state & LVIS_OVERLAYMASK;
if (rcIcon.left + 16 + indent_space < rcItem.right)
{
ImageList_DrawEx(hImageList, lvi.iImage, hDC, rcIcon.left, rcIcon.top, 16, 16,
GetSysColor(COLOR_WINDOW), clrImage, uiFlags | nOvlImageMask);
}
}
res = ListView_GetItemRect_Modified(hWnd, nItem, &rcItem, LVIR_LABEL);
pszText = MakeShortString(hDC, szBuff, rcItem.right - rcItem.left, 2*offset + indent_space);
rcLabel = rcItem;
rcLabel.left += offset + indent_space;
rcLabel.right -= offset;
DrawText(hDC, pszText, -1, &rcLabel, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER);
for (nColumn = 1; nColumn < nColumnMax; nColumn++)
{
int nRetLen;
UINT nJustify;
LV_ITEM lvItem;
lvc.mask = LVCF_FMT | LVCF_WIDTH;
res = ListView_GetColumn(hWnd, order[nColumn], &lvc);
lvItem.mask = LVIF_TEXT;
lvItem.iItem = nItem;
lvItem.iSubItem = order[nColumn];
lvItem.pszText = szBuff;
lvItem.cchTextMax = sizeof(szBuff) / sizeof(szBuff[0]);
if (ListView_GetItem(hWnd, &lvItem) == FALSE)
continue;
rcItem.left = rcItem.right;
rcItem.right += lvc.cx;
nRetLen = _tcslen(szBuff);
if (nRetLen == 0)
continue;
pszText = MakeShortString(hDC, szBuff, rcItem.right - rcItem.left, 2 * offset);
nJustify = DT_LEFT;
if (pszText == szBuff)
{
switch (lvc.fmt & LVCFMT_JUSTIFYMASK)
{
case LVCFMT_RIGHT:
nJustify = DT_RIGHT;
break;
case LVCFMT_CENTER:
nJustify = DT_CENTER;
break;
default:
break;
}
}
rcLabel = rcItem;
rcLabel.left += offset;
rcLabel.right -= offset;
DrawText(hDC, pszText, -1, &rcLabel,
nJustify | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER);
}
if (lvi.state & LVIS_FOCUSED && bFocus)
DrawFocusRect(hDC, &rcAllLabels);
SetTextColor(hDC, clrTextSave);
SetBkColor(hDC, clrBkSave);
free(order);
res++;
}
HDIB BitmapToDIB(HBITMAP hBitmap, HPALETTE hPal)
{
BITMAP bm; // bitmap structure
BITMAPINFOHEADER bi; // bitmap header
BITMAPINFOHEADER FAR *lpbi; // pointer to BITMAPINFOHEADER
DWORD dwLen; // size of memory block
HANDLE hDIB, h; // handle to DIB, temp handle
HDC hDC; // handle to DC
WORD biBits; // bits per pixel
/* check if bitmap handle is valid */
if (!hBitmap)
return NULL;
/* if no palette is specified, use default palette */
if (hPal == NULL)
hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
/* fill in BITMAP structure */
GetObject(hBitmap, sizeof(bm), (LPSTR)&bm);
/* calculate bits per pixel */
biBits = bm.bmPlanes * bm.bmBitsPixel;
/* initialize BITMAPINFOHEADER */
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = bm.bmWidth;
bi.biHeight = bm.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = biBits;
bi.biCompression = DIB_RGB_COLORS;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
/* calculate size of memory block required to store BITMAPINFO */
dwLen = bi.biSize + PaletteSize((LPSTR)&bi);
/* get a DC */
hDC = GetDC(NULL);
/* select and realize our palette */
hPal = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
/* alloc memory block to store our bitmap */
hDIB = GlobalAlloc(GHND, dwLen);
/* if we couldn't get memory block */
if (!hDIB)
{
/* clean up and return NULL */
SelectPalette(hDC, hPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
return NULL;
}
/* lock memory and get pointer to it */
lpbi = (BITMAPINFOHEADER FAR *)GlobalLock(hDIB);
/* use our bitmap info. to fill BITMAPINFOHEADER */
*lpbi = bi;
/* call GetDIBits with a NULL lpBits param, so it will calculate the
* biSizeImage field for us
*/
GetDIBits(hDC, hBitmap, 0, (WORD)bi.biHeight, NULL, (LPBITMAPINFO)lpbi,
DIB_RGB_COLORS);
/* get the info. returned by GetDIBits and unlock memory block */
bi = *lpbi;
GlobalUnlock(hDIB);
/* if the driver did not fill in the biSizeImage field, make one up */
if (bi.biSizeImage == 0)
bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
/* realloc the buffer big enough to hold all the bits */
dwLen = bi.biSize + PaletteSize((LPSTR)&bi) + bi.biSizeImage;
if (h = GlobalReAlloc(hDIB, dwLen, 0))
hDIB = h;
else
{
/* clean up and return NULL */
GlobalFree(hDIB);
hDIB = NULL;
SelectPalette(hDC, hPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
return NULL;
}
/* lock memory block and get pointer to it */
lpbi = (BITMAPINFOHEADER FAR *)GlobalLock(hDIB);
/* call GetDIBits with a NON-NULL lpBits param, and actualy get the
* bits this time
*/
if (GetDIBits(hDC, hBitmap, 0, (WORD)bi.biHeight, (LPSTR)lpbi + (WORD)lpbi
->biSize + PaletteSize((LPSTR)lpbi), (LPBITMAPINFO)lpbi,
DIB_RGB_COLORS) == 0)
{
/* clean up and return NULL */
GlobalUnlock(hDIB);
hDIB = NULL;
SelectPalette(hDC, hPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
return NULL;
}
bi = *lpbi;
/* clean up */
GlobalUnlock(hDIB);
SelectPalette(hDC, hPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
/* return handle to the DIB */
return hDIB;
}
BOOL
saveBmp( const char *filename, HBITMAP hBitmap )
{
// 出典: http://blog.csdn.net/bobob/archive/2005/02/20/294759.aspx
if ( !filename || !(*filename) || !hBitmap )
return FALSE;
HDC hDC;
int iBits;
WORD wBitCount;
DWORD dwPaletteSize = 0;
DWORD dwBmBitsSize = 0;
DWORD dwDIBSize = 0;
BITMAP Bitmap;
BITMAPFILEHEADER bmfHdr;
BITMAPINFOHEADER bi;
LPBITMAPINFOHEADER lpbi;
HANDLE hDib, hPal, hOldPal = NULL;
FILE *fp;
hDC = CreateDC( "DISPLAY", NULL, NULL, NULL );
iBits = GetDeviceCaps( hDC, BITSPIXEL ) * GetDeviceCaps( hDC, PLANES );
DeleteDC( hDC );
if ( iBits <= 1 )
wBitCount = 1;
else if ( iBits <= 4 )
wBitCount = 4;
else if ( iBits <= 8 )
wBitCount = 8;
else
wBitCount = 24;
GetObject( hBitmap, sizeof ( Bitmap ), (LPSTR)&Bitmap );
bi.biSize = sizeof ( BITMAPINFOHEADER );
bi.biWidth = Bitmap.bmWidth;
bi.biHeight = Bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = wBitCount;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrImportant = 0;
bi.biClrUsed = 0;
dwBmBitsSize =
((Bitmap.bmWidth * wBitCount + 31) / 32) * 4 *Bitmap.bmHeight;
hDib = GlobalAlloc(
GHND,
dwBmBitsSize + dwPaletteSize + sizeof ( BITMAPINFOHEADER ) );
lpbi = (LPBITMAPINFOHEADER)GlobalLock( hDib );
*lpbi = bi;
hPal = GetStockObject( DEFAULT_PALETTE );
if ( hPal ) {
hDC = ::GetDC( NULL );
hOldPal = ::SelectPalette( hDC, (HPALETTE)hPal, FALSE );
RealizePalette( hDC );
}
GetDIBits( hDC, hBitmap, 0, (UINT) Bitmap.bmHeight,
(LPSTR)lpbi + sizeof ( BITMAPINFOHEADER ) + dwPaletteSize,
(BITMAPINFO *)lpbi, DIB_RGB_COLORS );
if ( hOldPal ) {
::SelectPalette( hDC, (HPALETTE)hOldPal, TRUE );
RealizePalette( hDC );
::ReleaseDC( NULL, hDC );
}
fp = fopen( filename, "wb" );
if ( !fp ) {
GlobalUnlock( hDib );
GlobalFree( hDib );
return ( FALSE );
}
bmfHdr.bfType = 0x4D42; // "BM"
dwDIBSize = sizeof ( BITMAPFILEHEADER ) +
sizeof ( BITMAPINFOHEADER ) +
dwPaletteSize +
dwBmBitsSize;
bmfHdr.bfSize = dwDIBSize;
bmfHdr.bfReserved1 = 0;
bmfHdr.bfReserved2 = 0;
bmfHdr.bfOffBits = sizeof ( BITMAPFILEHEADER ) +
sizeof ( BITMAPINFOHEADER ) +
dwPaletteSize;
fwrite( &bmfHdr, sizeof ( BITMAPFILEHEADER ), 1, fp );
fwrite( lpbi, sizeof ( BYTE ), dwDIBSize, fp );
GlobalUnlock( hDib );
GlobalFree( hDib );
fclose( fp );
return TRUE;
}
void PLWEMFDecoder::GetImage (PLBmpBase & Bmp)
{
HPALETTE hpal = NULL;
LPLOGPALETTE plogpal (0);
if (GetBitsPerPixel() == 8) {
plogpal = (LPLOGPALETTE)new PLBYTE[sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 256)];
memset(plogpal,0x0,sizeof(LOGPALETTE) + sizeof(PALETTEENTRY)*256);
plogpal->palVersion = 0x300;
plogpal->palNumEntries = 256;
if (plogpal == NULL) {
PLASSERT(false);
raiseError (PL_ERRNO_MEMORY,"Cannot allocate palette.");
}
UINT pe = GetEnhMetaFilePaletteEntries(m_hemf, 0, NULL);
GetEnhMetaFilePaletteEntries(m_hemf, pe, plogpal->palPalEntry);
}
// Setup a logical palette for our memory dc and also a
// paintlib compatible palette for the paintlib bitmap
PLPixel32 pPal[256];
if (plogpal) {
for (UINT i = 0; i < 256; i++) {
pPal[i] = *(PLPixel32*)&plogpal->palPalEntry[i];
}
if ( 0 != (hpal = CreatePalette((LPLOGPALETTE)plogpal)) ) {
m_holdpal = SelectPalette(m_memdc, hpal, false);
RealizePalette(m_memdc);
}
Bmp.SetPalette(pPal);
delete [] plogpal;
}
// Play the metafile into the device context
// First, setup a bounding rectangle and fill
// the memory dc with white (some metafiles only
// use a black pen to draw and have no actual fill
// color set, This would cause a black on black
// painting which is rather useless
RECT rc;
rc.left = rc.top = 0;
rc.bottom = GetHeight();
rc.right = GetWidth();
FillRect(m_memdc,&rc,(HBRUSH)GetStockObject(WHITE_BRUSH));
// Heeere we go....
/*BOOL bres =*/ PlayEnhMetaFile(m_memdc,m_hemf,&rc);
// Finally, convert the Windows bitmap into a paintlib bitmap
PLWinBmp& winbmp = dynamic_cast<PLWinBmp&>(Bmp);
BITMAPINFO* pBMI = (BITMAPINFO*)winbmp.GetBMI();
//PLBYTE* pBits = (PLBYTE*)winbmp.GetBits();
if (GetBitsPerPixel() == 8) {
GetDIBits(m_dc, m_bm, 0, GetHeight(), winbmp.GetBits(), pBMI, DIB_RGB_COLORS);
}
else {
GetDIBits(m_dc, m_bm, 0, GetHeight(), winbmp.GetBits(), pBMI, DIB_PAL_COLORS);
}
}
HDIB FAR ChangeDIBFormat(HDIB hDIB, WORD wBitCount, DWORD dwCompression)
{
HDC hDC; // Handle to DC
HBITMAP hBitmap; // Handle to bitmap
BITMAP Bitmap; // BITMAP data structure
BITMAPINFOHEADER bi; // Bitmap info header
LPBITMAPINFOHEADER lpbi; // Pointer to bitmap info
HDIB hNewDIB = NULL; // Handle to new DIB
HPALETTE hPal, hOldPal; // Handle to palette, prev pal
WORD DIBBPP, NewBPP; // DIB bits per pixel, new bpp
DWORD DIBComp, NewComp;// DIB compression, new compression
/* Check for a valid DIB handle */
if (!hDIB)
return NULL;
/* Get the old DIB's bits per pixel and compression format */
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
DIBBPP = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
DIBComp = ((LPBITMAPINFOHEADER)lpbi)->biCompression;
GlobalUnlock(hDIB);
/* Validate wBitCount and dwCompression
* They must match correctly (i.e., BI_RLE4 and 4 BPP or
* BI_RLE8 and 8BPP, etc.) or we return failure */
if (wBitCount == 0)
{
NewBPP = DIBBPP;
if ((dwCompression == BI_RLE4 && NewBPP == 4) ||
(dwCompression == BI_RLE8 && NewBPP == 8) ||
(dwCompression == BI_RGB))
NewComp = dwCompression;
else
return NULL;
}
else if (wBitCount == 1 && dwCompression == BI_RGB)
{
NewBPP = wBitCount;
NewComp = BI_RGB;
}
else if (wBitCount == 4)
{
NewBPP = wBitCount;
if (dwCompression == BI_RGB || dwCompression == BI_RLE4)
NewComp = dwCompression;
else
return NULL;
}
else if (wBitCount == 8)
{
NewBPP = wBitCount;
if (dwCompression == BI_RGB || dwCompression == BI_RLE8)
NewComp = dwCompression;
else
return NULL;
}
else if (wBitCount == 24 && dwCompression == BI_RGB)
{
NewBPP = wBitCount;
NewComp = BI_RGB;
}
else
return NULL;
/* Save the old DIB's palette */
hPal = CreateDIBPalette(hDIB);
if (!hPal)
return NULL;
/* Convert old DIB to a bitmap */
hBitmap = DIBToBitmap(hDIB, hPal);
if (!hBitmap)
{
DeleteObject(hPal);
return NULL;
}
/* Get info about the bitmap */
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
/* Fill in the BITMAPINFOHEADER appropriately */
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = Bitmap.bmWidth;
bi.biHeight = Bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = NewBPP;
bi.biCompression = NewComp;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
/* Go allocate room for the new DIB */
hNewDIB = AllocRoomForDIB(bi, hBitmap);
if (!hNewDIB)
return NULL;
/* Get a pointer to the new DIB */
lpbi = (VOID FAR *)GlobalLock(hNewDIB);
/* Get a DC and select/realize our palette in it */
hDC = GetDC(NULL);
hOldPal = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
/* Call GetDIBits and get the new DIB bits */
if (!GetDIBits(hDC, hBitmap, 0, (WORD) lpbi->biHeight,
(LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize((LPSTR)lpbi),
(LPBITMAPINFO)lpbi, DIB_RGB_COLORS))
{
GlobalUnlock(hNewDIB);
GlobalFree(hNewDIB);
hNewDIB = NULL;
}
/* Clean up and return */
SelectPalette(hDC, hOldPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
if (hNewDIB)
/* Unlock the new DIB's memory block */
GlobalUnlock(hNewDIB);
DeleteObject(hBitmap);
DeleteObject(hPal);
return hNewDIB;
}
// Window procedure, handles all messages for this program
LRESULT CALLBACK WndProc( HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
static HGLRC hRC; // Permenant Rendering context
static HDC hDC; // Private GDI Device context
switch (message)
{
// Window creation, setup for OpenGL
case WM_CREATE:
// Store the device context
hDC = GetDC(hWnd);
// Select the pixel format
SetDCPixelFormat(hDC);
// Create the rendering context and make it current
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
// Create the palette
hPalette = GetOpenGLPalette(hDC);
SetupRC(hDC);
break;
// Window is being destroyed, cleanup
case WM_DESTROY:
// Kill the timer that we created
KillTimer(hWnd,101);
glDeleteLists(nFontList, 128);
// Deselect the current rendering context and delete it
wglMakeCurrent(hDC,NULL);
wglDeleteContext(hRC);
// Delete the palette
if(hPalette != NULL)
DeleteObject(hPalette);
// Tell the application to terminate after the window
// is gone.
PostQuitMessage(0);
break;
// Window is resized.
case WM_SIZE:
// Call our function which modifies the clipping
// volume and viewport
ChangeSize(LOWORD(lParam), HIWORD(lParam));
break;
// The painting function. This message sent by Windows
// whenever the screen needs updating.
case WM_PAINT:
{
// Call OpenGL drawing code
RenderScene();
// Call function to swap the buffers
SwapBuffers(hDC);
ValidateRect(hWnd,NULL);
}
break;
// Windows is telling the application that it may modify
// the system palette. This message in essance asks the
// application for a new palette.
case WM_QUERYNEWPALETTE:
// If the palette was created.
if(hPalette)
{
int nRet;
// Selects the palette into the current device context
SelectPalette(hDC, hPalette, FALSE);
// Map entries from the currently selected palette to
// the system palette. The return value is the number
// of palette entries modified.
nRet = RealizePalette(hDC);
// Repaint, forces remap of palette in current window
InvalidateRect(hWnd,NULL,FALSE);
return nRet;
}
break;
// This window may set the palette, even though it is not the
// currently active window.
case WM_PALETTECHANGED:
// Don't do anything if the palette does not exist, or if
// this is the window that changed the palette.
if((hPalette != NULL) && ((HWND)wParam != hWnd))
{
// Select the palette into the device context
SelectPalette(hDC,hPalette,FALSE);
// Map entries to system palette
RealizePalette(hDC);
// Remap the current colors to the newly realized palette
UpdateColors(hDC);
return 0;
}
break;
default: // Passes it on if unproccessed
return (DefWindowProc(hWnd, message, wParam, lParam));
}
return (0L);
}
int GPsetwidgetattr (Gwidget_t *widget, int attrn, Gwattr_t *attrp) {
PIXsize_t ps;
int color, ai;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRORIGIN:
break;
case G_ATTRSIZE:
break;
case G_ATTRNAME:
break;
case G_ATTRMODE:
break;
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color < 0 || color > G_MAXCOLORS) {
Gerr (POS, G_ERRBADCOLORINDEX, color);
return -1;
}
WPU->colors[color].color.peRed = attrp[ai].u.c.r;
WPU->colors[color].color.peGreen = attrp[ai].u.c.g;
WPU->colors[color].color.peBlue = attrp[ai].u.c.b;
WPU->colors[color].color.peFlags = 0;
if (color >= WPU->ncolor)
ResizePalette (WPU->cmap, color + 1), WPU->ncolor = color + 1;
SetPaletteEntries (
WPU->cmap, (int) color, 1, &WPU->colors[color].color
);
RealizePalette (GC);
WPU->colors[color].inuse = TRUE;
if (color == WPU->gattr.color)
WPU->gattr.color = -1;
break;
case G_ATTRVIEWPORT:
if (attrp[ai].u.s.x == 0)
attrp[ai].u.s.x = 1;
if (attrp[ai].u.s.y == 0)
attrp[ai].u.s.y = 1;
WPU->vsize.x = attrp[ai].u.s.x + 0.5;
WPU->vsize.y = attrp[ai].u.s.y + 0.5;
ps.x = WPU->vsize.x, ps.y = WPU->vsize.y;
break;
case G_ATTRWINDOW:
if (attrp[ai].u.r.o.x == attrp[ai].u.r.c.x)
attrp[ai].u.r.c.x = attrp[ai].u.r.o.x + 1;
if (attrp[ai].u.r.o.y == attrp[ai].u.r.c.y)
attrp[ai].u.r.c.y = attrp[ai].u.r.o.y + 1;
WPU->wrect = attrp[ai].u.r;
break;
case G_ATTRWINDOWID:
Gerr (POS, G_ERRCANNOTSETATTR2, "windowid");
return -1;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr (POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// 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);
}
// If necessary, creates a 3-3-2 palette for the device context listed.
HPALETTE GetOpenGLPalette(HDC hDC)
{
HPALETTE hRetPal = NULL; // Handle to palette to be created
PIXELFORMATDESCRIPTOR pfd; // Pixel Format Descriptor
LOGPALETTE *pPal; // Pointer to memory for logical palette
int nPixelFormat; // Pixel format index
int nColors; // Number of entries in palette
int i; // Counting variable
BYTE RedRange,GreenRange,BlueRange;
// Range for each color entry (7,7,and 3)
// Get the pixel format index and retrieve the pixel format description
nPixelFormat = GetPixelFormat(hDC);
DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
// Does this pixel format require a palette? If not, do not create a
// palette and just return NULL
if(!(pfd.dwFlags & PFD_NEED_PALETTE))
return NULL;
// Number of entries in palette. 8 bits yeilds 256 entries
nColors = 1 << pfd.cColorBits;
// Allocate space for a logical palette structure plus all the palette entries
pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +nColors*sizeof(PALETTEENTRY));
// Fill in palette header
pPal->palVersion = 0x300; // Windows 3.0
pPal->palNumEntries = nColors; // table size
// Build mask of all 1's. This creates a number represented by having
// the low order x bits set, where x = pfd.cRedBits, pfd.cGreenBits, and
// pfd.cBlueBits.
RedRange = (1 << pfd.cRedBits) -1;
GreenRange = (1 << pfd.cGreenBits) - 1;
BlueRange = (1 << pfd.cBlueBits) -1;
// Loop through all the palette entries
for(i = 0; i < nColors; i++)
{
// Fill in the 8-bit equivalents for each component
pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange;
pPal->palPalEntry[i].peRed = (unsigned char)(
(double) pPal->palPalEntry[i].peRed * 255.0 / RedRange);
pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange;
pPal->palPalEntry[i].peGreen = (unsigned char)(
(double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange);
pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange;
pPal->palPalEntry[i].peBlue = (unsigned char)(
(double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange);
pPal->palPalEntry[i].peFlags = (unsigned char) NULL;
}
// Create the palette
hRetPal = CreatePalette(pPal);
// Go ahead and select and realize the palette for this device context
SelectPalette(hDC,hRetPal,FALSE);
RealizePalette(hDC);
// Free the memory used for the logical palette structure
free(pPal);
// Return the handle to the new palette
return hRetPal;
}
BOOL CDIB::SetBitmap(HBITMAP hBitmap, HPALETTE hPal /*= NULL*/)
{
// DeleteObject();
if (!hBitmap)
return FALSE;
// Get dimensions of bitmap
BITMAP bm;
if (!::GetObject(hBitmap, sizeof(bm),(LPVOID)&bm))
return FALSE;
bm.bmHeight = abs(bm.bmHeight);
HDC hDC = GetWindowDC(NULL);
HPALETTE hOldPal = NULL;
m_iColorTableSize = NumColorEntries(bm.bmBitsPixel, BI_RGB);
// Initialize the BITMAPINFOHEADER in m_DIBinfo
BITMAPINFOHEADER& bih = m_DIBinfo.bmiHeader;
bih.biSize = sizeof(BITMAPINFOHEADER);
bih.biWidth = bm.bmWidth;
bih.biHeight = bm.bmHeight;
bih.biPlanes = 1; // Must always be 1 according to docs
bih.biBitCount = bm.bmBitsPixel;
bih.biCompression = BI_RGB;
bih.biSizeImage = BytesPerLine(bm.bmWidth, bm.bmBitsPixel) * bm.bmHeight;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
GetColorTableEntries(hDC, hBitmap);
// If we have a palette supplied, then set the palette (and hance DIB color
// table) using this palette
if (hPal)
SetPalette(hPal);
if (hPal)
{
hOldPal = SelectPalette(hDC, m_hPal, FALSE);
RealizePalette(hDC);
}
// Create it!
m_hBitmap = CreateDIBSection(hDC, (const BITMAPINFO*) m_DIBinfo, m_iColorDataType, &m_ppvBits, NULL, 0);
if (hOldPal)
SelectPalette(hDC, hOldPal, FALSE);
hOldPal = NULL;
if (! m_hBitmap)
{
TRACE0("Unable to CreateDIBSection\n");
return FALSE;
}
// If palette was supplied then create a palette using the entries in the DIB
// color table.
if (! hPal)
CreatePalette();
// Need to copy the supplied bitmap onto the newly created DIBsection
HDC hMemDC = CreateCompatibleDC(hDC);
HDC hCopyDC = CreateCompatibleDC(hDC);
if (! hMemDC || ! hCopyDC)
{
TRACE0("Unable to create compatible DC's\n");
//AfxThrowResourceException();
}
if (m_hPal)
{
SelectPalette(hMemDC, m_hPal, FALSE); RealizePalette(hMemDC);
SelectPalette(hCopyDC, m_hPal, FALSE); RealizePalette(hCopyDC);
}
HBITMAP hOldMemBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
HBITMAP hOldCopyBitmap = (HBITMAP) SelectObject(hCopyDC, m_hBitmap);
BitBlt(hCopyDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hOldMemBitmap);
SelectObject(hCopyDC, hOldCopyBitmap);
if (m_hPal)
{
HGDIOBJ hObj = ::GetStockObject(DEFAULT_PALETTE);
SelectObject(hMemDC, hObj);
SelectObject(hCopyDC, hObj);
}
ReleaseDC(NULL, hDC);
return TRUE;
}
INT
Test_NtUserSelectPalette(PTESTINFO pti)
{
HPALETTE hPal, hOldPal;
HWND hWnd;
HDC hDC, hCompDC;
struct
{
LOGPALETTE logpal;
PALETTEENTRY entry[20];
} pal;
ZeroMemory(&pal, sizeof(pal));
pal.logpal.palVersion = 0x300;
pal.logpal.palNumEntries = 6;
pal.entry[0] = PALENTRY(0,0,0);
pal.entry[1] = PALENTRY(255,255,255);
pal.entry[2] = PALENTRY(128,128,128);
pal.entry[3] = PALENTRY(128,0,0);
pal.entry[4] = PALENTRY(0,128,0);
pal.entry[5] = PALENTRY(0,0,128);
hPal = CreatePalette(&pal.logpal);
ASSERT(hPal);
TEST(DeletePalette(hPal) == 1);
hPal = CreatePalette(&pal.logpal);
ASSERT(hPal);
/* Create a window */
hWnd = CreateWindowW(L"BUTTON", L"TestWindow", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,
NULL, NULL, g_hInstance, 0);
hDC = GetDC(hWnd);
ASSERT(hDC);
hCompDC = CreateCompatibleDC(hDC);
ASSERT(hCompDC);
/* Test NULL DC */
SetLastError(ERROR_SUCCESS);
hOldPal = NtUserSelectPalette(NULL, hPal, 0);
TEST(hOldPal == 0);
TEST(GetLastError() == ERROR_SUCCESS);
/* Test invalid DC */
SetLastError(ERROR_SUCCESS);
hOldPal = NtUserSelectPalette((HDC)-1, hPal, 0);
TEST(hOldPal == 0);
TEST(GetLastError() == ERROR_SUCCESS);
/* Test NULL palette */
SetLastError(ERROR_SUCCESS);
hOldPal = NtUserSelectPalette(hDC, NULL, 0);
TEST(hOldPal == 0);
TEST(GetLastError() == ERROR_SUCCESS);
/* Test invalid palette */
SetLastError(ERROR_SUCCESS);
hOldPal = NtUserSelectPalette(hDC, (HPALETTE)-1, 0);
TEST(hOldPal == 0);
TEST(GetLastError() == ERROR_SUCCESS);
/* Test valid palette */
hOldPal = NtUserSelectPalette(hDC, hPal, 0);
TEST(hOldPal != 0);
TEST(hOldPal == GetStockObject(DEFAULT_PALETTE));
/* We cannot Delete the palette */
TEST(DeletePalette(hPal) == 0);
/* We can still select the Palette into a compatible DC */
hOldPal = NtUserSelectPalette(hCompDC, hPal, 0);
TEST(hOldPal != 0);
#if 0
RealizePalette(hDC);
GetClientRect(hWnd, &rect);
FillRect(hDC, &rect, GetSysColorBrush(COLOR_BTNSHADOW));
TEST(GetNearestColor(hDC, RGB(0,0,0)) == RGB(0,0,0));
TEST(GetNearestColor(hDC, RGB(0,0,1)) == RGB(0,0,1));
ReleaseDC(hWnd, hDC);
DestroyWindow(hWnd);
RECT rect;
HBITMAP hBmp;
BITMAPINFOHEADER bmih = {sizeof(BITMAPINFOHEADER), // biSize
3, // biWidth
3, // biHeight
1, // biPlanes
8, // biBitCount
BI_RGB, // biCompression
0, // biSizeImage
92, // biXPelsPerMeter
92, // biYPelsPerMeter
6, // biClrUsed
6}; // biClrImportant
BYTE bits[3][3] = {{0,1,2},{3,4,5},{6,1,2}};
struct
{
BITMAPINFOHEADER bmih;
RGBQUAD colors[6];
} bmi = {{sizeof(BITMAPINFOHEADER),3,3,1,8,BI_RGB,0,92,92,6,6},
{{0,0,0,0},{255,255,255,0},{255,0,0,0},
{0,255,0,0},{0,0,255,0},{128,128,128,0}}};
hBmp = CreateDIBitmap(hCompDC, &bmih, CBM_INIT, &bits, (BITMAPINFO*)&bmi, DIB_RGB_COLORS);
ASSERT(hBmp);
SetLastError(0);
TEST(NtGdiSelectBitmap(hCompDC, hBmp));
hOldPal = NtUserSelectPalette(hCompDC, hPal, 0);
TEST(hOldPal != NULL);
RealizePalette(hCompDC);
TEST(GetNearestColor(hCompDC, RGB(0,0,0)) == RGB(0,0,0));
TEST(GetNearestColor(hCompDC, RGB(0,0,1)) == RGB(0,0,0));
TEST(GetNearestColor(hCompDC, RGB(100,0,0)) == RGB(0,0,0));
TEST(GetNearestColor(hCompDC, RGB(250,250,250)) == RGB(255,255,255));
TEST(GetNearestColor(hCompDC, RGB(120,100,110)) == RGB(128,128,128));
printf("nearest = 0x%x\n", GetNearestColor(hCompDC, RGB(120,100,110)));
#endif
return APISTATUS_NORMAL;
}
static BOOL CALLBACK
sSplashDlgProc (
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PSPLASHSTRUCT pss;
switch (uMsg) {
case WM_INITDIALOG:
{
HWND hWndControl;
SetWindowLong (hDlg, GWL_USERDATA, lParam);
pss = (PSPLASHSTRUCT)lParam;
g_hWndSplash = hDlg;
SetWindowPos (hDlg, HWND_TOP, pss->uXpos, pss->uYpos,
pss->uXsize, pss->uYsize, 0);
hWndControl = GetDlgItem (hDlg, IDOK);
EnableWindow (hWndControl, FALSE);
ShowWindow (hWndControl, SW_HIDE);
hWndControl = GetDlgItem (hDlg, IDC_BUYNOW);
EnableWindow (hWndControl, FALSE);
ShowWindow (hWndControl, SW_HIDE);
pss->uTimerTime = 0;
SetTimer (hDlg, TIMER_ID, TIMER_PERIOD, NULL);
}
return TRUE;
case WM_PAINT:
{
HDC hDC, hMemDC;
PAINTSTRUCT ps;
HBITMAP hBitmapOld;
pss = (PSPLASHSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
hDC = BeginPaint (hDlg, &ps);
hMemDC = CreateCompatibleDC (hDC);
if (pss->hPaletteSplash) {
SelectPalette (hDC, pss->hPaletteSplash, FALSE);
RealizePalette (hDC);
}
hBitmapOld = SelectObject (hMemDC, pss->hBitmapSplash);
CLPaintUserInfo (MemMgr, hDlg, hMemDC, NULL);
BitBlt (hDC, 0, 0, pss->uXsize, pss->uYsize,
hMemDC, 0, 0, SRCCOPY);
SelectObject (hMemDC, hBitmapOld);
DeleteDC (hMemDC);
EndPaint (hDlg, &ps);
}
return FALSE;
case WM_LBUTTONDOWN:
if (hWndSplashParent) EndDialog (hDlg, 0);
return TRUE;
case WM_DESTROY:
KillTimer (hDlg, TIMER_ID);
return FALSE;
case WM_TIMER:
pss = (PSPLASHSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
if (pss->uTimerTime < pss->uTimeOut)
pss->uTimerTime += TIMER_PERIOD;
else
if (hWndSplashParent) EndDialog (hDlg, 0);
return TRUE;
case WM_CLOSE :
EndDialog (hDlg, 0);
break;
case WM_COMMAND :
switch(LOWORD (wParam)) {
case IDOK:
if (hWndSplashParent) EndDialog (hDlg, 0);
break;
}
return TRUE;
default:
return FALSE;
}
return FALSE;
}
void
SetupContext(void)
{
PIXELFORMATDESCRIPTOR pfd; /* Pixel format information */
LOGPALETTE *pPal; /* Pointer to logical palette */
int nColors; /* Number of entries in palette */
int ind, /* Color index */
rmax, /* Maximum red value */
gmax, /* Maximum green value */
bmax; /* Maximum blue value */
/* Choose a pixel format... */
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
pfd.iPixelType = PFD_TYPE_RGBA; /* RGB color buffer */
pfd.cDepthBits = 16; /* Need a depth buffer */
Format = ChoosePixelFormat(DC, &pfd);
if (!Format)
exit(1);
DescribePixelFormat(DC, Format, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
SetPixelFormat(DC, Format, &pfd);
/* Create the OpenGL rendering context... */
RC = wglCreateContext(DC);
wglMakeCurrent(DC, RC);
/* Find out if we need to define a color palette... */
if (!(pfd.dwFlags & PFD_NEED_PALETTE))
{
Palette = NULL;
return;
}
/* Allocate memory for a color palette... */
nColors = 1 << pfd.cColorBits;
pPal = (LOGPALETTE *)malloc(sizeof(LOGPALETTE) +
nColors * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
pPal->palNumEntries = nColors;
/*
* Get the maximum values for red, green, and blue. Then build 'nColors'
* colors...
*/
rmax = (1 << pfd.cRedBits) - 1;
gmax = (1 << pfd.cGreenBits) - 1;
bmax = (1 << pfd.cBlueBits) - 1;
for (ind = 0; ind < nColors; ind ++)
{
pPal->palPalEntry[ind].peRed = 255 * ((ind >> pfd.cRedShift) & rmax) / rmax;
pPal->palPalEntry[ind].peGreen = 255 * ((ind >> pfd.cGreenShift) & gmax) / gmax;
pPal->palPalEntry[ind].peBlue = 255 * ((ind >> pfd.cBlueShift) & bmax) / bmax;
pPal->palPalEntry[ind].peFlags = 0;
}
/* Create, select, and realize the palette... */
Palette = CreatePalette(pPal);
SelectPalette(DC, Palette, FALSE);
RealizePalette(DC);
free(pPal);
}
int GPcreatewidget (
Gwidget_t *parent, Gwidget_t *widget, int attrn, Gwattr_t *attrp
) {
PIXpoint_t po;
PIXsize_t ps;
PRINTDLG pd;
DOCINFO di;
DEVMODE *dmp;
/* the 2 here is to provide enough space for palPalEntry[0] and [1] */
LOGPALETTE pal[2];
HBRUSH brush;
HPEN pen;
HBITMAP bmap;
char *s, *s1;
int color, lflag, ai, dpix, dpiy, i;
s = Gpscanvasname;
lflag = FALSE;
po.x = po.y = 0;
ps.x = ps.y = MINPWSIZE;
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRORIGIN:
GETORIGIN (attrp[ai].u.p, po);
break;
case G_ATTRSIZE:
GETSIZE (attrp[ai].u.s, ps, MINPWSIZE);
break;
case G_ATTRNAME:
if (attrp[ai].u.t && attrp[ai].u.t[0])
s = attrp[ai].u.t;
break;
case G_ATTRMODE:
if (strcmp ("landscape", attrp[ai].u.t) == 0)
lflag = TRUE;
else if (strcmp ("portrait", attrp[ai].u.t) == 0)
lflag = FALSE;
else {
Gerr (POS, G_ERRBADATTRVALUE, attrp[ai].u.t);
return -1;
}
break;
case G_ATTRCOLOR:
/* will do it after the widget is created */
break;
case G_ATTRVIEWPORT:
/* will do it after the widget is created */
break;
case G_ATTRWINDOW:
/* will do it after the widget is created */
break;
case G_ATTRWINDOWID:
Gerr (POS, G_ERRCANNOTSETATTR1, "windowid");
return -1;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr (POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
s1 = s + strlen (s) - 3;
if (s1 > s && strncmp (s1, "emf", 3) == 0) {
WPU->mode = 1;
ps.x *= 8.235, ps.y *= 8.235;
if (!(GC = CreateEnhMetaFile (NULL, s, NULL, "LEFTY\\0GRAPH\\0\\0"))) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
} else { /* open the printer device */
WPU->mode = 2;
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = NULL;
di.lpszOutput = NULL;
di.lpszDatatype = "LEFTY";
di.fwType = 0;
pd.lStructSize = sizeof (pd);
pd.hwndOwner = NULL;
pd.hDevMode = NULL;
pd.hDevNames = NULL;
pd.hDC = NULL;
pd.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
pd.nFromPage = 0;
pd.nToPage = 0;
pd.nMinPage = 0;
pd.nMaxPage = 0;
pd.nCopies = 1;
pd.hInstance = NULL;
pd.lCustData = NULL;
pd.lpfnPrintHook = NULL;
pd.lpfnSetupHook = NULL;
pd.lpPrintTemplateName = NULL;
pd.lpSetupTemplateName = NULL;
pd.hPrintTemplate = NULL;
pd.hSetupTemplate = NULL;
if (!PrintDlg (&pd)) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
if (lflag && pd.hDevMode) {
dmp = (DEVMODE *) GlobalLock (pd.hDevMode);
dmp->dmOrientation = DMORIENT_LANDSCAPE;
GlobalUnlock (pd.hDevMode);
pd.Flags = PD_RETURNDC;
if (!PrintDlg (&pd)) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
}
GC = pd.hDC;
dpix = GetDeviceCaps (GC, LOGPIXELSX);
if (dpix != 300)
ps.x = ps.x * (double) dpix / 300.0;
dpiy = GetDeviceCaps (GC, LOGPIXELSY);
if (dpiy != 300)
ps.y = ps.y * (double) dpiy / 300.0;
if (StartDoc (GC, &di) <= 0 || StartPage (GC) <= 0) {
Gerr (POS, G_ERRCANNOTCREATEWIDGET);
return -1;
}
}
WPU->wrect.o.x = 0.0, WPU->wrect.o.y = 0.0;
WPU->wrect.c.x = 1.0, WPU->wrect.c.y = 1.0;
WPU->vsize.x = ps.x, WPU->vsize.y = ps.y;
WPU->ncolor = 2;
pal[0].palVersion = 0x300; /* HA HA HA */
pal[0].palNumEntries = 2;
pal[0].palPalEntry[0].peRed = 255;
pal[0].palPalEntry[0].peGreen = 255;
pal[0].palPalEntry[0].peBlue = 255;
pal[0].palPalEntry[0].peFlags = 0;
pal[0].palPalEntry[1].peRed = 0;
pal[0].palPalEntry[1].peGreen = 0;
pal[0].palPalEntry[1].peBlue = 0;
pal[0].palPalEntry[1].peFlags = 0;
WPU->cmap = CreatePalette (&pal[0]);
WPU->colors[0].color = pal[0].palPalEntry[0];
for (i = 1; i < G_MAXCOLORS; i++)
WPU->colors[i].color = pal[0].palPalEntry[1];
SelectPalette (GC, WPU->cmap, FALSE);
RealizePalette (GC);
WPU->colors[0].inuse = TRUE;
WPU->colors[1].inuse = TRUE;
for (i = 2; i < G_MAXCOLORS; i++)
WPU->colors[i].inuse = FALSE;
WPU->gattr.color = 1;
brush = CreateSolidBrush (PALETTEINDEX (1));
SelectObject (GC, brush);
pen = CreatePen (PS_SOLID, 1, PALETTEINDEX (1));
SelectObject (GC, pen);
SetTextColor (GC, PALETTEINDEX (1));
SetBkMode (GC, TRANSPARENT);
WPU->gattr.width = 0;
WPU->gattr.mode = G_SRC;
WPU->gattr.fill = 0;
WPU->gattr.style = 0;
WPU->defgattr = WPU->gattr;
WPU->font = NULL;
if (Gdepth == 1) {
for (i = 0; i < 17; i++) {
if (!(bmap = CreateBitmap (4, 4, 1, 1, &grays[i][0])))
continue;
WPU->grays[i] = CreatePatternBrush (bmap);
}
}
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color < 0 || color > G_MAXCOLORS) {
Gerr (POS, G_ERRBADCOLORINDEX, color);
return -1;
}
WPU->colors[color].color.peRed = attrp[ai].u.c.r;
WPU->colors[color].color.peGreen = attrp[ai].u.c.g;
WPU->colors[color].color.peBlue = attrp[ai].u.c.b;
WPU->colors[color].color.peFlags = 0;
if (color >= WPU->ncolor)
ResizePalette (WPU->cmap, color + 1), WPU->ncolor = color + 1;
SetPaletteEntries (
WPU->cmap, (int) color, 1, &WPU->colors[color].color
);
RealizePalette (GC);
WPU->colors[color].inuse = TRUE;
if (color == WPU->gattr.color)
WPU->gattr.color = -1;
break;
case G_ATTRVIEWPORT:
if (attrp[ai].u.s.x == 0)
attrp[ai].u.s.x = 1;
if (attrp[ai].u.s.y == 0)
attrp[ai].u.s.y = 1;
WPU->vsize.x = attrp[ai].u.s.x + 0.5;
WPU->vsize.y = attrp[ai].u.s.y + 0.5;
SetWindowPos (
widget->w, (HWND) NULL, 0, 0, WPU->vsize.x,
WPU->vsize.y, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE
);
break;
case G_ATTRWINDOW:
if (attrp[ai].u.r.o.x == attrp[ai].u.r.c.x)
attrp[ai].u.r.c.x = attrp[ai].u.r.o.x + 1;
if (attrp[ai].u.r.o.y == attrp[ai].u.r.c.y)
attrp[ai].u.r.c.y = attrp[ai].u.r.o.y + 1;
WPU->wrect = attrp[ai].u.r;
break;
}
}
return 0;
}
LRESULT CALLBACK CanvasWndProc (
HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam
) {
Gwidget_t *widget;
WINDOWPOS *wpos;
PIXpoint_t pp;
Gevent_t gev;
POINT p;
int wi, bn;
static int cntlflag;
if (Gnocallbacks || !(widget = findwidget (hwnd, G_CANVASWIDGET)))
return (DefWindowProc(hwnd, message, wparam, lparam));
Gpopdownflag = FALSE;
switch (message) {
case WM_PAINT:
if (palettechanged != hwnd)
RealizePalette (widget->u.c->gc);
Gneedredraw = widget->u.c->needredraw = TRUE;
Gadjustclip (widget);
return (DefWindowProc(hwnd, message, wparam, lparam));
case WM_WINDOWPOSCHANGED:
wpos = (WINDOWPOS *) lparam;
if (!(wpos->flags & SWP_NOSIZE))
handleresize (widget);
return 0;
case WM_MOUSEACTIVATE:
SetFocus (widget->w);
return (DefWindowProc(hwnd, message, wparam, lparam));
case WM_COMMAND:
processcommand (widget, wparam, lparam);
return 0;
case WM_CHAR:
gev.type = G_KEYBD;
gev.code = G_DOWN; /* I don't know how to get up events so I make */
Gpopdownflag = TRUE; /* the code after this switch send the up event */
gev.data = wparam;
GetCursorPos (&p);
ScreenToClient (widget->w, &p);
pp.x = p.x, pp.y = p.y;
gev.p = ppixtodraw (widget, pp);
/* continues after the end of this switch */
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
gev.type = G_MOUSE;
if (twobmouse) {
if (message == WM_LBUTTONDOWN && (wparam & MK_CONTROL))
message = WM_MBUTTONDOWN, cntlflag = TRUE;
if (message == WM_LBUTTONUP && cntlflag)
message = WM_MBUTTONUP, cntlflag = FALSE;
}
switch (message) {
case WM_LBUTTONDOWN: gev.code = G_DOWN, gev.data = G_LEFT; break;
case WM_LBUTTONUP: gev.code = G_UP, gev.data = G_LEFT; break;
case WM_MBUTTONDOWN: gev.code = G_DOWN, gev.data = G_MIDDLE; break;
case WM_MBUTTONUP: gev.code = G_UP, gev.data = G_MIDDLE; break;
case WM_RBUTTONDOWN: gev.code = G_DOWN, gev.data = G_RIGHT; break;
case WM_RBUTTONUP: gev.code = G_UP, gev.data = G_RIGHT; break;
}
pp.x = LOWORD (lparam), pp.y = HIWORD (lparam);
gev.p = ppixtodraw (widget, pp);
bn = WCU->bstate[gev.data];
WCU->bstate[gev.data] = (gev.code == G_DOWN) ? 1 : 0;
bn = WCU->bstate[gev.data] - bn;
widget->u.c->buttonsdown += bn;
Gbuttonsdown += bn;
/* continues after the end of this switch */
break;
default:
return (DefWindowProc(hwnd, message, wparam, lparam));
}
wi = gev.wi = widget - &Gwidgets[0];
if (widget->u.c->func)
(*widget->u.c->func) (&gev);
if (Gpopdownflag) {
Gpopdownflag = FALSE;
if (gev.code == G_DOWN) {
gev.code = G_UP;
widget = &Gwidgets[wi];
WCU->bstate[gev.data] = 0;
widget->u.c->buttonsdown--;
Gbuttonsdown--;
if (widget->inuse && widget->u.c->func)
(*widget->u.c->func) (&gev);
}
}
return 0;
}
/*----------------------------------------------------------------------------*\
| AppWndProc( hwnd, uiMessage, wParam, lParam ) |
| |
| Description: |
| 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;
switch (msg)
{
case WM_CREATE:
hwndA = CreateWindowEx(WS_EX_CLIENTEDGE,ANIMATE_CLASS, NULL,
// ACS_CENTER |
ACS_TRANSPARENT |
WS_VISIBLE | WS_CHILD | WS_BORDER,
10, 10, 500, 200, hwnd, (HMENU)42, hInstApp, NULL);
break;
case WM_SIZE:
//if (hwndC = GetWindow(hwnd, GW_CHILD))
// MoveWindow(hwndC, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
break;
case WM_ACTIVATEAPP:
fAppActive = (BOOL)wParam;
break;
case WM_TIMER:
break;
case WM_ERASEBKGND:
break;
case WM_INITMENU:
EnableMenuSz((HMENU)wParam, TEXT("Edit.Paste"), IsClipboardFormatAvailable(CF_TEXT));
break;
case WM_COMMAND:
//
// the animate control will notify us when play start or stops.
//
if (LOWORD(wParam) == 42)
{
if (GET_WM_COMMAND_CMD(wParam, lParam) == ACN_STOP)
AppSetText(TEXT("(stopped)"));
else if (GET_WM_COMMAND_CMD(wParam, lParam) == ACN_START)
AppSetText(TEXT("(playing)"));
else
AppSetText(NULL);
}
return HandleCommand(hwnd,msg,wParam,lParam);
case WM_DESTROY:
hAccelApp = NULL;
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);
AppPaint (hwnd,hdc);
EndPaint(hwnd,&ps);
return 0L;
}
return DefWindowProc(hwnd,msg,wParam,lParam);
}
BOOL CDDB::ConstructDDB( // construct a DDB from the DIB data
LPBITMAPINFOHEADER lpHeader, // pointer to BITMAPINFOHEADER structure
HDC hDC, // device context to use for call to CreateDIBitmap()
BOOL fUseDIBPalette, // flag indicating if DIB bitmap should be used for conversion
HPALETTE hPalette /*=NULL*/) // Palette to use
{
/*
// Build a palette containing the DIB color table. For 24 bit dibs, a default
// 256 entry palette is built (RGB)=(8*8*4).
*/
if ((m_hPalette = hPalette) == NULL)
{
UINT wNumberOfPaletteEntries;
if ((wNumberOfPaletteEntries = PaletteEntryCount(lpHeader)) == 0)
{
if (lpHeader->biBitCount == 24)
{
wNumberOfPaletteEntries = 256;
}
}
if (wNumberOfPaletteEntries > 0)
{
LOGPALETTE FAR *lpPalette;
if ((lpPalette = (LOGPALETTE FAR *)new far char[sizeof(LOGPALETTE)+wNumberOfPaletteEntries*sizeof(PALETTEENTRY)]) != NULL)
{
lpPalette->palNumEntries = (WORD)wNumberOfPaletteEntries;
lpPalette->palVersion = 0x0300;
if (lpHeader->biBitCount != 24)
{
RGBQUAD FAR *lpRGB;
lpRGB = (RGBQUAD FAR *)(((LPBYTE)lpHeader)+(WORD)(lpHeader->biSize));
UINT i;
for (i = 0; i < wNumberOfPaletteEntries; i++)
{
lpPalette->palPalEntry[i].peRed = lpRGB[i].rgbRed;
lpPalette->palPalEntry[i].peGreen = lpRGB[i].rgbGreen;
lpPalette->palPalEntry[i].peBlue = lpRGB[i].rgbBlue;
lpPalette->palPalEntry[i].peFlags = (BYTE)0;
}
}
else
{
BYTE Red = 0;
BYTE Green = 0;
BYTE Blue = 0;
UINT i;
for (i = 0; i < wNumberOfPaletteEntries; i++)
{
lpPalette->palPalEntry[i].peRed = Red;
lpPalette->palPalEntry[i].peGreen = Green;
lpPalette->palPalEntry[i].peBlue = Blue;
lpPalette->palPalEntry[i].peFlags = (BYTE)0;
if ((Red += 32) == 0)
{
if ((Green += 32) == 0)
{
Blue += 64;
}
}
}
}
m_hPalette = CreatePalette(lpPalette);
delete [] lpPalette;
lpPalette = NULL;
}
}
}
/*
// If the palette was successfully created, then go ahead and create the DDB.
*/
if (m_hPalette != NULL)
{
/*
// If the user wants to use the DIB palette to convert the DIB to a DDB, then select it now.
*/
HPALETTE hOldPalette = NULL;
if (fUseDIBPalette)
{
/*
// Note: The DIB palette is selected as a background palette. This should
// make the DIB->DDB conversion work without affecting the system colors.
*/
if ((hOldPalette = SelectPalette(hDC, m_hPalette, TRUE)) != NULL)
{
RealizePalette(hDC);
}
}
if ((!fUseDIBPalette) || (hOldPalette != NULL))
{
/*
// Create the DDB.
*/
m_hBitmap = CreateDIBitmap(
hDC,
lpHeader,
CBM_INIT,
((LPBYTE)lpHeader)+((UINT)lpHeader->biSize)+(PaletteEntryCount(lpHeader)*sizeof(RGBQUAD)),
(LPBITMAPINFO)lpHeader,
DIB_RGB_COLORS);
}
if (hOldPalette != NULL)
{
SelectPalette(hDC, hOldPalette, FALSE);
}
}
return IsValid();
}
//VC下把HBITMAP保存为bmp图片
BOOL SaveBmp(HBITMAP hBitmap, CString FileName)
{
HDC hDC;
//当前分辨率下每象素所占字节数
int iBits;
//位图中每象素所占字节数
WORD wBitCount;
//定义调色板大小， 位图中像素字节大小 ，位图文件大小 ， 写入文件字节数
DWORD dwPaletteSize = 0, dwBmBitsSize = 0, dwDIBSize = 0, dwWritten = 0;
//位图属性结构
BITMAP Bitmap;
//位图文件头结构
BITMAPFILEHEADER bmfHdr;
//位图信息头结构
BITMAPINFOHEADER bi;
//指向位图信息头结构
LPBITMAPINFOHEADER lpbi;
//定义文件，分配内存句柄，调色板句柄
HANDLE fh, hDib, hPal, hOldPal = NULL;
//计算位图文件每个像素所占字节数
hDC = CreateDC(L"DISPLAY", NULL, NULL, NULL);
iBits = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
DeleteDC(hDC);
if (iBits <= 1)
wBitCount = 1;
else if (iBits <= 4)
wBitCount = 4;
else if (iBits <= 8)
wBitCount = 8;
else
wBitCount = 24;
GetObject(hBitmap, sizeof(Bitmap), (LPSTR)&Bitmap);
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = Bitmap.bmWidth;
bi.biHeight = Bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = wBitCount;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrImportant = 0;
bi.biClrUsed = 0;
dwBmBitsSize = ((Bitmap.bmWidth *wBitCount + 31) / 32) * 4 * Bitmap.bmHeight;
//为位图内容分配内存
hDib = GlobalAlloc(GHND, dwBmBitsSize + dwPaletteSize + sizeof(BITMAPINFOHEADER));
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);
*lpbi = bi;
// 处理调色板
hPal = GetStockObject(DEFAULT_PALETTE);
if (hPal)
{
hDC = ::GetDC(NULL);
hOldPal = ::SelectPalette(hDC, (HPALETTE)hPal, FALSE);
RealizePalette(hDC);
}
// 获取该调色板下新的像素值
GetDIBits(hDC, hBitmap, 0, (UINT)Bitmap.bmHeight,
(LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + dwPaletteSize,
(BITMAPINFO *)lpbi, DIB_RGB_COLORS);
//恢复调色板
if (hOldPal)
{
::SelectPalette(hDC, (HPALETTE)hOldPal, TRUE);
RealizePalette(hDC);
::ReleaseDC(NULL, hDC);
}
//创建位图文件
fh = CreateFile(FileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (fh == INVALID_HANDLE_VALUE) return FALSE;
// 设置位图文件头
bmfHdr.bfType = 0x4D42; // "BM"
dwDIBSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwPaletteSize + dwBmBitsSize;
bmfHdr.bfSize = dwDIBSize;
bmfHdr.bfReserved1 = 0;
bmfHdr.bfReserved2 = 0;
bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwPaletteSize;
// 写入位图文件头
WriteFile(fh, (LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER), &dwWritten, NULL);
// 写入位图文件其余内容
WriteFile(fh, (LPSTR)lpbi, dwDIBSize, &dwWritten, NULL);
//清除
GlobalUnlock(hDib);
GlobalFree(hDib);
CloseHandle(fh);
return TRUE;
}
HDIB FAR ChangeBitmapFormat(HBITMAP hBitmap,
WORD wBitCount,
DWORD dwCompression,
HPALETTE hPal)
{
HDC hDC; // Screen DC
HDIB hNewDIB=NULL; // Handle to new DIB
BITMAP Bitmap; // BITMAP data structure
BITMAPINFOHEADER bi; // Bitmap info. header
LPBITMAPINFOHEADER lpbi; // Pointer to bitmap header
HPALETTE hOldPal=NULL; // Handle to palette
WORD NewBPP; // New bits per pixel
DWORD NewComp; // New compression format
/* Check for a valid bitmap handle */
if (!hBitmap)
return NULL;
/* Validate wBitCount and dwCompression
* They must match correctly (i.e., BI_RLE4 and 4 BPP or
* BI_RLE8 and 8BPP, etc.) or we return failure
*/
if (wBitCount == 0)
{
NewComp = dwCompression;
if (NewComp == BI_RLE4)
NewBPP = 4;
else if (NewComp == BI_RLE8)
NewBPP = 8;
else /* Not enough info */
return NULL;
}
else if (wBitCount == 1 && dwCompression == BI_RGB)
{
NewBPP = wBitCount;
NewComp = BI_RGB;
}
else if (wBitCount == 4)
{
NewBPP = wBitCount;
if (dwCompression == BI_RGB || dwCompression == BI_RLE4)
NewComp = dwCompression;
else
return NULL;
}
else if (wBitCount == 8)
{
NewBPP = wBitCount;
if (dwCompression == BI_RGB || dwCompression == BI_RLE8)
NewComp = dwCompression;
else
return NULL;
}
else if (wBitCount == 24 && dwCompression == BI_RGB)
{
NewBPP = wBitCount;
NewComp = BI_RGB;
}
else
return NULL;
/* Get info about the bitmap */
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
/* Fill in the BITMAPINFOHEADER appropriately */
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = Bitmap.bmWidth;
bi.biHeight = Bitmap.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = NewBPP;
bi.biCompression = NewComp;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
/* Go allocate room for the new DIB */
hNewDIB = AllocRoomForDIB(bi, hBitmap);
if (!hNewDIB)
return NULL;
/* Get a pointer to the new DIB */
lpbi = (VOID FAR *)GlobalLock(hNewDIB);
/* If we have a palette, get a DC and select/realize it */
if (hPal)
{
hDC = GetDC(NULL);
hOldPal = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
}
/* Call GetDIBits and get the new DIB bits */
if (!GetDIBits(hDC, hBitmap, 0, (WORD) lpbi->biHeight,
(LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize((LPSTR)lpbi),
(LPBITMAPINFO)lpbi, DIB_RGB_COLORS))
{
GlobalUnlock(hNewDIB);
GlobalFree(hNewDIB);
hNewDIB = NULL;
}
/* Clean up and return */
if (hOldPal)
{
SelectPalette(hDC, hOldPal, TRUE);
RealizePalette(hDC);
ReleaseDC(NULL, hDC);
}
if (hNewDIB)
{
/* Unlock the new DIB's memory block */
GlobalUnlock(hNewDIB);
}
return hNewDIB;
}
static int MyPaintSplash (HWND pmSplashWindow, BOOL pmDraw)
{
SplashWindowInfoPtr myInfo;
HDC myDisplayContext, myMemDC;
PAINTSTRUCT myPaintStruct;
BITMAP myBitmap;
HBITMAP myOldBitmap;
HPALETTE myPalette, myOldPalette;
POINT myPoint, myOrigin;
int myY;
myInfo = MyGetSplashWindowInfo (pmSplashWindow);
myDisplayContext = BeginPaint (pmSplashWindow, &myPaintStruct);
if (pmDraw && myInfo -> usePicture)
{
myMemDC = CreateCompatibleDC (NULL);
myOldBitmap = SelectBitmap (myMemDC, myInfo -> picture);
GetObject (myInfo -> picture, sizeof(BITMAP), (LPSTR) &myBitmap);
myPoint.x = myBitmap.bmWidth;
myPoint.y = myBitmap.bmHeight;
DPtoLP (myDisplayContext, &myPoint, 1);
myOrigin.x = 0;
myOrigin.y = 0;
DPtoLP (myMemDC, &myOrigin, 1);
//
// We need to perform all sorts of stuff to get the palette right...
//
// If the DIBSection is 256 color or less, it has a color table
if ((myBitmap.bmBitsPixel * myBitmap.bmPlanes) <= 8)
{
RGBQUAD myClrTbl [256];
LPLOGPALETTE myLogPal;
WORD cnt;
// Get the DIBSection's color table
GetDIBColorTable (myMemDC, 0, 256, myClrTbl);
// Create a palette from the color tabl
myLogPal = (LOGPALETTE *) malloc (sizeof(LOGPALETTE) +
(256 * sizeof(PALETTEENTRY)));
myLogPal -> palVersion = 0x300;
myLogPal -> palNumEntries = 256;
for (cnt = 0 ; cnt < 256 ; cnt++)
{
myLogPal -> palPalEntry [cnt].peRed = myClrTbl [cnt].rgbRed;
myLogPal -> palPalEntry [cnt].peGreen = myClrTbl [cnt].rgbGreen;
myLogPal -> palPalEntry [cnt].peBlue = myClrTbl [cnt].rgbBlue;
myLogPal -> palPalEntry [cnt].peFlags = 0;
}
myPalette = CreatePalette (myLogPal);
free (myLogPal);
// Select Palette
myOldPalette = SelectPalette (myDisplayContext, myPalette, FALSE);
RealizePalette (myDisplayContext);
}
if (gProgram.isTuring)
{
BitBlt (myDisplayContext, 0, 0, myPoint.x, myPoint.y,
myMemDC, myOrigin.x, myOrigin.y, SRCCOPY);
}
else
{
BitBlt (myDisplayContext, MARGIN, 0, myPoint.x, myPoint.y,
myMemDC, myOrigin.x, myOrigin.y, SRCCOPY);
}
SelectObject (myMemDC, myOldBitmap);
if ((myBitmap.bmBitsPixel * myBitmap.bmPlanes) <= 8)
{
SelectPalette (myDisplayContext, myOldPalette, FALSE);
DeleteObject (myPalette);
}
DeleteDC (myMemDC);
}
// Place Ministry message over top of the Sun
if (gProgram.assistedByIBM && gProgram.isTuring)
{
//
// Output "Ministry of Education License Message"
//
myY = LARGE_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> versionFont,
myInfo -> miniEdMsg [0], &myY, pmDraw, FALSE);
myY += SMALL_GAP;
MyDrawStrings (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
&myInfo -> miniEdMsg [1], 9, &myY, pmDraw, FALSE);
} // if (gProgram.assistedByIBM)
if (myInfo -> usePicture)
{
// The starting Y position
myY = myInfo -> bitmapHeight + MARGIN;
}
else
{
myY = SMALL_GAP;
MyDrawStrings (myInfo, myDisplayContext, myInfo -> productNameFont,
myInfo -> productNameMsg, myInfo -> productNameLines,
&myY, pmDraw, TRUE);
myY += LARGE_GAP;
}
//
// Output "Created By Holt Software Associates Inc."
//
MyDrawString (myInfo, myDisplayContext, myInfo -> createdByFont,
myInfo -> createdByMsg, &myY, pmDraw, TRUE);
if (gProgram.assistedByIBM && gProgram.isJava)
{
//
// Output "Development Assisted by IBM Corp."
//
MyDrawString (myInfo, myDisplayContext, myInfo -> createdByFont,
myInfo -> assistedByMsg, &myY, pmDraw, TRUE);
} // if (gProgram.assistedByIBM)
//
//
// Output "Lead Programmer: Tom West"
//
if (gProgram.isJava)
{
MyDrawString (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
myInfo -> leadProgrammerMsg, &myY, pmDraw, TRUE);
} // if (gProgram.isJava)
//
// Output version number
//
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> versionFont,
myInfo -> versionString, &myY, pmDraw, TRUE);
//
// Output install kind specific info
if (gProgram.miniVersion)
{
//
// Output: Licensed to xxx.
// This version cannot compile programs of greater than 100 lines in length
//
myY += SMALL_GAP;
MyDrawStrings (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
myInfo -> miniMsg, 3, &myY, pmDraw, TRUE);
}
else if (gProgram.installKind == INSTALL_KIND_EVAL)
{
//
// Output: This version is for personal evaluation purposes only.
// It may not be redistributed or used for teaching purposes.
// See the "Help" menu for information on obtaining Ready.
// This version is time limited and will not execute Java programs after xxx
// or
//
// Output: This version is for personal evaluation purposes only.
// It may not be redistributed or used for teaching purposes.
// See the "Help" menu for information on obtaining Ready.
// This demonstration version of the software is restricted and
// (1) Cannot save programs,
// (2) Cannot compile programs of greater than 100 lines in length, and
// (3) Will not execute programs after xxx
//
myY += SMALL_GAP;
if (gProgram.restrictedVersion)
{
MyDrawStrings (myInfo, myDisplayContext,
myInfo -> chiefProgrammerFont,
myInfo -> evalMsg, 3, &myY, pmDraw, TRUE);
myY += SMALL_GAP;
MyDrawStrings (myInfo, myDisplayContext,
myInfo -> chiefProgrammerFont,
myInfo -> restrictMsg, 4, &myY, pmDraw, TRUE);
}
else
{
MyDrawStrings (myInfo, myDisplayContext,
myInfo -> chiefProgrammerFont,
myInfo -> evalMsg, 4, &myY, pmDraw, TRUE);
}
}
else if (gProgram.installKind == INSTALL_KIND_BETA)
{
//
// Output: This version is for personal beta test purposes only.
// It may not be redistributed or used for teaching purposes.
// Please report all bugs found in this software to [email protected]
// This version of the software will not execute programs after xxx
//
myY += SMALL_GAP;
MyDrawStrings (myInfo, myDisplayContext,
myInfo -> chiefProgrammerFont,
myInfo -> betaMsg, 4, &myY, pmDraw, TRUE);
}
else if (gProgram.installKind == INSTALL_KIND_PERSONAL)
{
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
myInfo -> personalMsg, &myY, pmDraw, TRUE);
}
else if (gProgram.installKind == INSTALL_KIND_SITE)
{
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
myInfo -> siteMsg, &myY, pmDraw, TRUE);
}
else if (gProgram.installKind == INSTALL_KIND_REDISTRIB)
{
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> chiefProgrammerFont,
myInfo -> redistribMsg, &myY, pmDraw, TRUE);
}
if (gProgram.isJava)
{
//
// Output "Using IBM's Jikes Java Compiler"
//
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> usingJikesFont,
myInfo -> usingJikesMsg, &myY, pmDraw, TRUE);
myY += SMALL_GAP;
if (gProgram.operatingSystem == WIN_95)
{
MyDrawString (myInfo, myDisplayContext, myInfo -> trademarkFont,
myInfo -> win95Msg, &myY, pmDraw, TRUE);
}
else
{
MyDrawString (myInfo, myDisplayContext, myInfo -> trademarkFont,
myInfo -> jreLevelMsg, &myY, pmDraw, TRUE);
}
//
// Output trademark information
//
myY += SMALL_GAP;
MyDrawString (myInfo, myDisplayContext, myInfo -> trademarkFont,
myInfo -> trademarkMsg, &myY, pmDraw, TRUE);
} // if (gProgram.isJava)
EndPaint (pmSplashWindow, &myPaintStruct);
return myY;
} // MyPaintSplash
static void InstallColours(void)
{
int pixVal=0;
int c;
int step;
LOGPALETTE *pal;
HPALETTE hpal,OldPal;
HDC dc;
/* WHITE */
colours[0][0] = 255; colours[0][1] = 255; colours[0][2] = 255;
/* YELLOW */
colours[1][0] = 255; colours[1][1] = 255; colours[1][2] = 0;
/* ORANGE */
colours[2][0] = 255; colours[2][1] = 128; colours[2][2] = 0;
/* RED */
colours[3][0] = 255; colours[3][1] = 0; colours[3][2] = 0;
/* MAUVE */
colours[4][0] = 196; colours[4][1] = 100; colours[4][2] = 255;
/* PURPLE */
colours[5][0] = 128; colours[5][1] = 0; colours[5][2] = 128;
/* DARK_BLUE */
colours[6][0] = 0; colours[6][1] = 0; colours[6][2] = 196;
/* LIGHT_BLUE (CYAN) */
colours[7][0] = 0; colours[7][1] = 255; colours[7][2] = 255;
/* DARK_GREEN */
colours[8][0] = 0; colours[8][1] = 128; colours[8][2] = 0;
/* LIGHT_GREEN */
colours[9][0] = 0; colours[9][1] = 255; colours[9][2] = 0;
/* DARK_BROWN */
colours[10][0] = 128;colours[10][1] = 64; colours[10][2] = 64;
/* LIGHT_BROWN */
colours[11][0] = 196;colours[11][1] = 140;colours[11][2] = 140;
/* LIGHT_GREY */
colours[12][0] = 196;colours[12][1] = 196;colours[12][2] = 196;
/* GREY */
colours[13][0] = 128;colours[13][1] = 128;colours[13][2] = 128;
/* DARK_GREY */
colours[14][0] = 64; colours[14][1] = 64; colours[14][2] = 64;
/* BLACK */
colours[15][0] = 0; colours[15][1] = 0; colours[15][2] = 0;
step = 256/MAX_GREYS;
for (c = 0; c < MAX_GREYS; c++, pixVal+= step){
greys[c] = pixVal;
}
/* if display is 8 bits or less, create a palette containing
the best match to our desired colors. If it is 16 bits or
greater, matching will be no problem. */
if (dispDEEP <= 8){
pal = (LOGPALETTE *)
New(&gcheap,2*sizeof(WORD) + (MAX_GREYS + MAX_COLOURS)*sizeof(PALETTEENTRY));
pal->palVersion = 0x300;
pal->palNumEntries = MAX_GREYS + MAX_COLOURS;
/* most important colors should be first in list. Black, White,
the rest of the colors, then the greys. */
pal->palPalEntry[0].peRed = pal->palPalEntry[0].peGreen =
pal->palPalEntry[0].peBlue = 0;
pal->palPalEntry[0].peFlags = 0;
pal->palPalEntry[1].peRed = pal->palPalEntry[1].peGreen =
pal->palPalEntry[1].peBlue = 255;
pal->palPalEntry[1].peFlags = 0;
for (c=2;c<MAX_COLOURS;c++) {
pal->palPalEntry[c].peRed = colours[c-1][0];
pal->palPalEntry[c].peGreen = colours[c-1][1];
pal->palPalEntry[c].peBlue = colours[c-1][2];
pal->palPalEntry[c].peFlags = 0;
}
for (c=0;c<MAX_GREYS;c++) {
pal->palPalEntry[MAX_COLOURS+c].peRed = greys[c];
pal->palPalEntry[MAX_COLOURS+c].peGreen = greys[c];
pal->palPalEntry[MAX_COLOURS+c].peBlue = greys[c];
pal->palPalEntry[MAX_COLOURS+c].peFlags = 0;
}
hpal = CreatePalette(pal);
OldPal = SelectPalette(memDC,hpal,FALSE);
RealizePalette(memDC);
SelectPalette(memDC,OldPal,FALSE);
dc = GetDC(theWindow);
OldPal = SelectPalette(dc,hpal,FALSE);
RealizePalette(dc);
SelectPalette(dc,OldPal,FALSE);
ReleaseDC(theWindow,dc);
DeleteObject(hpal);
} /* if (dispDEEP <= 8) */
}
/*****************************************************************************
* x11_copy_to_screen
*
* Helper function that blts the front buffer contents to the target window
*
* Params:
* This: Surface to copy from
* rc: Rectangle to copy
*
*****************************************************************************/
void x11_copy_to_screen(IWineD3DSwapChainImpl *This, const RECT *rc)
{
IWineD3DSurfaceImpl *front = This->front_buffer;
if(front->resource.usage & WINED3DUSAGE_RENDERTARGET) {
POINT offset = {0,0};
HWND hDisplayWnd;
HDC hDisplayDC;
HDC hSurfaceDC = 0;
RECT drawrect;
TRACE("(%p)->(%p): Copying to screen\n", front, rc);
hSurfaceDC = front->hDC;
hDisplayWnd = This->win_handle;
hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
if(rc) {
TRACE(" copying rect (%d,%d)->(%d,%d), offset (%d,%d)\n",
rc->left, rc->top, rc->right, rc->bottom, offset.x, offset.y);
}
/* Front buffer coordinates are screen coordinates. Map them to the destination
* window if not fullscreened
*/
if(This->presentParms.Windowed) {
ClientToScreen(hDisplayWnd, &offset);
}
#if 0
/* FIXME: This doesn't work... if users really want to run
* X in 8bpp, then we need to call directly into display.drv
* (or Wine's equivalent), and force a private colormap
* without default entries. */
if (front->palette) {
SelectPalette(hDisplayDC, front->palette->hpal, FALSE);
RealizePalette(hDisplayDC); /* sends messages => deadlocks */
}
#endif
drawrect.left = 0;
drawrect.right = front->currentDesc.Width;
drawrect.top = 0;
drawrect.bottom = front->currentDesc.Height;
#if 0
/* TODO: Support clippers */
if (front->clipper)
{
RECT xrc;
HWND hwnd = ((IWineD3DClipperImpl *) front->clipper)->hWnd;
if (hwnd && GetClientRect(hwnd,&xrc))
{
OffsetRect(&xrc,offset.x,offset.y);
IntersectRect(&drawrect,&drawrect,&xrc);
}
}
#endif
if (rc) {
IntersectRect(&drawrect,&drawrect,rc);
}
else {
/* Only use this if the caller did not pass a rectangle, since
* due to double locking this could be the wrong one ...
*/
if (front->lockedRect.left != front->lockedRect.right) {
IntersectRect(&drawrect,&drawrect,&front->lockedRect);
}
}
BitBlt(hDisplayDC,
drawrect.left-offset.x, drawrect.top-offset.y,
drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
hSurfaceDC,
drawrect.left, drawrect.top,
SRCCOPY);
ReleaseDC(hDisplayWnd, hDisplayDC);
}
}
// DDBToDIB - Creates a DIB from a DDB
// bitmap - Device dependent bitmap
// dwCompression - Type of compression - see BITMAPINFOHEADER
// pPal - Logical palette
HANDLE CClientCapture::DDBToDIB( CBitmap& bitmap, DWORD dwCompression, CPalette* pPal, CDC *dc)
{
BITMAP bm;
BITMAPINFOHEADER bi;
//LPBITMAPINFOHEADER lpbi;
DWORD dwLen;
//HANDLE hDIB;
HANDLE handle;
HDC hDC;
HPALETTE hPal;
ASSERT( bitmap.GetSafeHandle() );
// The function has no arg for bitfields
if( dwCompression == BI_BITFIELDS )
return NULL;
// If a palette has not been supplied use defaul palette
hPal = (HPALETTE) pPal->GetSafeHandle();
if (hPal==NULL)
hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
// Get bitmap information
bitmap.GetObject(sizeof(bm),(LPSTR)&bm);
// Initialize the bitmapinfoheader
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = bm.bmWidth;
bi.biHeight = bm.bmHeight;
bi.biPlanes = 1;
bi.biBitCount = bm.bmPlanes * bm.bmBitsPixel;
bi.biCompression = dwCompression;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
// Compute the size of the infoheader and the color table
int nColors = (1 << bi.biBitCount);
if( nColors > 256 )
nColors = 0;
dwLen = bi.biSize + nColors * sizeof(RGBQUAD);
// We need a device context to get the DIB from
hDC = dc->GetSafeHdc();
//hDC = GetDC(NULL);
hPal = SelectPalette(hDC,hPal,FALSE);
RealizePalette(hDC);
// Allocate enough memory to hold bitmapinfoheader and color table
if(hDIB) GlobalFree( hDIB );
hDIB = GlobalAlloc(GMEM_FIXED,dwLen);
if (!hDIB){
SelectPalette(hDC,hPal,FALSE);
return NULL;
}
lpbi = (LPBITMAPINFOHEADER)hDIB;
*lpbi = bi;
// Call GetDIBits with a NULL lpBits param, so the device driver
// will calculate the biSizeImage field
GetDIBits(hDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);
bi = *lpbi;
// If the driver did not fill in the biSizeImage field, then compute it
// Each scan line of the image is aligned on a DWORD (32bit) boundary
if (bi.biSizeImage == 0){
bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8)
* bi.biHeight;
// If a compression scheme is used the result may infact be larger
// Increase the size to account for this.
if (dwCompression != BI_RGB)
bi.biSizeImage = (bi.biSizeImage * 3) / 2;
}
// Realloc the buffer so that it can hold all the bits
dwLen += bi.biSizeImage;
if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
hDIB = handle;
else{
GlobalFree(hDIB);
hDIB = 0;
// Reselect the original palette
SelectPalette(hDC,hPal,FALSE);
return NULL;
}
// Get the bitmap bits
lpbi = (LPBITMAPINFOHEADER)hDIB;
m_pBMI = (LPBITMAPINFO)hDIB;
m_pBits = (LPBYTE)hDIB + (bi.biSize + nColors * sizeof(RGBQUAD));
// FINALLY get the DIB
BOOL bGotBits = GetDIBits( hDC, (HBITMAP)bitmap.GetSafeHandle(),
0L, // Start scan line
(DWORD)bi.biHeight, // # of scan lines
(LPBYTE) m_pBits,//lpbi // address for bitmap bits
(LPBITMAPINFO)lpbi, // address of bitmapinfo
(DWORD)DIB_RGB_COLORS); // Use RGB for color table
if( !bGotBits )
{
GlobalFree(hDIB);
hDIB = 0;
SelectPalette(hDC,hPal,FALSE);
return NULL;
}
SelectPalette(hDC,hPal,FALSE);
return hDIB;
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HPALETTE hPalette ;
static int cxClient, cyClient ;
HDC hdc ;
PAINTSTRUCT ps ;
switch (message)
{
case WM_CREATE:
if (!CheckDisplay (hwnd))
return -1 ;
hPalette = CreateRoutine (hwnd) ;
return 0 ;
case WM_DISPLAYCHANGE:
if (!CheckDisplay (hwnd))
DestroyWindow (hwnd) ;
return 0 ;
case WM_SIZE:
cxClient = LOWORD (lParam) ;
cyClient = HIWORD (lParam) ;
return 0 ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
PaintRoutine (hdc, cxClient, cyClient) ;
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_TIMER:
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
TimerRoutine (hdc, hPalette) ;
ReleaseDC (hwnd, hdc) ;
return 0 ;
case WM_QUERYNEWPALETTE:
if (!hPalette)
return FALSE ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
InvalidateRect (hwnd, NULL, TRUE) ;
ReleaseDC (hwnd, hdc) ;
return TRUE ;
case WM_PALETTECHANGED:
if (!hPalette || (HWND) wParam == hwnd)
break ;
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
UpdateColors (hdc) ;
ReleaseDC (hwnd, hdc) ;
break ;
case WM_DESTROY:
DestroyRoutine (hwnd, hPalette) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
LRESULT CALLBACK EXPORT AWLayoutWndProc
(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
BOOL fHandled = FALSE;
LRESULT lRet;
Layout* pLayout = (Layout*)GetWindowLong(hwnd, I_GWL_LAYOUT);
switch(uMsg)
{
case WM_CREATE:
pLayout = (Layout*)(((CREATESTRUCT*)lParam)->lpCreateParams);
SetWindowLong(hwnd, I_GWL_LAYOUT, (long)pLayout);
pLayout->m_hwndLayout = hwnd;
fHandled = TRUE;
lRet = 0L;
break;
case WM_SYSCOMMAND:
if((wParam & 0xFFF0)==SC_CLOSE)
{
FORWARD_WM_COMMAND(hwnd, IDM_EXIT, 0, 0, PostMessage);
fHandled = TRUE;
lRet = 0L;
break;
}
break;
case WM_QUERYENDSESSION:
MessageBeep(MB_ICONEXCLAMATION);
MessageBox(hwnd, "Window layout is still active.\r\n\r\nQuit the window layout before quitting Windows.", "Window Layout", MB_TASKMODAL | MB_OK | MB_ICONEXCLAMATION);
lRet = 0;
fHandled = TRUE;
break;
case WM_KEYDOWN:
(pLayout->m_shapes).KeyDown(pLayout->m_pWndActive, hwnd, (int)wParam, lParam);
fHandled = TRUE;
lRet = 0L;
break;
case WM_KEYUP:
(pLayout->m_shapes).KeyUp(pLayout->m_pWndActive, hwnd, (int)wParam, lParam);
fHandled = TRUE;
lRet = 0L;
break;
case WM_INITMENUPOPUP:
HANDLE_WM_INITMENUPOPUP(hwnd, wParam, lParam, pLayout->InitMenuPopup);
fHandled = TRUE;
lRet = 0L;
break;
case WM_PALETTECHANGED:
if ((pLayout->ActiveWindow()) && ((HWND)wParam==pLayout->ActiveWindow()->ClientWnd()))
break;
// else fall through
case WM_QUERYNEWPALETTE:
if(!IsIconic(hwnd) && pLayout->ActiveWindow() && WndData::GetPaletteHandle())
{
HDC hdc = GetDC(pLayout->ActiveWindow()->ClientWnd());
HPALETTE hpalOld = SelectPalette(hdc, WndData::GetPaletteHandle(), FALSE);
lRet = RealizePalette(hdc);
SelectPalette(hdc, hpalOld, TRUE);
RealizePalette(hdc);
ReleaseDC(pLayout->ActiveWindow()->ClientWnd(), hdc);
if(lRet)
InvalidateRect(pLayout->ActiveWindow()->ClientWnd(), NULL, TRUE);
fHandled = TRUE;
}
break;
case WM_HSCROLL:
HANDLE_WM_HSCROLL(hwnd, wParam, lParam, pLayout->HScroll);
fHandled = TRUE;
lRet = 0;
break;
case WM_VSCROLL:
HANDLE_WM_VSCROLL(hwnd, wParam, lParam, pLayout->VScroll);
fHandled = TRUE;
lRet = 0L;
break;
case WM_SIZE:
pLayout->UpdateScrollRegion();
fHandled = TRUE;
lRet = 0L;
break;
case WM_COMMAND:
HANDLE_WM_COMMAND(hwnd, wParam, lParam, pLayout->Command);
fHandled = TRUE;
lRet = 0L;
break;
case WM_NCACTIVATE:
if(!IsIconic(hwnd) && pLayout->m_pWndActive && pLayout->m_pWndActive->WndHandle())
SendMessage(pLayout->m_pWndActive->WndHandle(), uMsg, wParam, lParam);
break;
default:
break;
}
if(!fHandled)
lRet = DefWindowProc(hwnd, uMsg, wParam, lParam);
return lRet;
}
LRESULT CALLBACK
WinProc(HWND hWnd, /* I - Window triggering this event */
UINT uMsg, /* I - Message type */
WPARAM wParam, /* I - 'word' parameter value */
LPARAM lParam) /* I - 'long' parameter value */
{
PAINTSTRUCT ps; /* WM_PAINT message info */
RECT rect; /* Current client area rectangle */
switch (uMsg)
{
case WM_CREATE :
/*
* 'Create' message. Get device and rendering contexts, and
* setup the client area for OpenGL drawing...
*/
DC = GetDC(hWnd);
SetupContext();
break;
case WM_SIZE :
/*
* Handle resizes...
*/
GetClientRect(hWnd, &rect);
Resize(rect.right, rect.bottom);
case WM_PAINT :
/*
* Repaint the client area...
*/
BeginPaint(hWnd, &ps);
Redraw();
EndPaint(hWnd, &ps);
break;
case WM_QUIT :
case WM_CLOSE :
/*
* Destroy the window and exit...
*/
DestroyWindow(Window);
exit(0);
break;
case WM_DESTROY :
/*
* Release and free the device context, rendering
* context, and color palette...
*/
if (RC)
wglDeleteContext(RC);
if (DC)
ReleaseDC(Window, DC);
if (Palette)
DeleteObject(Palette);
PostQuitMessage(0);
break;
case WM_QUERYNEWPALETTE :
/*
* Realize the color palette if necessary...
*/
if (Palette)
{
SelectPalette(DC, Palette, FALSE);
RealizePalette(DC);
InvalidateRect(hWnd, NULL, FALSE);
return (TRUE);
}
break;
case WM_PALETTECHANGED:
/*
* Reselect our color palette if necessary...
*/
if (Palette && (HWND)wParam != hWnd)
{
SelectPalette(DC, Palette, FALSE);
RealizePalette(DC);
UpdateColors(DC);
}
break;
case WM_CHAR :
/*
* Handle key presses...
*/
Keyboard((unsigned char)wParam, 0, 0);
break;
default :
/*
* Pass all other messages through the default window
* procedure...
*/
return (DefWindowProc(hWnd, uMsg, wParam, lParam));
}
return (FALSE);
}
LONG CALLBACK AppWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
RECT Rect;
int key;
switch (msg)
{
case WM_COMMAND:
switch(LOWORD(wParam))
{
case CM_FILEEXIT:
DestroyWindow(hwndApp);
break;
case CM_FILEOPEN:
OpenBitmap();
break;
case CM_PALETTE:
if(!paletteWindow)
paletteWindow = CreateDialog(hInstApp, "PaletteControl", hwnd, (DLGPROC) PaletteDialog);
break;
}
break;
case WM_KEYDOWN:
case WM_KEYUP:
case WM_CREATE:
break;
case WM_PALETTECHANGED:
break;
case WM_QUERYNEWPALETTE:
{
BOOL changed;
HDC hDC = GetDC(hwnd);
if(sfc) sfc->setPalette(NULL);
changed = RealizePalette(hDC);
if(changed)
{
InvalidateRect(hwnd, NULL, TRUE);
//((GFXCDSSurface *)sfc)->setHWND(hwnd);
}
return changed;
}
case WM_SETCURSOR:
break;
case WM_ENTERMENULOOP:
break;
case WM_EXITMENULOOP:
break;
case WM_INITMENUPOPUP:
break;
case WM_DESTROY:
hwndApp = NULL;
PostQuitMessage(0);
break;
case WM_PAINT:
LPPAINTSTRUCT lpPaint;
//BeginPaint(hwnd, lpPaint);
if(sfc) sfc->update();
//EndPaint(hwnd, lpPaint);
return 1;
break;
case WM_MOVE:
case WM_SIZE:
break;
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
if(GetKeyState(VK_LBUTTON) < 0)
{
imgPoint.x = LOWORD(lParam);
imgPoint.y = HIWORD(lParam);
Redraw();
}
break;
}
return DefWindowProc(hwnd,msg,wParam,lParam);
}
int gr_palette_fade_in(ubyte *pal, int nsteps, int allow_keys)
{
HRESULT ddresult;
int i,j;
ubyte c;
fix fade_palette[768];
fix fade_palette_delta[768];
allow_keys = allow_keys;
Assert(_lpDDPalActive!=0);
if (!gr_palette_faded_out) return 0;
#ifndef NDEBUG
if (grd_fades_disabled) {
gr_palette_load(pal);
return 0;
}
#endif
for (i=0; i<768; i++ ) {
gr_current_pal[i] = pal[i];
fade_palette[i] = 0;
fade_palette_delta[i] = i2f(pal[i]+gr_palette_gamma) / nsteps;
}
for (j=0; j<nsteps; j++ ) {
for (i=0; i<256; i++ ) {
fade_palette[i*3] += fade_palette_delta[i*3];
fade_palette[i*3+1] += fade_palette_delta[i*3+1];
fade_palette[i*3+2] += fade_palette_delta[i*3+2];
if (fade_palette[i*3] > i2f(pal[i*3]+gr_palette_gamma) )
fade_palette[i*3] = i2f(pal[i*3]+gr_palette_gamma);
if (fade_palette[i*3+1] > i2f(pal[i*3+1]+gr_palette_gamma) )
fade_palette[i*3+1] = i2f(pal[i*3+1]+gr_palette_gamma);
if (fade_palette[i*3+2] > i2f(pal[i*3+2]+gr_palette_gamma) )
fade_palette[i*3+2] = i2f(pal[i*3+2]+gr_palette_gamma);
c = f2i(fade_palette[i*3]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peRed = c << 2;
c = f2i(fade_palette[i*3+1]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peGreen = c << 2;
c = f2i(fade_palette[i*3+2]);
if ( c > 63 ) c = 63;
PalGDIData.ScratchPal[i].peBlue = c << 2;
PalGDIData.ScratchPal[i].peFlags = 0;
}
if (!hPalGDI) {
IDirectDraw_WaitForVerticalBlank(lpDD, DDWAITVB_BLOCKBEGIN, NULL);
ddresult = IDirectDrawPalette_SetEntries(_lpDDPalActive, 0,
0, 256,
PalGDIData.ScratchPal);
Assert (ddresult == DD_OK);
}
else {
HDC hdc;
hdc = GetDC(GetLibraryWindow());
SetPaletteEntries(hPalGDI, 0, PalGDIData.num, PalGDIData.ScratchPal);
RealizePalette(hdc);
ReleaseDC(GetLibraryWindow(), hdc);
}
}
gr_palette_faded_out = 0;
return 0;
}