static void WinXSetupRadarWindow() { if (radarWindow) { /* if (instruments & SHOW_SLIDING_RADAR) { if (xid[radar].hwnd.hSaveDC != NULL) { ReleaseDC(xid[radar].hwnd.hWnd, xid[radar].hwnd.hBmpDC); xid[radar].hwnd.hBmpDC = xid[radar].hwnd.hSaveDC; xid[radar].hwnd.hSaveDC = NULL; } } else */ { if (xid[radarWindow].hwnd.hSaveDC == NULL) { HDC hNewDC = GetDC(xid[radarWindow].hwnd.hWnd); xid[radarWindow].hwnd.hSaveDC = xid[radarWindow].hwnd.hBmpDC; xid[radarWindow].hwnd.hBmpDC = hNewDC; SelectPalette(hNewDC, myPal, FALSE); RealizePalette(hNewDC); } } } }
void select_palette (struct frame *f, HDC hdc) { struct w32_display_info *display_info = FRAME_DISPLAY_INFO (f); if (!display_info->has_palette) return; if (display_info->palette == 0) return; if (!NILP (Vw32_enable_palette)) f->output_data.w32->old_palette = SelectPalette (hdc, display_info->palette, FALSE); else f->output_data.w32->old_palette = NULL; if (RealizePalette (hdc) != GDI_ERROR) { Lisp_Object frame, framelist; FOR_EACH_FRAME (framelist, frame) { SET_FRAME_GARBAGED (XFRAME (frame)); }
long far PASCAL _export LayoutWndProc ( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { SCALE *scale ; scale = (SCALE*) GetWindowLong(GetParent(hwnd), DWL_USER) ; if (!scale) DefWindowProc (hwnd, message, wParam, lParam) ; switch(message) { case WM_CREATE: scale->ScaleSetScrollPos(hwnd) ; return 0 ; case WM_PAINT: scale->RepaintBitmap(hwnd) ; return 0 ; case WM_PALETTECHANGED: // if the palette was realized by this window itself, then ignore it if ((HWND) wParam == hwnd) return 0; /* else, fall through */ case WM_QUERYNEWPALETTE: if (PaletteCls::GetPaletteHandle()) { HDC hdc = GetDC(hwnd); HPALETTE hpalOld = SelectPalette(hdc, PaletteCls::GetPaletteHandle(), FALSE); BOOL lRet = RealizePalette(hdc); SelectPalette(hdc, hpalOld, TRUE); RealizePalette(hdc); ReleaseDC(hwnd, hdc); if(lRet) InvalidateRect(hwnd, NULL, TRUE); return 1; } return 0; case WM_VSCROLL: scale->DoVscroll (hwnd, wParam, lParam) ; return 0 ; case WM_HSCROLL: scale->DoHscroll (hwnd, wParam, lParam) ; return 0 ; case WM_LBUTTONDOWN: if (!scale->MouseDown (hwnd, lParam)) return 0 ; break ; case WM_MOUSEMOVE: if(!scale->MoveBitmap(hwnd,wParam, lParam) ) return 0 ; break ; case WM_LBUTTONUP: if (scale->MouseUp(hwnd)) return 0 ; break ; } return DefWindowProc (hwnd, message, wParam, lParam) ; }
HDIB 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 = (LPBITMAPINFOHEADER)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, (UINT) 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); // Unlock the new DIB's memory block if (hNewDIB) GlobalUnlock(hNewDIB); DeleteObject(hBitmap); DeleteObject(hPal); return hNewDIB; }
HDIB 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 = (LPBITMAPINFOHEADER)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, (UINT) 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); } // Unlock the new DIB's memory block if (hNewDIB) GlobalUnlock(hNewDIB); return hNewDIB; }
BOOL BinImg::SaveToFile(HBITMAP hBitmap,LPCTSTR lpszFileName) { 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("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(lpszFileName, 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; }
LRESULT CALLBACK WndProc(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam) { int i; static bool palette_changed = false; switch (messg) { case WM_PAINT: if (hdc[0] == 0) { hdc[0] = BeginPaint(hWnd, &ps); SelectPalette(hdc[0], hPalette, FALSE); RealizePalette(hdc[0]); hdc[1] = CreateCompatibleDC(hdc[0]); SelectPalette(hdc[1], hPalette, FALSE); hdc[2] = CreateCompatibleDC(hdc[0]); SelectPalette(hdc[2], hPalette, FALSE); hdc[3] = CreateCompatibleDC(hdc[0]); SelectPalette(hdc[3], hPalette, FALSE); screen_width = GetDeviceCaps(hdc[0], HORZRES); screen_height = GetDeviceCaps(hdc[0], VERTRES); hBitmap[active_page] = CreateCompatibleBitmap(hdc[0], screen_width, screen_height); SelectObject(hdc[1], hBitmap[active_page]); SetTextColor(hdc[0], PALETTEINDEX(text_color+BG)); SetTextColor(hdc[1], PALETTEINDEX(text_color+BG)); SetBkColor(hdc[0], PALETTEINDEX(BG)); SetBkColor(hdc[1], PALETTEINDEX(BG)); SelectObject(hdc[0], hBrush[fill_settings.pattern]); SelectObject(hdc[1], hBrush[fill_settings.pattern]); RECT scr; scr.left = -view_settings.left; scr.top = -view_settings.top; scr.right = screen_width-view_settings.left-1; scr.bottom = screen_height-view_settings.top-1; FillRect(hdc[1], &scr, hBackgroundBrush); } if (hRgn != NULL) { SelectClipRgn(hdc[0], NULL); } if (visual_page != active_page) { SelectObject(hdc[1], hBitmap[visual_page]); } BitBlt(hdc[0], -view_settings.left, -view_settings.top, window_width, window_height, hdc[1], -view_settings.left, -view_settings.top, SRCCOPY); if (hRgn != NULL) { SelectClipRgn(hdc[0], hRgn); } if (visual_page != active_page) { SelectObject(hdc[1], hBitmap[active_page]); } ValidateRect(hWnd, NULL); break; case WM_SETFOCUS: if (palette_changed) { HPALETTE new_palette = CreatePalette(pPalette); SelectPalette(hdc[0], new_palette, FALSE); RealizePalette(hdc[0]); SelectPalette(hdc[1], new_palette, FALSE); SelectPalette(hdc[2], new_palette, FALSE); SelectPalette(hdc[3], new_palette, FALSE); DeleteObject(hPalette); hPalette = new_palette; palette_changed = false; } break; case WM_PALETTECHANGED: RealizePalette(hdc[0]); UpdateColors(hdc[0]); palette_changed = true; break; case WM_DESTROY: EndPaint(hWnd, &ps); hdc[0] = 0; DeleteObject(hdc[1]); DeleteObject(hdc[2]); DeleteObject(hdc[3]); if (hPutimageBitmap) { DeleteObject(hPutimageBitmap); hPutimageBitmap = NULL; } for (i = 0; i < MAX_PAGES; i++) { if (hBitmap[i] != NULL) { DeleteObject(hBitmap[i]); hBitmap[i] = 0; } } DeleteObject(hPalette); hPalette = 0; PostQuitMessage(0); break; case WM_SIZE: window_width = LOWORD(lParam); window_height = HIWORD(lParam); break; case WM_TIMER: KillTimer(hWnd, TIMER_ID); timeout_expired = true; break; case WM_CHAR: kbd_queue.put((TCHAR) wParam); break; // Handle some mouse events, too (1-Oct-2000, Matthew Weathers, Erik Habbestad) case WM_LBUTTONDOWN: iClickedMouseX = LOWORD(lParam); iClickedMouseY = HIWORD(lParam); bMouseDown = true; iWhichMouseButton = LEFT_BUTTON; break; case WM_LBUTTONUP: iClickedMouseX = LOWORD(lParam); iClickedMouseY = HIWORD(lParam); bMouseUp = true; iWhichMouseButton = LEFT_BUTTON; break; case WM_RBUTTONDOWN: iClickedMouseX = LOWORD(lParam); iClickedMouseY = HIWORD(lParam); bMouseDown = true; iWhichMouseButton = RIGHT_BUTTON; break; case WM_RBUTTONUP: iClickedMouseX = LOWORD(lParam); iClickedMouseY = HIWORD(lParam); bMouseUp = true; iWhichMouseButton = RIGHT_BUTTON; break; case WM_MOUSEMOVE: iCurrentMouseX = LOWORD(lParam); iCurrentMouseY = HIWORD(lParam); break; default: return DefWindowProc(hWnd, messg, wParam, lParam); } return 0; }
static void test_DIB_PAL_COLORS(void) { HDC hdc = GetDC( NULL ); HDC memhdc = CreateCompatibleDC( hdc ); HBITMAP hbmp, hbmpOld; char bmpbuf[sizeof(BITMAPINFO) + 10 * sizeof(WORD)]; PBITMAPINFO bmp = (PBITMAPINFO)bmpbuf; WORD * bmpPalPtr; char logpalettebuf[sizeof(LOGPALETTE) + sizeof(logpalettedata)]; PLOGPALETTE logpalette = (PLOGPALETTE)logpalettebuf; HPALETTE hpal, hpalOld; COLORREF setColor, chkColor, getColor; int i; /* Initialize the logical palette with a few colours */ logpalette->palVersion = 0x300; logpalette->palNumEntries = 8; memcpy( logpalette->palPalEntry, logpalettedata, sizeof(logpalettedata) ); hpal = CreatePalette( logpalette ); hpalOld = SelectPalette( memhdc, hpal, FALSE ); ok( hpalOld != NULL, "error=%d\n", GetLastError() ); /* Create a DIB BMP which references colours in the logical palette */ memset( bmp, 0x00, sizeof(BITMAPINFO) ); bmp->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmp->bmiHeader.biWidth = 1; bmp->bmiHeader.biHeight = 1; bmp->bmiHeader.biPlanes = 1; bmp->bmiHeader.biBitCount = 8; bmp->bmiHeader.biCompression = BI_RGB; bmp->bmiHeader.biClrUsed = 10; bmp->bmiHeader.biClrImportant = 0; bmpPalPtr = (WORD *)&bmp->bmiColors; for( i = 0; i < 8; i++ ) { *bmpPalPtr++ = i; } *bmpPalPtr++ = 8; /* Pointer to logical palette index just outside range */ *bmpPalPtr++ = 19; /* Pointer to bad logical palette index */ hbmp = CreateDIBSection( memhdc, bmp, DIB_PAL_COLORS, 0, 0, 0 ); ok( hbmp != NULL, "error=%d\n", GetLastError() ); hbmpOld = SelectObject( memhdc, hbmp ); ok( hbmpOld != NULL, "error=%d\n", GetLastError() ); /* Test with a RGB to DIB_PAL_COLORS */ setColor = RGB( logpalettedata[1].peRed, logpalettedata[1].peGreen, logpalettedata[1].peBlue ); SetPixel( memhdc, 0, 0, setColor ); chkColor = RGB( logpalettedata[1].peRed, logpalettedata[1].peGreen, logpalettedata[1].peBlue ); getColor = GetPixel( memhdc, 0, 0 ); ok( getColor == chkColor, "getColor=%08X\n", (UINT)getColor ); /* Test with a valid DIBINDEX to DIB_PAL_COLORS */ setColor = DIBINDEX( 2 ); SetPixel( memhdc, 0, 0, setColor ); chkColor = RGB( logpalettedata[2].peRed, logpalettedata[2].peGreen, logpalettedata[2].peBlue ); getColor = GetPixel( memhdc, 0, 0 ); ok( getColor == chkColor, "getColor=%08X\n", (UINT)getColor ); /* Test with an invalid DIBINDEX to DIB_PAL_COLORS */ setColor = DIBINDEX( 12 ); SetPixel( memhdc, 0, 0, setColor ); chkColor = RGB( 0, 0, 0 ); getColor = GetPixel( memhdc, 0, 0 ); ok( getColor == chkColor, "getColor=%08X\n", (UINT)getColor ); /* Test for double wraparound on logical palette references from */ /* DIBINDEX by DIB_PAL_COLORS. */ setColor = DIBINDEX( 9 ); SetPixel( memhdc, 0, 0, setColor ); chkColor = RGB( logpalettedata[3].peRed, logpalettedata[3].peGreen, logpalettedata[3].peBlue ); getColor = GetPixel( memhdc, 0, 0 ); ok( getColor == chkColor, "getColor=%08X\n", (UINT)getColor ); SelectPalette( memhdc, hpalOld, FALSE ); DeleteObject( hpal ); SelectObject( memhdc, hbmpOld ); DeleteObject( hbmp ); DeleteDC( memhdc ); ReleaseDC( NULL, hdc ); }
// **************************************************************************** // // Function Name: LoadResourceBitmap( ) // // Description: Load DIB from resource and get it's palette // // Returns: bitmap handle or NULL on failure // // Exceptions: None // // **************************************************************************** // HBITMAP LoadResourceBitmap(HINSTANCE hInstance, LPSTR lpString, HPALETTE FAR* lphPalette) { // initialise all our variables HRSRC hRsrc = NULL; HGLOBAL hGlobal = NULL; HGLOBAL hTemp = NULL; DWORD dwSize = 0; HBITMAP hBitmapFinal = NULL; HPALETTE hPalOld = NULL; LPSTR lpRes = NULL; LPSTR lpNew = NULL; HDC hdc = NULL; int iNumColors = 0; LPBITMAPINFOHEADER lpbi = NULL; // find the resource in the resource file hRsrc = FindResource(hInstance, lpString, RT_BITMAP); if ( hRsrc != NULL ) { // get a handle to the resource data hTemp = LoadResource(hInstance, hRsrc); if ( hTemp != NULL ) { // get it's size dwSize = SizeofResource(hInstance, hRsrc); // lock the resource data lpRes = (char*) LockResource(hTemp); if ( lpRes != NULL ) { // allocate memory to copy the data hGlobal = GlobalAlloc(GHND, dwSize); if ( hGlobal != NULL ) { // lock the allocated memory lpNew = (char*)GlobalLock(hGlobal); if ( lpNew != NULL ) { // copy the data memcpy(lpNew, lpRes, dwSize); // unlock and free the resource UnlockResource(hTemp); FreeResource(hTemp); lpbi = (LPBITMAPINFOHEADER)lpNew; // get a screen DC compatible with the screen hdc = GetDC(NULL); // create a palette from the bitmap info header *lphPalette = CreateDIBPalette ((LPBITMAPINFO)lpbi, &iNumColors); // select the palette into the DC if (*lphPalette) { hPalOld = SelectPalette(hdc,*lphPalette,FALSE); RealizePalette(hdc); } // create the DIB bitmap using the DC's palette hBitmapFinal = CreateDIBitmap( hdc, (LPBITMAPINFOHEADER)lpbi, (LONG) CBM_INIT, (LPSTR)lpbi + lpbi->biSize + iNumColors * sizeof(RGBQUAD), (LPBITMAPINFO)lpbi, DIB_RGB_COLORS ); if ( *lphPalette && hPalOld ) SelectPalette(hdc,hPalOld,FALSE); // release the HDC ReleaseDC(NULL,hdc); // unlock the allocated bitmap data GlobalUnlock(hGlobal); } // GlobalLock failed // free the bitmpa data GlobalFree(hGlobal); } // GlobalAlloc failed } // LockResource failed } // LoadResource failed } // FindResource failed // return the bitmap return hBitmapFinal; }
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static HBITMAP hBitmap ; static HPALETTE hPalette ; static int cxClient, cyClient ; static OPENFILENAME ofn ; static PBYTE pBits ; static TCHAR szFileName [MAX_PATH], szTitleName [MAX_PATH] ; static TCHAR szFilter[] = TEXT ("Bitmap Files (*.BMP)\0*.bmp\0") TEXT ("All Files (*.*)\0*.*\0\0") ; BITMAP bitmap ; BITMAPINFO * pPackedDib ; HDC hdc, hdcMem ; PAINTSTRUCT ps ; switch (message) { case WM_CREATE: ofn.lStructSize = sizeof (OPENFILENAME) ; ofn.hwndOwner = hwnd ; ofn.hInstance = NULL ; ofn.lpstrFilter = szFilter ; ofn.lpstrCustomFilter = NULL ; ofn.nMaxCustFilter = 0 ; ofn.nFilterIndex = 0 ; ofn.lpstrFile = szFileName ; ofn.nMaxFile = MAX_PATH ; ofn.lpstrFileTitle = szTitleName ; ofn.nMaxFileTitle = MAX_PATH ; ofn.lpstrInitialDir = NULL ; ofn.lpstrTitle = NULL ; ofn.Flags = 0 ; ofn.nFileOffset = 0 ; ofn.nFileExtension = 0 ; ofn.lpstrDefExt = TEXT ("bmp") ; ofn.lCustData = 0 ; ofn.lpfnHook = NULL ; ofn.lpTemplateName = NULL ; return 0 ; case WM_SIZE: cxClient = LOWORD (lParam) ; cyClient = HIWORD (lParam) ; return 0 ; case WM_COMMAND: switch (LOWORD (wParam)) { case IDM_FILE_OPEN: // Show the File Open dialog box if (!GetOpenFileName (&ofn)) return 0 ; // If there's an existing packed DIB, free the memory if (hBitmap) { DeleteObject (hBitmap) ; hBitmap = NULL ; } // If there's an existing logical palette, delete it if (hPalette) { DeleteObject (hPalette) ; hPalette = NULL ; } // Load the packed DIB into memory SetCursor (LoadCursor (NULL, IDC_WAIT)) ; ShowCursor (TRUE) ; pPackedDib = PackedDibLoad (szFileName) ; ShowCursor (FALSE) ; SetCursor (LoadCursor (NULL, IDC_ARROW)) ; if (pPackedDib) { // Create the DIB section from the DIB hBitmap = CreateDIBSection (NULL, pPackedDib, DIB_RGB_COLORS, &pBits, NULL, 0) ; // Copy the bits CopyMemory (pBits, PackedDibGetBitsPtr (pPackedDib), PackedDibGetBitsSize (pPackedDib)) ; // Create palette from the DIB hPalette = PackedDibCreatePalette (pPackedDib) ; // Free the packed-DIB memory free (pPackedDib) ; } else { MessageBox (hwnd, TEXT ("Cannot load DIB file"), szAppName, 0) ; } InvalidateRect (hwnd, NULL, TRUE) ; return 0 ; } break ; case WM_PAINT: hdc = BeginPaint (hwnd, &ps) ; if (hPalette) { SelectPalette (hdc, hPalette, FALSE) ; RealizePalette (hdc) ; } if (hBitmap) { GetObject (hBitmap, sizeof (BITMAP), &bitmap) ; hdcMem = CreateCompatibleDC (hdc) ; SelectObject (hdcMem, hBitmap) ; BitBlt (hdc, 0, 0, bitmap.bmWidth, bitmap.bmHeight, hdcMem, 0, 0, SRCCOPY) ; DeleteDC (hdcMem) ; } EndPaint (hwnd, &ps) ; 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: if (hBitmap) DeleteObject (hBitmap) ; if (hPalette) DeleteObject (hPalette) ; PostQuitMessage (0) ; return 0 ; } return DefWindowProc (hwnd, message, wParam, lParam) ; }
void AboutTimer(HWND hwnd, UINT id) { HWND hwndBitmap; HDC hdc; int i, j, k, x, y; RECT r; PDIB pdib; BYTE *bits, index; object_node *obj; // Copy bits to offscreen area for (i=0; i < scroll_height; i++) { int yBitmap = (scroll_y + i) % DibHeight(credits_pdib); BYTE *pSource = DibPtr(credits_pdib) + (yBitmap * DibWidth(credits_pdib)); BYTE *pDest = gBits + i*DIBWIDTH(gbits_width); memcpy(pDest,pSource,scroll_width); } scroll_y++; if (scroll_y >= DibHeight(credits_pdib)) scroll_y = 0; hwndBitmap = GetDlgItem(hwnd, IDC_SCROLL); hdc = GetDC(hwndBitmap); SelectPalette(hdc, hPal, FALSE); BitBlt(hdc, 0, 0, scroll_width, scroll_height, gDC, 0, 0, SRCCOPY); ReleaseDC(hwndBitmap, hdc); // Draw animated characters r.left = r.top = 0; r.right = gbits_width; r.bottom = gbits_height; FillRect(gDC, &r, GetSysColorBrush(COLOR_3DFACE)); GdiFlush(); hdc = GetDC(hwnd); for (i=0; i < NUM_DUDES; i++) { if (dudes[i].obj != NULL) { obj = dudes[i].obj; if (rand() % 30 == 0) { obj->animate->animation = ANIMATE_ONCE; obj->animate->group = obj->animate->group_low = 3; obj->animate->group_high = 4; obj->animate->group_final = 0; obj->animate->period = obj->animate->tick = 400; if (config.play_sound) { switch (dudes[i].obj->icon_res) { case ABOUT_RSC1: index = 3; break; case ABOUT_RSC2: index = 4; break; case ABOUT_RSC3: index = 5; break; default: index = rand() % num_sounds; break; } SoundPlayFile(sounds[index], SF_RANDOM_PITCH); } } AnimateObject(dudes[i].obj, ABOUT_INTERVAL); pdib = GetObjectPdib(dudes[i].obj->icon_res, dudes[i].angle, dudes[i].obj->animate->group); if (pdib == NULL) continue; bits = DibPtr(pdib); x = dudes[i].x - DibWidth(pdib) / 2; y = DUDE_MAX_HEIGHT - DibHeight(pdib); for (j=0; j < DibHeight(pdib); j++) { for (k=0; k < DibWidth(pdib); k++) { index = *(bits + j * DibWidth(pdib) + k); if (index != TRANSPARENT_INDEX) *(gBits + (j + y) * DIBWIDTH(gbits_width) + x + k) = index; } } } } SelectPalette(hdc, hPal, FALSE); BitBlt(hdc, dude_x, dude_y, DUDE_AREA_WIDTH, DUDE_MAX_HEIGHT, gDC, 0, 0, SRCCOPY); ReleaseDC(hwnd, hdc); }
VOID StoreSelection( IN PCONSOLE_INFORMATION Console ) /*++ StoreSelection - Store selection (if present) into the Clipboard --*/ { PCHAR_INFO Selection,CurCharInfo; COORD SourcePoint; COORD TargetSize; SMALL_RECT TargetRect; PWCHAR CurChar,CharBuf; HANDLE ClipboardDataHandle; SHORT i,j; BOOL Success; PSCREEN_INFORMATION ScreenInfo; BOOL bFalseUnicode; // // See if there is a selection to get // if (!(Console->SelectionFlags & CONSOLE_SELECTION_NOT_EMPTY)) { return; } // // read selection rectangle. clip it first. // ScreenInfo = Console->CurrentScreenBuffer; if (Console->SelectionRect.Left < 0) { Console->SelectionRect.Left = 0; } if (Console->SelectionRect.Top < 0) { Console->SelectionRect.Top = 0; } if (Console->SelectionRect.Right >= ScreenInfo->ScreenBufferSize.X) { Console->SelectionRect.Right = (SHORT)(ScreenInfo->ScreenBufferSize.X-1); } if (Console->SelectionRect.Bottom >= ScreenInfo->ScreenBufferSize.Y) { Console->SelectionRect.Bottom = (SHORT)(ScreenInfo->ScreenBufferSize.Y-1); } TargetSize.X = WINDOW_SIZE_X(&Console->SelectionRect); TargetSize.Y = WINDOW_SIZE_Y(&Console->SelectionRect); if (ScreenInfo->Flags & CONSOLE_TEXTMODE_BUFFER) { Selection = (PCHAR_INFO)HeapAlloc(pConHeap,MAKE_TAG( TMP_TAG ),sizeof(CHAR_INFO) * TargetSize.X * TargetSize.Y); if (Selection == NULL) return; #ifdef _X86_ if ((Console->FullScreenFlags & CONSOLE_FULLSCREEN) && (Console->Flags & CONSOLE_VDM_REGISTERED)) { ReadRegionFromScreenHW(ScreenInfo, &Console->SelectionRect, Selection); } else { #endif SourcePoint.X = Console->SelectionRect.Left; SourcePoint.Y = Console->SelectionRect.Top; TargetRect.Left = TargetRect.Top = 0; TargetRect.Right = (SHORT)(TargetSize.X-1); TargetRect.Bottom = (SHORT)(TargetSize.Y-1); ReadRectFromScreenBuffer(ScreenInfo, SourcePoint, Selection, TargetSize, &TargetRect); #ifdef _X86_ } #endif // extra 2 per line is for CRLF, extra 1 is for null ClipboardDataHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (TargetSize.Y * (TargetSize.X + 2) + 1) * sizeof(WCHAR)); if (ClipboardDataHandle == NULL) { HeapFree(pConHeap,0,Selection); return; } // // convert to clipboard form // CurCharInfo = Selection; CurChar = CharBuf = GlobalLock(ClipboardDataHandle); bFalseUnicode = ((ScreenInfo->Flags & CONSOLE_OEMFONT_DISPLAY) && !(Console->FullScreenFlags & CONSOLE_FULLSCREEN)); for (i=0;i<TargetSize.Y;i++) { PWCHAR pwchLineStart = CurChar; for (j=0;j<TargetSize.X;j++,CurCharInfo++,CurChar++) { *CurChar = CurCharInfo->Char.UnicodeChar; if (*CurChar == 0) { *CurChar = UNICODE_SPACE; } } // trim trailing spaces CurChar--; while ((CurChar >= pwchLineStart) && (*CurChar == UNICODE_SPACE)) CurChar--; CurChar++; if (bFalseUnicode) { FalseUnicodeToRealUnicode(pwchLineStart, CurChar - pwchLineStart, Console->OutputCP); } *CurChar++ = UNICODE_CARRIAGERETURN; *CurChar++ = UNICODE_LINEFEED; } if (TargetSize.Y) CurChar -= 2; // don't put CRLF on last line *CurChar = '\0'; // null terminate GlobalUnlock(ClipboardDataHandle); HeapFree(pConHeap,0,Selection); Success = OpenClipboard(Console->hWnd); if (!Success) { GlobalFree(ClipboardDataHandle); return; } Success = EmptyClipboard(); if (!Success) { GlobalFree(ClipboardDataHandle); return; } SetClipboardData(CF_UNICODETEXT,ClipboardDataHandle); CloseClipboard(); // Close clipboard } else { HBITMAP hBitmapTarget, hBitmapOld; HDC hDCMem; HPALETTE hPaletteOld; int Height; NtWaitForSingleObject(ScreenInfo->BufferInfo.GraphicsInfo.hMutex, FALSE, NULL); hDCMem = CreateCompatibleDC(Console->hDC); hBitmapTarget = CreateCompatibleBitmap(Console->hDC, TargetSize.X, TargetSize.Y); if (hBitmapTarget) { hBitmapOld = SelectObject(hDCMem, hBitmapTarget); if (ScreenInfo->hPalette) { hPaletteOld = SelectPalette(hDCMem, ScreenInfo->hPalette, FALSE); } MyInvert(Console,&Console->SelectionRect); // if (DIB is a top-down) // ySrc = abs(height) - rect.bottom - 1; // else // ySrc = rect.Bottom. // Height = ScreenInfo->BufferInfo.GraphicsInfo.lpBitMapInfo->bmiHeader.biHeight; StretchDIBits(hDCMem, 0, 0, TargetSize.X, TargetSize.Y, Console->SelectionRect.Left + ScreenInfo->Window.Left, (Height < 0) ? -Height - (Console->SelectionRect.Bottom + ScreenInfo->Window.Top) - 1 : Console->SelectionRect.Bottom + ScreenInfo->Window.Top, TargetSize.X, TargetSize.Y, ScreenInfo->BufferInfo.GraphicsInfo.BitMap, ScreenInfo->BufferInfo.GraphicsInfo.lpBitMapInfo, ScreenInfo->BufferInfo.GraphicsInfo.dwUsage, SRCCOPY); MyInvert(Console,&Console->SelectionRect); if (ScreenInfo->hPalette) { SelectPalette(hDCMem, hPaletteOld, FALSE); } SelectObject(hDCMem, hBitmapOld); OpenClipboard(Console->hWnd); EmptyClipboard(); SetClipboardData(CF_BITMAP,hBitmapTarget); CloseClipboard(); } DeleteDC(hDCMem); NtReleaseMutant(ScreenInfo->BufferInfo.GraphicsInfo.hMutex, NULL); } }
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); }
void setupPalette(HDC hDC) { PIXELFORMATDESCRIPTOR pfd; LOGPALETTE* pPal; int pixelFormat = GetPixelFormat(hDC); int paletteSize; DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd); /* ** Determine if a palette is needed and if so what size. */ if (pfd.dwFlags & PFD_NEED_PALETTE || pfd.iPixelType == PFD_TYPE_COLORINDEX) { paletteSize = 1 << pfd.cColorBits; if (paletteSize > 4096) { paletteSize = 4096; } } else { return; } pPal = (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY)); pPal->palVersion = 0x300; pPal->palNumEntries = paletteSize; /* ** Fill the logical palette with color ramps. ** ** Set up the logical palette so that it can be realized ** into the system palette as an identity palette. ** ** 1) The default static entries should be present and at the right ** location. The easiest way to do this is to grab them from ** the current system palette. ** ** 2) All non-static entries should be initialized to unique values. ** The easiest way to do this is to ensure that all of the non-static ** entries have the PC_NOCOLLAPSE flag bit set. */ { int numRamps = NUM_COLORS; int rampSize = (paletteSize - 20) / numRamps; int extra = (paletteSize - 20) - (numRamps * rampSize); int i, r; /* ** Initialize static entries by copying them from the ** current system palette. */ GetSystemPaletteEntries(hDC, 0, paletteSize, &pPal->palPalEntry[0]); /* ** Fill in non-static entries with desired colors. */ for (r=0; r<numRamps; ++r) { int rampBase = r * rampSize + 10; PALETTEENTRY *pe = &pPal->palPalEntry[rampBase]; int diffSize = (int) (rampSize * colors[r].ratio); int specSize = rampSize - diffSize; for (i=0; i<rampSize; ++i) { GLfloat *c0, *c1; GLint a; if (i < diffSize) { c0 = colors[r].amb; c1 = colors[r].diff; a = (i * 255) / (diffSize - 1); } else { c0 = colors[r].diff; c1 = colors[r].spec; a = ((i - diffSize) * 255) / (specSize - 1); } pe[i].peRed = (BYTE) (a * (c1[0] - c0[0]) + 255 * c0[0]); pe[i].peGreen = (BYTE) (a * (c1[1] - c0[1]) + 255 * c0[1]); pe[i].peBlue = (BYTE) (a * (c1[2] - c0[2]) + 255 * c0[2]); pe[i].peFlags = PC_NOCOLLAPSE; } colors[r].indexes[0] = rampBase; colors[r].indexes[1] = rampBase + (diffSize-1); colors[r].indexes[2] = rampBase + (rampSize-1); } /* ** Initialize any remaining non-static entries. */ for (i=0; i<extra; ++i) { int index = numRamps*rampSize+10+i; PALETTEENTRY *pe = &pPal->palPalEntry[index]; pe->peRed = (BYTE) 0; pe->peGreen = (BYTE) 0; pe->peBlue = (BYTE) 0; pe->peFlags = PC_NOCOLLAPSE; } } hPalette = CreatePalette(pPal); free(pPal); if (hPalette) { SelectPalette(hDC, hPalette, FALSE); RealizePalette(hDC); } }
// from "Windows Palettes in RGBA mode" on MSDN void OpenGL :: SetPalette() { int ct; // counter int r,g,b; // colour counters int num; // number of colours HPALETTE hpal; // handle to palette LOGPALETTE *pal; // our palette PIXELFORMATDESCRIPTOR pf; // pixel format PALETTEENTRY *ppe; // the remaining palette // do we need this palette DescribePixelFormat(hDC,GetPixelFormat(hDC),sizeof(PIXELFORMATDESCRIPTOR),&pf); if(!(pf.dwFlags & PFD_NEED_PALETTE)) return; // allocate our palette pal=(LOGPALETTE *)new BYTE [sizeof(LOGPALETTE)+(256*sizeof(PALETTEENTRY))]; // setup the palette pal->palVersion=0x300; pal->palNumEntries=256; // get the number of colours num=1<<pf.cColorBits; // fill the colour array for(ct=0; ct<num; ct++) { pal->palPalEntry[ct].peRed= this->ComponentFromIndex(ct,pf.cRedBits,pf.cRedShift); pal->palPalEntry[ct].peGreen= this->ComponentFromIndex(ct,pf.cGreenBits,pf.cGreenShift); pal->palPalEntry[ct].peBlue= this->ComponentFromIndex(ct,pf.cBlueBits,pf.cBlueShift); pal->palPalEntry[ct].peFlags=0; } // sort out windows colours for 3:3:2 if( (pf.cRedBits==3) && (pf.cRedShift==0) && (pf.cGreenBits==3) && (pf.cGreenShift==3) && (pf.cBlueBits==2) && (pf.cBlueShift==6) ) { for(ct=1; ct<=12; ct++) pal->palPalEntry[palDefaultOverride[ct]]= palDefaultPalEntry[ct]; }else{ // Get the system colours GetSystemPaletteEntries(hDC,0,10,&pal->palPalEntry[0]); GetSystemPaletteEntries(hDC,246,10,&pal->palPalEntry[246]); // get start position ppe=&pal->palPalEntry[10]; // create a colour cube for(r=0; r<6; r++) for(g=0; g<6; g++) for(b=0; b<6; b++) { ppe->peRed=(unsigned char)(r*255/6); ppe->peGreen=(unsigned char)(g*255/6); ppe->peBlue=(unsigned char)(b*255/6); ppe->peFlags=PC_NOCOLLAPSE; ppe++; } // and grey scale for(ct=0; ct<20; ct++) { ppe->peRed=(unsigned char)(ct*255/6); ppe->peGreen=(unsigned char)(ct*255/6); ppe->peBlue=(unsigned char)(ct*255/6); ppe->peFlags=PC_NOCOLLAPSE; ppe++; } } // set the palette hpal=CreatePalette(pal); SelectPalette(hDC,hpal,TRUE); RealizePalette(hDC); }
BOOL CALLBACK IntroDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { BOOL bReturnCode = FALSE; pgpConfigInfo * pConfig = NULL; g_hCurrentDlgWnd = hwndDlg; if (uMsg != WM_INITDIALOG) pConfig = (pgpConfigInfo *) GetWindowLong(hwndDlg, GWL_USERDATA); switch(uMsg) { case WM_INITDIALOG: { RECT rc; PROPSHEETPAGE *ppspConfig = (PROPSHEETPAGE *) lParam; // center dialog on screen GetWindowRect(GetParent(hwndDlg), &rc); SetWindowPos (GetParent(hwndDlg), NULL, (GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left))/2, (GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top))/2, 0, 0, SWP_NOSIZE | SWP_NOZORDER); pConfig = (pgpConfigInfo *) ppspConfig->lParam; SetWindowLong(hwndDlg, GWL_USERDATA, (LPARAM) pConfig); break; } case WM_PAINT: if (pConfig->hPalette) { PAINTSTRUCT ps; HDC hDC = BeginPaint (hwndDlg, &ps); SelectPalette (hDC, pConfig->hPalette, FALSE); RealizePalette (hDC); EndPaint (hwndDlg, &ps); bReturnCode = TRUE; } break; case WM_NOTIFY: { LPNMHDR pnmh; pnmh = (LPNMHDR) lParam; switch(pnmh->code) { case PSN_SETACTIVE: { // Initialize window PostMessage(GetParent(hwndDlg), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT | PSWIZB_BACK); SendDlgItemMessage(hwndDlg, IDC_WIZBITMAP, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM) pConfig->hBitmap); bReturnCode = TRUE; break; } case PSN_KILLACTIVE: { // Save user data for this page break; } case PSN_WIZFINISH: { // Save user data for all pages break; } case PSN_HELP: { // Display help break; } case PSN_QUERYCANCEL: { // User wants to quit g_bGotReloadMsg = FALSE; break; } } break; } } return(bReturnCode); }
static LONG WINAPI WindowFunc(HWND hWnd,UINT msg,WPARAM wp,LPARAM lp) { switch(msg) { case WM_QUERYNEWPALETTE: case WM_PALETTECHANGED: if(NULL!=fsWin32Internal.hPlt) { SelectPalette(fsWin32Internal.hDC,fsWin32Internal.hPlt,FALSE); RealizePalette(fsWin32Internal.hDC); } return DefWindowProc(hWnd,msg,wp,lp); case WM_CREATE: fsWin32Internal.hDC=GetDC(hWnd); YsSetPixelFormat(fsWin32Internal.hDC); fsWin32Internal.hRC=wglCreateContext(fsWin32Internal.hDC); wglMakeCurrent(fsWin32Internal.hDC,fsWin32Internal.hRC); if(0==doubleBuffer) { glDrawBuffer(GL_FRONT); } InitializeOpenGL(hWnd); break; case WM_SIZE: wglMakeCurrent(fsWin32Internal.hDC,fsWin32Internal.hRC); break; case WM_PAINT: wglMakeCurrent(fsWin32Internal.hDC,fsWin32Internal.hRC); exposure=1; return DefWindowProc(hWnd,msg,wp,lp); case WM_COMMAND: break; case WM_DESTROY: exit(1); break; case WM_MOUSEWHEEL: { int step; step=HIWORD(wp); if(step>=0x8000) { step-=0x10000; } step/=WHEEL_DELTA; if(step>0) { while(step>0) { if(nKeyBufUsed<NKEYBUF) { keyBuffer[nKeyBufUsed++]=FSKEY_WHEELUP; } step--; } } else if(step<0) { while(step<0) { if(nKeyBufUsed<NKEYBUF) { keyBuffer[nKeyBufUsed++]=FSKEY_WHEELDOWN; } step++; } } } break; case WM_SYSKEYDOWN: if((lp & (1<<29))!=0 && // Alt (wp==VK_MENU || wp==VK_OEM_1 || wp==VK_OEM_PLUS || wp==VK_OEM_COMMA || wp==VK_OEM_MINUS || wp==VK_OEM_PERIOD || wp==VK_OEM_2 || wp==VK_OEM_3 || wp==VK_OEM_4 || wp==VK_OEM_5 || wp==VK_OEM_6 || wp==VK_OEM_7 || wp==VK_OEM_8 || #ifdef VK_OEM_AX wp==VK_OEM_AX || #endif wp==VK_OEM_102 || wp=='0' || wp=='1' || wp=='2' || wp=='3' || wp=='4' || wp=='5' || wp=='6' || wp=='7' || wp=='8' || wp=='9' || wp=='A' || wp=='B' || wp=='C' || wp=='D' || wp=='E' || wp=='F' || wp=='G' || wp=='H' || wp=='I' || wp=='J' || wp=='K' || wp=='L' || wp=='M' || wp=='N' || wp=='O' || wp=='P' || wp=='Q' || wp=='R' || wp=='S' || wp=='T' || wp=='U' || wp=='V' || wp=='W' || wp=='X' || wp=='Y' || wp=='Z' || wp==VK_ESCAPE || wp==VK_F1 || wp==VK_F2 || wp==VK_F3 || /* wp==VK_F4 || */ wp==VK_F5 || wp==VK_F6 || wp==VK_F7 || wp==VK_F8 || wp==VK_F9 || wp==VK_F10 || wp==VK_F11 || wp==VK_F12 || wp==VK_RETURN || wp==VK_NUMLOCK || wp==VK_NUMPAD0 || wp==VK_NUMPAD1 || wp==VK_NUMPAD2 || wp==VK_NUMPAD3 || wp==VK_NUMPAD4 || wp==VK_NUMPAD5 || wp==VK_NUMPAD6 || wp==VK_NUMPAD7 || wp==VK_NUMPAD8 || wp==VK_NUMPAD9 || wp==VK_DECIMAL || wp==VK_DIVIDE || wp==VK_MULTIPLY || wp==VK_SUBTRACT || wp==VK_ADD)) { int keyCode; keyCode=fsKeyMapper.VkToFsKey(wp); if(keyCode!=0 && nKeyBufUsed<NKEYBUF) { keyBuffer[nKeyBufUsed++]=keyCode; } return 0; } return DefWindowProc(hWnd,msg,wp,lp); case WM_SYSKEYUP: return 0; case WM_KEYDOWN: if(nKeyBufUsed<NKEYBUF) { int keyCode; keyCode=fsKeyMapper.VkToFsKey(wp); if(keyCode!=0) { keyBuffer[nKeyBufUsed++]=keyCode; } } break; case WM_CHAR: if(nCharBufUsed<NKEYBUF) { charBuffer[nCharBufUsed++]=wp; } break; case WM_ERASEBKGND: return 1; case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_RBUTTONDOWN: case WM_RBUTTONUP: case WM_MOUSEMOVE: if(nMosBufUsed<NKEYBUF) { int eventType; switch(msg) { default: eventType=FSMOUSEEVENT_NONE; break; case WM_LBUTTONDOWN: eventType=FSMOUSEEVENT_LBUTTONDOWN; break; case WM_LBUTTONUP: eventType=FSMOUSEEVENT_LBUTTONUP; break; case WM_MBUTTONDOWN: eventType=FSMOUSEEVENT_MBUTTONDOWN; break; case WM_MBUTTONUP: eventType=FSMOUSEEVENT_MBUTTONUP; break; case WM_RBUTTONDOWN: eventType=FSMOUSEEVENT_RBUTTONDOWN; break; case WM_RBUTTONUP: eventType=FSMOUSEEVENT_RBUTTONUP; break; case WM_MOUSEMOVE: eventType=FSMOUSEEVENT_MOVE; break; } int lb=((wp & MK_LBUTTON)!=0); int mb=((wp & MK_MBUTTON)!=0); int rb=((wp & MK_RBUTTON)!=0); unsigned int shift=((wp & MK_SHIFT)!=0); unsigned int ctrl=((wp & MK_CONTROL)!=0); int mx=LOWORD(lp); int my=HIWORD(lp); if(eventType==FSMOUSEEVENT_MOVE && 0<nMosBufUsed && mosBuffer[nMosBufUsed-1].eventType==FSMOUSEEVENT_MOVE && mosBuffer[nMosBufUsed-1].lb==lb && mosBuffer[nMosBufUsed-1].mb==mb && mosBuffer[nMosBufUsed-1].rb==rb && mosBuffer[nMosBufUsed-1].shift==shift && mosBuffer[nMosBufUsed-1].ctrl==ctrl) { mosBuffer[nMosBufUsed-1].mx=mx; mosBuffer[nMosBufUsed-1].my=my; break; } mosBuffer[nMosBufUsed].eventType=eventType; mosBuffer[nMosBufUsed].lb=lb; mosBuffer[nMosBufUsed].mb=mb; mosBuffer[nMosBufUsed].rb=rb; mosBuffer[nMosBufUsed].shift=shift; mosBuffer[nMosBufUsed].ctrl=ctrl; mosBuffer[nMosBufUsed].mx=mx; mosBuffer[nMosBufUsed].my=my; nMosBufUsed++; } break; default: return DefWindowProc(hWnd,msg,wp,lp); } return 1; }
///////////////////////////////////////////////////////////////////////////// // HBITMAP MagicLoad( LPCTSTR ) // // @func This function accepts a LPCTSTR identifier to load a bitmap from // the current application. In order to munge the palette, the // LoadBitmap API can not be used. This function loads the resource // with the LoadResource API and locks the resource in memory. // A RT_BITMAP locked from the resource file is accessible as a DIB // which has palette information available. A copy of the locked // DIB is made in the application's stack space and then the palette // is searched for the "magic" colors: <nl> <nl> // // RGB(192,192,192): COLOR_BTNFACE <nl> // RGB( 0, 0, 0 ): COLOR_BTNTEXT <nl> // RGB(255,255,255): COLOR_BTNHIGHLIGHT <nl> // RGB(128,128,128): COLOR_BTNSHADOW <nl> // // These colors are then substituted in the DIB's palette, // a BITMAP object compatible with the system display which is // returned. // // Note that this function only works for bitmap resources // with a color depth of 4 or 8 bpp. // HBITMAP MagicLoad( LPCTSTR nID ) { BITMAPINFOHEADER * lpbih; // pointer to original bitmap HRSRC hrsrc; // handle returned from FindResource HGLOBAL hglobal; // handle returned from LoadResource BITMAPINFOHEADER * newlpbih; // pointer to the bitmap copy if (nID == NULL) return NULL; hrsrc = FindResource(AfxGetResourceHandle(), nID, RT_BITMAP); if (hrsrc == NULL) return NULL; hglobal = LoadResource(AfxGetResourceHandle(), hrsrc ); if (hglobal == NULL) return NULL; lpbih = (LPBITMAPINFOHEADER) LockResource( hglobal ); if (lpbih == NULL) { FreeResource(hglobal); return NULL; } int nPalSize(0); if (lpbih->biBitCount == 8) nPalSize = (lpbih->biClrUsed == 0) ? 256 : lpbih->biClrUsed; else if (lpbih->biBitCount == 4) nPalSize = (lpbih->biClrUsed == 0) ? 16 : lpbih->biClrUsed; // Calculate the original bitmap's width and height. // Note that width must be a multiple of 4 for memory // allocation purposes. int width = lpbih->biWidth; while (width % 4 != 0) width++; int height = lpbih->biHeight; // Calculate the memory needed for a temporary copy of the // bitmap resource for palette corrections int biSize = width * height + sizeof(BITMAPINFOHEADER) + sizeof(DWORD) * nPalSize; // Allocate the memory using GlocalAlloc(). This is a very // inelegant way to allocate memory for a temporary copy of the // bitmap resource, but the Accusoft function IMG_create_handle // requires global memory. This will likely be fixed in v 6.0 // of the Accusoft Libraries which will require adjustments // to this code. // newlpbih = (BITMAPINFOHEADER *) malloc( biSize ); memcpy( newlpbih, lpbih, biSize ); DWORD * pRGB = (DWORD *) ((BYTE *)newlpbih + sizeof(BITMAPINFOHEADER)); // Spin through the palette for the loaded bitmap resource and // make substitutions for "magic colors" for( int i = 0; i < nPalSize; i++ ) { switch (*(pRGB+i)) { case RGB(192,192,192): SetDwordRGB( pRGB+i, GetSysColor(COLOR_BTNFACE)); break; case RGB( 0, 0, 0 ): SetDwordRGB( pRGB+i, GetSysColor(COLOR_BTNTEXT)); break; case RGB(255,255,255): SetDwordRGB( pRGB+i, GetSysColor(COLOR_BTNHIGHLIGHT)); break; case RGB(128,128,128): SetDwordRGB( pRGB+i, GetSysColor(COLOR_BTNSHADOW)); break; case RGB(128, 0, 0): SetDwordRGB( pRGB+i, GetSysColor(COLOR_ACTIVECAPTION)); break; } } TpsAssert( newlpbih->biBitCount <= 8, "Bitmap more then 256 colors" ); BYTE *lpbits = (BYTE *) newlpbih + sizeof(BITMAPINFOHEADER) + nPalSize *sizeof(RGBQUAD); // Get a compatible DC to create an HBITMAP HWND hWnd = GetDesktopWindow(); HDC hdcDeskTop = GetDC(hWnd); HBITMAP hBitmap; HPALETTE hPalette = (HPALETTE) tbitGetScreenPalette(); HPALETTE hPalOld = ::SelectPalette( hdcDeskTop, hPalette, FALSE ); RealizePalette( hdcDeskTop ); // Create the HBITMAP hBitmap = CreateCompatibleBitmap( hdcDeskTop, newlpbih->biWidth, newlpbih->biHeight ); // Populate the HBITMAP with the bits from the "new" DIB SetDIBits( hdcDeskTop, hBitmap, 0, newlpbih->biHeight, lpbits, (BITMAPINFO *) newlpbih, DIB_RGB_COLORS ); // Clean up allocated resources SelectPalette( hdcDeskTop, hPalOld, FALSE ); ReleaseDC( hWnd, hdcDeskTop ); FreeResource( hglobal ); return hBitmap; }
/* * @implemented */ INT WINAPI SetDIBits( HDC hDC, HBITMAP hBitmap, UINT uStartScan, UINT cScanLines, CONST VOID *lpvBits, CONST BITMAPINFO *lpbmi, UINT fuColorUse) { HDC hDCc, SavehDC, nhDC; DWORD dwWidth, dwHeight; HGDIOBJ hOldBitmap; HPALETTE hPal = NULL; INT LinesCopied = 0; BOOL newDC = FALSE; if (!lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP)) return 0; if (lpbmi) { if (lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) { if (lpbmi->bmiHeader.biCompression == BI_JPEG || lpbmi->bmiHeader.biCompression == BI_PNG) { SetLastError(ERROR_INVALID_PARAMETER); return 0; } } } hDCc = NtGdiGetDCforBitmap(hBitmap); // hDC can be NULL, so, get it from the bitmap. SavehDC = hDCc; if (!hDCc) // No DC associated with bitmap, Clone or Create one. { nhDC = CreateCompatibleDC(hDC); if (!nhDC) return 0; newDC = TRUE; SavehDC = nhDC; } else if (!SaveDC(hDCc)) return 0; hOldBitmap = SelectObject(SavehDC, hBitmap); if (hOldBitmap) { if (hDC) hPal = SelectPalette(SavehDC, (HPALETTE) GetCurrentObject(hDC, OBJ_PAL), FALSE); if (lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER)) { PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi; dwWidth = pbci->bmciHeader.bcWidth; dwHeight = pbci->bmciHeader.bcHeight; } else { dwWidth = lpbmi->bmiHeader.biWidth; dwHeight = abs(lpbmi->bmiHeader.biHeight); } LinesCopied = SetDIBitsToDevice(SavehDC, 0, 0, dwWidth, dwHeight, 0, 0, uStartScan, cScanLines, (void *) lpvBits, (LPBITMAPINFO) lpbmi, fuColorUse); if (hDC) SelectPalette(SavehDC, hPal, FALSE); SelectObject(SavehDC, hOldBitmap); } if (newDC) DeleteDC(SavehDC); else RestoreDC(SavehDC, -1); return LinesCopied; }
void MDIORGB_UseNewPalette (MIOWinInfoPtr pmInfo) { SelectPalette ((HDC) pmInfo -> deviceContext, pmInfo -> palette, FALSE); SelectPalette ((HDC) pmInfo -> offscreenDeviceContext, pmInfo -> palette, FALSE); } // MDIORGB_UseNewPalette
static Image *ReadCLIPBOARDImage(const ImageInfo *image_info, ExceptionInfo *exception) { Image *image; MagickBooleanType status; register ssize_t x; register Quantum *q; ssize_t y; assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AcquireImage(image_info,exception); { HBITMAP bitmapH; HPALETTE hPal; OpenClipboard(NULL); bitmapH=(HBITMAP) GetClipboardData(CF_BITMAP); hPal=(HPALETTE) GetClipboardData(CF_PALETTE); CloseClipboard(); if ( bitmapH == NULL ) ThrowReaderException(CoderError,"NoBitmapOnClipboard"); { BITMAPINFO DIBinfo; BITMAP bitmap; HBITMAP hBitmap, hOldBitmap; HDC hDC, hMemDC; RGBQUAD *pBits, *ppBits; /* create an offscreen DC for the source */ hMemDC=CreateCompatibleDC(NULL); hOldBitmap=(HBITMAP) SelectObject(hMemDC,bitmapH); GetObject(bitmapH,sizeof(BITMAP),(LPSTR) &bitmap); if ((image->columns == 0) || (image->rows == 0)) { image->columns=bitmap.bmWidth; image->rows=bitmap.bmHeight; } status=SetImageExtent(image,image->columns,image->rows,exception); if (status == MagickFalse) return(DestroyImageList(image)); /* Initialize the bitmap header info. */ (void) ResetMagickMemory(&DIBinfo,0,sizeof(BITMAPINFO)); DIBinfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER); DIBinfo.bmiHeader.biWidth=(LONG) image->columns; DIBinfo.bmiHeader.biHeight=(-1)*(LONG) image->rows; DIBinfo.bmiHeader.biPlanes=1; DIBinfo.bmiHeader.biBitCount=32; DIBinfo.bmiHeader.biCompression=BI_RGB; hDC=GetDC(NULL); if (hDC == 0) ThrowReaderException(CoderError,"UnableToCreateADC"); hBitmap=CreateDIBSection(hDC,&DIBinfo,DIB_RGB_COLORS,(void **) &ppBits, NULL,0); ReleaseDC(NULL,hDC); if (hBitmap == 0) ThrowReaderException(CoderError,"UnableToCreateBitmap"); /* create an offscreen DC */ hDC=CreateCompatibleDC(NULL); if (hDC == 0) { DeleteObject(hBitmap); ThrowReaderException(CoderError,"UnableToCreateADC"); } hOldBitmap=(HBITMAP) SelectObject(hDC,hBitmap); if (hOldBitmap == 0) { DeleteDC(hDC); DeleteObject(hBitmap); ThrowReaderException(CoderError,"UnableToCreateBitmap"); } if (hPal != NULL) { /* Kenichi Masuko says this needed */ SelectPalette(hDC, hPal, FALSE); RealizePalette(hDC); } /* bitblt from the memory to the DIB-based one */ BitBlt(hDC,0,0,(int) image->columns,(int) image->rows,hMemDC,0,0,SRCCOPY); /* finally copy the pixels! */ pBits=ppBits; for (y=0; y < (ssize_t) image->rows; y++) { q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); if (q == (Quantum *) NULL) break; for (x=0; x < (ssize_t) image->columns; x++) { SetPixelRed(image,ScaleCharToQuantum(pBits->rgbRed),q); SetPixelGreen(image,ScaleCharToQuantum(pBits->rgbGreen),q); SetPixelBlue(image,ScaleCharToQuantum(pBits->rgbBlue),q); SetPixelAlpha(image,OpaqueAlpha,q); pBits++; q+=GetPixelChannels(image); } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } DeleteDC(hDC); DeleteObject(hBitmap); } } (void) CloseBlob(image); return(GetFirstImageInList(image)); }
bool CxImageWMF::Decode(CxFile *hFile, long nForceWidth, long nForceHeight) { if (hFile == NULL) return false; HENHMETAFILE hMeta; HDC hDC; int cx,cy; //save the current position of the file long pos = hFile->Tell(); // Read the Metafile and convert to an Enhanced Metafile METAFILEHEADER mfh; hMeta = ConvertWmfFiletoEmf(hFile, &mfh); if (hMeta) { // ok, it's a WMF ///////////////////////////////////////////////////////////////////// // We use the original WMF size information, because conversion to // EMF adjusts the Metafile to Full Screen or does not set rclBounds at all // ENHMETAHEADER emh; // UINT uRet; // uRet = GetEnhMetaFileHeader(hMeta, // handle of enhanced metafile // sizeof(ENHMETAHEADER), // size of buffer, in bytes // &emh); // address of buffer to receive data // if (!uRet){ // DeleteEnhMetaFile(hMeta); // return false; // } // // calculate size // cx = emh.rclBounds.right - emh.rclBounds.left; // cy = emh.rclBounds.bottom - emh.rclBounds.top; ///////////////////////////////////////////////////////////////////// // calculate size // scale the metafile (pixels/inch of metafile => pixels/inch of display) // mfh.inch already checked to be <> 0 hDC = ::GetDC(0); int cx1 = ::GetDeviceCaps(hDC, LOGPIXELSX); int cy1 = ::GetDeviceCaps(hDC, LOGPIXELSY); ::ReleaseDC(0, hDC); cx = (mfh.bbox.right - mfh.bbox.left) * cx1 / mfh.inch; cy = (mfh.bbox.bottom - mfh.bbox.top) * cy1 / mfh.inch; } else { // maybe it's an EMF... hFile->Seek(pos,SEEK_SET); ENHMETAHEADER emh; hMeta = ConvertEmfFiletoEmf(hFile, &emh); if (!hMeta){ strcpy(info.szLastError,"corrupted WMF"); return false; // definitively give up } // ok, it's an EMF // calculate size cx = emh.rclBounds.right - emh.rclBounds.left; cy = emh.rclBounds.bottom - emh.rclBounds.top; } if (info.nEscape) { // Check if cancelled DeleteEnhMetaFile(hMeta); strcpy(info.szLastError,"Cancelled"); return false; } if (!cx || !cy) { DeleteEnhMetaFile(hMeta); strcpy(info.szLastError,"empty WMF"); return false; } if (nForceWidth) cx=nForceWidth; if (nForceHeight) cy=nForceHeight; ShrinkMetafile(cx, cy); // !! Otherwise Bitmap may have bombastic size HDC hDC0 = GetDC(0); // DC of screen HBITMAP hBitmap = CreateCompatibleBitmap(hDC0, cx, cy); // has # colors of display hDC = CreateCompatibleDC(hDC0); // memory dc compatible with screen ReleaseDC(0, hDC0); // don't need anymore. get rid of it. if (hDC){ if (hBitmap){ RECT rc = {0,0,cx,cy}; int bpp = ::GetDeviceCaps(hDC, BITSPIXEL); HBITMAP hBitmapOld = (HBITMAP)SelectObject(hDC, hBitmap); // clear out the entire bitmap with windows background // because the MetaFile may not contain background information DWORD dwBack = XMF_COLOR_BACK; #if XMF_SUPPORT_TRANSPARENCY if (bpp == 24) dwBack = XMF_COLOR_TRANSPARENT; #endif DWORD OldColor = SetBkColor(hDC, dwBack); ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL); SetBkColor(hDC, OldColor); //retrieves optional palette entries from the specified enhanced metafile PLOGPALETTE plogPal; PBYTE pjTmp; HPALETTE hPal; int iEntries = GetEnhMetaFilePaletteEntries(hMeta, 0, NULL); if (iEntries) { if ((plogPal = (PLOGPALETTE)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(DWORD) + sizeof(PALETTEENTRY)*iEntries )) == NULL) { DeleteObject(hBitmap); DeleteDC(hDC); DeleteEnhMetaFile(hMeta); strcpy(info.szLastError,"Cancelled"); return false; } plogPal->palVersion = 0x300; plogPal->palNumEntries = (WORD) iEntries; pjTmp = (PBYTE) plogPal; pjTmp += 4; GetEnhMetaFilePaletteEntries(hMeta, iEntries, (PPALETTEENTRY)pjTmp); hPal = CreatePalette(plogPal); GlobalFree(plogPal); SelectPalette(hDC, hPal, FALSE); RealizePalette(hDC); } // Play the Metafile into Memory DC BOOL bRet = PlayEnhMetaFile(hDC, // handle to a device context hMeta, // handle to an enhanced metafile &rc); // pointer to bounding rectangle SelectObject(hDC, hBitmapOld); DeleteEnhMetaFile(hMeta); // we are done with this one if (info.nEscape) { // Check if cancelled DeleteObject(hBitmap); DeleteDC(hDC); strcpy(info.szLastError,"Cancelled"); return false; } // the Bitmap now has the image. // Create our DIB and convert the DDB into DIB if (!Create(cx, cy, bpp, CXIMAGE_FORMAT_WMF)) { DeleteObject(hBitmap); DeleteDC(hDC); return false; } #if XMF_SUPPORT_TRANSPARENCY if (bpp == 24) { RGBQUAD rgbTrans = { XMF_RGBQUAD_TRANSPARENT }; SetTransColor(rgbTrans); } #endif // We're finally ready to get the DIB. Call the driver and let // it party on our bitmap. It will fill in the color table, // and bitmap bits of our global memory block. bRet = GetDIBits(hDC, hBitmap, 0, (UINT)cy, GetBits(), (LPBITMAPINFO)pDib, DIB_RGB_COLORS); DeleteObject(hBitmap); DeleteDC(hDC); return (bRet!=0); } else { DeleteDC(hDC); } } else { if (hBitmap) DeleteObject(hBitmap); } DeleteEnhMetaFile(hMeta); return false; }
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow) { HWND hWnd; MSG msg; WNDCLASS wndClass; wndClass.style=CS_HREDRAW|CS_VREDRAW; wndClass.lpfnWndProc=WndProc; wndClass.cbClsExtra=0; wndClass.cbWndExtra=0; wndClass.hInstance=hInstance; wndClass.hIcon=LoadIcon(NULL,IDI_APPLICATION); wndClass.hCursor=LoadCursor(NULL,IDC_ARROW); wndClass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH); wndClass.lpszMenuName=NULL; wndClass.lpszClassName=szName; if(!RegisterClass(&wndClass)) { MessageBox(NULL,TEXT("Can not create!"),szName,MB_ICONERROR); return 0; } hWnd=CreateWindow(szName,TEXT("Soft Render"),WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,CW_USEDEFAULT,SCREEN_WIDTH,SCREEN_HEIGHT, NULL,NULL,hInstance,NULL); hdc=GetDC(hWnd); checkDisplayMode(hdc); createPalette(hdc); dibDC=CreateCompatibleDC(hdc); swidth=SCREEN_WIDTH; sheight=SCREEN_HEIGHT; init(); ShowWindow(hWnd,iCmdShow); UpdateWindow(hWnd); willExit=false; memset(&msg,0,sizeof(MSG)); if(hPalette) { SelectPalette(hdc,hPalette,FALSE); RealizePalette(hdc); } while(!willExit) { if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { if(msg.message==WM_QUIT) willExit=true; else { TranslateMessage(&msg); DispatchMessage(&msg); } } else { runWindow(); draw(); BitBlt(hdc,0,0,swidth,sheight,dibDC,0,0,SRCCOPY); } } releasePalette(); releaseDIB(dibDC); DeleteDC(dibDC); ReleaseDC(hWnd,hdc); killWindow(hWnd,hInstance,wndClass); return msg.wParam; }
void SplashPaint(Splash * splash, HDC hdc) { unsigned numColors = splash->screenFormat.colorMap ? splash->screenFormat.numColors : 0; BITMAPV4HEADER *pBmi; HPALETTE hOldPal = NULL; if (!splash->frames) return; if (splash->currentFrame < 0 || splash->currentFrame >= splash->frameCount) return; pBmi = (BITMAPV4HEADER *) SAFE_SIZE_STRUCT_ALLOC(alloca, sizeof(BITMAPV4HEADER), sizeof(RGBQUAD), numColors); if (!pBmi) { return; } memset(pBmi, 0, sizeof(BITMAPV4HEADER)); if (splash->screenFormat.colorMap) memcpy(((BYTE *) pBmi) + sizeof(BITMAPV4HEADER), splash->screenFormat.colorMap, sizeof(RGBQUAD) * numColors); pBmi->bV4Size = sizeof(BITMAPV4HEADER); pBmi->bV4Width = splash->width; pBmi->bV4Height = -splash->height; pBmi->bV4Planes = 1; pBmi->bV4BitCount = (WORD) (splash->screenFormat.depthBytes * 8); /* we're ALWAYS using BGRA in screenFormat */ pBmi->bV4V4Compression = BI_RGB; pBmi->bV4ClrUsed = numColors; pBmi->bV4ClrImportant = numColors; pBmi->bV4AlphaMask = splash->screenFormat.mask[3]; pBmi->bV4RedMask = splash->screenFormat.mask[2]; pBmi->bV4GreenMask = splash->screenFormat.mask[1]; pBmi->bV4BlueMask = splash->screenFormat.mask[0]; /* creating the palette in SplashInitPlatform does not work, so I'm creating it here on demand */ if (!splash->hPalette) { unsigned i; LOGPALETTE *pLogPal = (LOGPALETTE *) SAFE_SIZE_STRUCT_ALLOC(malloc, sizeof(LOGPALETTE), sizeof(PALETTEENTRY), numColors); if (!pLogPal) { return; } pLogPal->palVersion = 0x300; pLogPal->palNumEntries = (WORD) numColors; for (i = 0; i < numColors; i++) { pLogPal->palPalEntry[i].peRed = (BYTE) QUAD_RED(splash->colorMap[i]); pLogPal->palPalEntry[i].peGreen = (BYTE) QUAD_GREEN(splash->colorMap[i]); pLogPal->palPalEntry[i].peBlue = (BYTE) QUAD_BLUE(splash->colorMap[i]); pLogPal->palPalEntry[i].peFlags = PC_NOCOLLAPSE; } splash->hPalette = CreatePalette(pLogPal); free(pLogPal); } if (splash->hPalette) { hOldPal = SelectPalette(hdc, splash->hPalette, FALSE); RealizePalette(hdc); } StretchDIBits(hdc, 0, 0, splash->width, splash->height, 0, 0, splash->width, splash->height, splash->screenData, (BITMAPINFO *) pBmi, DIB_RGB_COLORS, SRCCOPY); if (hOldPal) SelectPalette(hdc, hOldPal, FALSE); }
HDIB BitmapToDIB(HBITMAP hBitmap, HPALETTE hPal) { BITMAP bm; // bitmap structure BITMAPINFOHEADER bi; // bitmap header LPBITMAPINFOHEADER 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; // fill in BITMAP structure, return NULL if it didn't work if (!GetObject(hBitmap, sizeof(bm), (LPSTR)&bm)) return NULL; // if no palette is specified, use default palette if (hPal == NULL) hPal = (HPALETTE)GetStockObject(DEFAULT_PALETTE); // calculate bits per pixel biBits = bm.bmPlanes * bm.bmBitsPixel; // make sure bits per pixel is valid if (biBits <= 1) biBits = 1; else if (biBits <= 4) biBits = 4; else if (biBits <= 8) biBits = 8; else if (biBits <= 24) biBits = 24; else biBits = 32; // initialize BITMAPINFOHEADER bi.biSize = sizeof(BITMAPINFOHEADER); bi.biWidth = bm.bmWidth; bi.biHeight = bm.bmHeight; bi.biPlanes = 1; bi.biBitCount = biBits; bi.biCompression = BI_RGB; 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 = (LPBITMAPINFOHEADER)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, (UINT)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 = (LPBITMAPINFOHEADER)GlobalLock(hDIB); // call GetDIBits with a NON-NULL lpBits param, and actualy get the // bits this time if (GetDIBits(hDC, hBitmap, 0, (UINT)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; }
void RestorePalette(HDC hdc, HPALETTE hOldPal) { SelectPalette(hdc, hOldPal, TRUE); }
/********************************************************************** * DrawDibDraw [MSVFW32.@] */ BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc, INT xDst, INT yDst, INT dxDst, INT dyDst, LPBITMAPINFOHEADER lpbi, LPVOID lpBits, INT xSrc, INT ySrc, INT dxSrc, INT dySrc, UINT wFlags) { WINE_HDD *whdd; BOOL ret; int reopen = 0; TRACE("(%p,%p,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08x)\n", hdd, hdc, xDst, yDst, dxDst, dyDst, lpbi, lpBits, xSrc, ySrc, dxSrc, dySrc, wFlags); whdd = MSVIDEO_GetHddPtr(hdd); if (!whdd) return FALSE; TRACE("whdd=%p\n", whdd); if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME | DDF_UPDATE | DDF_DONTDRAW | DDF_BACKGROUNDPAL)) FIXME("wFlags == 0x%08x not handled\n", wFlags); if (!lpBits) { /* Undocumented? */ lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(num_colours(lpbi)*sizeof(RGBQUAD)); } #define CHANGED(x) (whdd->x != x) /* Check if anything changed from the parameters passed and our struct. * If anything changed we need to run DrawDibBegin again to ensure we * can support the changes. */ if (!whdd->begun) reopen = 1; else if (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) reopen = 2; else if (!(wFlags & DDF_SAME_DRAW)) { if (CHANGED(lpbi) && memcmp(lpbi, whdd->lpbi, sizeof(*lpbi))) reopen = 3; else if (CHANGED(dxSrc)) reopen = 4; else if (CHANGED(dySrc)) reopen = 5; else if (CHANGED(dxDst)) reopen = 6; else if (CHANGED(dyDst)) reopen = 7; } if (reopen) { TRACE("Something changed (reason %d)!\n", reopen); ret = DrawDibBegin(hdd, hdc, dxDst, dyDst, lpbi, dxSrc, dySrc, 0); if (!ret) return ret; } #undef CHANGED /* If source dimensions are not specified derive them from bitmap header */ if (dxSrc == -1 && dySrc == -1) { dxSrc = lpbi->biWidth; dySrc = lpbi->biHeight; } /* If destination dimensions are not specified derive them from source */ if (dxDst == -1 && dyDst == -1) { dxDst = dxSrc; dyDst = dySrc; } if (!(wFlags & DDF_UPDATE)) { if (lpbi->biCompression) { DWORD flags = 0; TRACE("Compression == 0x%08x\n", lpbi->biCompression); if (wFlags & DDF_NOTKEYFRAME) flags |= ICDECOMPRESS_NOTKEYFRAME; ICDecompress(whdd->hic, flags, lpbi, lpBits, whdd->lpbiOut, whdd->lpvbits); } else { /* BI_RGB: lpbi->biSizeImage isn't reliable */ DWORD biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight; memcpy(whdd->lpvbits, lpBits, biSizeImage); } } if (!(wFlags & DDF_DONTDRAW) && whdd->hpal) { if ((wFlags & DDF_BACKGROUNDPAL) && ! (wFlags & DDF_SAME_HDC)) SelectPalette(hdc, whdd->hpal, TRUE); else SelectPalette(hdc, whdd->hpal, FALSE); } ret = StretchBlt(whdd->hdc, xDst, yDst, dxDst, dyDst, whdd->hMemDC, xSrc, ySrc, dxSrc, dySrc, SRCCOPY); TRACE("Painting %dx%d at %d,%d from %dx%d at %d,%d -> %d\n", dxDst, dyDst, xDst, yDst, dxSrc, dySrc, xSrc, ySrc, ret); return ret; }
static void TreeCtrlOnPaint(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { PAINTSTRUCT ps; HDC hDC; RECT rcClip, rcClient; HDC memDC; HBITMAP bitmap; HBITMAP hOldBitmap; HBITMAP hBackground = GetBackgroundBitmap(); MYBITMAPINFO *bmDesc = GetBackgroundInfo(); hDC = BeginPaint(hWnd, &ps); GetClipBox(hDC, &rcClip); GetClientRect(hWnd, &rcClient); // Create a compatible memory DC memDC = CreateCompatibleDC(hDC); // Select a compatible bitmap into the memory DC bitmap = CreateCompatibleBitmap(hDC, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top); hOldBitmap = SelectObject(memDC, bitmap); // First let the control do its default drawing. CallWindowProc(g_lpTreeWndProc, hWnd, uMsg, (WPARAM)memDC, 0); // Draw bitmap in the background { HPALETTE hPAL; HDC maskDC; HBITMAP maskBitmap; HDC tempDC; HDC imageDC; HBITMAP bmpImage; HBITMAP hOldBmpImage; HBITMAP hOldMaskBitmap; HBITMAP hOldHBitmap; int i, j; RECT rcRoot; // Now create a mask maskDC = CreateCompatibleDC(hDC); // Create monochrome bitmap for the mask maskBitmap = CreateBitmap(rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, 1, 1, NULL); hOldMaskBitmap = SelectObject(maskDC, maskBitmap); SetBkColor(memDC, GetSysColor(COLOR_WINDOW)); // Create the mask from the memory DC BitBlt(maskDC, 0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, memDC, rcClient.left, rcClient.top, SRCCOPY); tempDC = CreateCompatibleDC(hDC); hOldHBitmap = SelectObject(tempDC, hBackground); imageDC = CreateCompatibleDC(hDC); bmpImage = CreateCompatibleBitmap(hDC, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top); hOldBmpImage = SelectObject(imageDC, bmpImage); hPAL = GetBackgroundPalette(); if (hPAL == NULL) hPAL = CreateHalftonePalette(hDC); if (GetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE && hPAL != NULL) { SelectPalette(hDC, hPAL, FALSE); RealizePalette(hDC); SelectPalette(imageDC, hPAL, FALSE); } // Get x and y offset TreeView_GetItemRect(hWnd, TreeView_GetRoot(hWnd), &rcRoot, FALSE); rcRoot.left = -GetScrollPos(hWnd, SB_HORZ); // Draw bitmap in tiled manner to imageDC for (i = rcRoot.left; i < rcClient.right; i += bmDesc->bmWidth) for (j = rcRoot.top; j < rcClient.bottom; j += bmDesc->bmHeight) BitBlt(imageDC, i, j, bmDesc->bmWidth, bmDesc->bmHeight, tempDC, 0, 0, SRCCOPY); // Set the background in memDC to black. Using SRCPAINT with black and any other // color results in the other color, thus making black the transparent color SetBkColor(memDC, RGB(0,0,0)); SetTextColor(memDC, RGB(255,255,255)); BitBlt(memDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, maskDC, rcClip.left, rcClip.top, SRCAND); // Set the foreground to black. See comment above. SetBkColor(imageDC, RGB(255,255,255)); SetTextColor(imageDC, RGB(0,0,0)); BitBlt(imageDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, maskDC, rcClip.left, rcClip.top, SRCAND); // Combine the foreground with the background BitBlt(imageDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, memDC, rcClip.left, rcClip.top, SRCPAINT); // Draw the final image to the screen BitBlt(hDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, imageDC, rcClip.left, rcClip.top, SRCCOPY); SelectObject(maskDC, hOldMaskBitmap); SelectObject(tempDC, hOldHBitmap); SelectObject(imageDC, hOldBmpImage); DeleteDC(maskDC); DeleteDC(imageDC); DeleteDC(tempDC); DeleteObject(bmpImage); DeleteObject(maskBitmap); if (GetBackgroundPalette() == NULL) { DeleteObject(hPAL); hPAL = 0; } } SelectObject(memDC, hOldBitmap); DeleteObject(bitmap); DeleteDC(memDC); EndPaint(hWnd, &ps); ReleaseDC(hWnd, hDC); }
bool CGetScreenInfo::_BitmapToData(HBITMAP hBitmap, WORD nwBitCount) { if(m_bIsLock) return false; HDC hDC; //当前分辨率下每象素所占字节数 int iBits; //位图中每象素所占字节数 WORD wBitCount; //定义调色板大小, 位图中像素字节大小 ,位图文件大小 , 写入文件字节数 DWORD dwPaletteSize=0, dwBmBitsSize=0, dwDIBSize=0, dwWritten=0; //位图属性结构 BITMAP Bitmap; //位图文件头结构 BITMAPFILEHEADER bmfHdr; //位图信息头结构 BITMAPINFOHEADER bi; //指向位图信息头结构 LPBITMAPINFOHEADER lpbi; //定义文件,分配内存句柄,调色板句柄 HANDLE /*hDib,*/ hPal,hOldPal=NULL; //计算位图文件每个像素所占字节数 // hDC = CreateDC(_T("DISPLAY"), NULL, NULL, NULL); hDC = GetDC(GetDesktopWindow()); iBits = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES); // DeleteDC(hDC); ReleaseDC(GetDesktopWindow(), hDC); if (iBits <= 1) wBitCount = 1; else if (iBits <= 4) wBitCount = 4; else if (iBits <= 8) wBitCount = 8; else wBitCount = 24; wBitCount = nwBitCount; if (wBitCount <= 8) dwPaletteSize = (1 << wBitCount) * sizeof(RGBQUAD); 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.bmWidthBytes*Bitmap.bmHeight; dwBmBitsSize= ((Bitmap.bmWidth * wBitCount + 31) / 32) * 4 * Bitmap.bmHeight; //为位图内容分配内存 dwDIBSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwPaletteSize + dwBmBitsSize; if(m_ScreenData.dwBufLen < dwDIBSize) { if(m_ScreenData.pScreenData != NULL) delete m_ScreenData.pScreenData; m_ScreenData.pScreenData = new BYTE[dwDIBSize]; if( !m_ScreenData.pScreenData ) { m_ScreenData.dwBufLen = 0; return false; } m_ScreenData.dwBufLen = dwDIBSize ; } lpbi = (LPBITMAPINFOHEADER)(m_ScreenData.pScreenData + sizeof(BITMAPFILEHEADER)); *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); } // 设置位图文件头 bmfHdr.bfType = 0x4D42; // "BM" bmfHdr.bfSize = dwDIBSize; bmfHdr.bfReserved1 = 0; bmfHdr.bfReserved2 = 0; bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwPaletteSize; memcpy(m_ScreenData.pScreenData, &bmfHdr, sizeof(BITMAPFILEHEADER)); return true; }
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 ); }