static BOOL ListViewOnErase(HWND hWnd, HDC hDC)
{
RECT rcClient;
HRGN rgnBitmap;
HPALETTE hPAL;
int i = 0, j = 0;
HDC htempDC;
POINT ptOrigin;
POINT pt = {0,0};
HBITMAP hOldBitmap;
MYBITMAPINFO *pbmDesc = GetBackgroundInfo();
HBITMAP hBackground = GetBackgroundBitmap();
HPALETTE hPALbg = GetBackgroundPalette();
// this does not draw the background properly in report view
GetClientRect(hWnd, &rcClient);
htempDC = CreateCompatibleDC(hDC);
hOldBitmap = (HBITMAP)SelectObject(htempDC, hBackground);
rgnBitmap = CreateRectRgnIndirect(&rcClient);
SelectClipRgn(hDC, rgnBitmap);
DeleteBitmap(rgnBitmap);
hPAL = (!hPALbg) ? CreateHalftonePalette(hDC) : hPALbg;
if (GetDeviceCaps(htempDC, RASTERCAPS) & RC_PALETTE && hPAL != NULL)
{
SelectPalette(htempDC, hPAL, FALSE);
RealizePalette(htempDC);
}
// Get x and y offset
MapWindowPoints(hWnd, GetTreeView(), &pt, 1);
GetDCOrgEx(hDC, &ptOrigin);
ptOrigin.x -= pt.x;
ptOrigin.y -= pt.y;
ptOrigin.x = -GetScrollPos(hWnd, SB_HORZ);
ptOrigin.y = -GetScrollPos(hWnd, SB_VERT);
if (pbmDesc->bmWidth && pbmDesc->bmHeight)
{
for (i = ptOrigin.x; i < rcClient.right; i += pbmDesc->bmWidth)
for (j = ptOrigin.y; j < rcClient.bottom; j += pbmDesc->bmHeight)
BitBlt(hDC, i, j, pbmDesc->bmWidth, pbmDesc->bmHeight, htempDC, 0, 0, SRCCOPY);
}
SelectObject(htempDC, hOldBitmap);
DeleteDC(htempDC);
if (!pbmDesc->bmColors)
{
DeletePalette(hPAL);
hPAL = 0;
}
return TRUE;
}
/***********************************************************************
* DrawDibRealize [MSVFW32.@]
*/
UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground)
{
WINE_HDD *whdd;
UINT ret = 0;
FIXME("(%p, %p, %d), stub\n", hdd, hdc, fBackground);
whdd = MSVIDEO_GetHddPtr(hdd);
if (!whdd) return FALSE;
if (!whdd->begun)
{
ret = 0;
goto out;
}
if (!whdd->hpal)
whdd->hpal = CreateHalftonePalette(hdc);
SelectPalette(hdc, whdd->hpal, fBackground);
ret = RealizePalette(hdc);
out:
TRACE("=> %u\n", ret);
return ret;
}
// The following code was taken from http://support.microsoft.com/kb/158898
BOOL CImage::LoadBitmapFromBMPFile(LPTSTR szFileName)
{
CAutoLock lock(&m_csLock);
BITMAP bm;
// Use LoadImage() to get the image loaded into a DIBSection
m_hBitmap = (HBITMAP)LoadImage( NULL, szFileName, IMAGE_BITMAP, 0, 0,
LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE );
if( m_hBitmap == NULL )
return FALSE;
// Get the color depth of the DIBSection
GetObject(m_hBitmap, sizeof(BITMAP), &bm );
// If the DIBSection is 256 color or less, it has a color table
if( ( bm.bmBitsPixel * bm.bmPlanes ) <= 8 )
{
HDC hMemDC = NULL;
HBITMAP hOldBitmap = NULL;
RGBQUAD rgb[256];
LPLOGPALETTE pLogPal = NULL;
WORD i = 0;
// Create a memory DC and select the DIBSection into it
hMemDC = CreateCompatibleDC( NULL );
hOldBitmap = (HBITMAP)SelectObject( hMemDC, m_hBitmap );
// Get the DIBSection's color table
GetDIBColorTable( hMemDC, 0, 256, rgb );
// Create a palette from the color tabl
pLogPal = (LOGPALETTE *)malloc( sizeof(LOGPALETTE) + (256*sizeof(PALETTEENTRY)) );
pLogPal->palVersion = 0x300;
pLogPal->palNumEntries = 256;
for(i=0; i<256; i++)
{
pLogPal->palPalEntry[i].peRed = rgb[i].rgbRed;
pLogPal->palPalEntry[i].peGreen = rgb[i].rgbGreen;
pLogPal->palPalEntry[i].peBlue = rgb[i].rgbBlue;
pLogPal->palPalEntry[i].peFlags = 0;
}
m_hPalette = CreatePalette( pLogPal );
// Clean up
free( pLogPal );
SelectObject( hMemDC, hOldBitmap );
DeleteDC( hMemDC );
}
else // It has no color table, so use a halftone palette
{
HDC hRefDC = NULL;
hRefDC = GetDC( NULL );
m_hPalette = CreateHalftonePalette( hRefDC );
ReleaseDC( NULL, hRefDC );
}
return TRUE;
}
/*! Create a DIB from current bitmap
// \param HDC hdcSRC :
*/
BOOL CAxJpgCard::CreateDib(HDC hdcSRC)
{
BITMAP bm;
UINT iColorDataType; // color data type (palette or RGB values)
::GetObject( m_hCurrentBitmap, sizeof(bm), (LPVOID)&bm );
HDC hdcComp = CreateCompatibleDC(hdcSRC);
iColorDataType = DIB_RGB_COLORS;
// create a DIB
DIBINFO DIBinfo;
BITMAPINFOHEADER& bih = 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.bmHeight, bm.bmBitsPixel) * bm.bmWidth;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
if (!::GetDIBits(hdcComp, m_hCurrentBitmap, 0, bm.bmHeight, NULL, DIBinfo, iColorDataType))
{
ATLTRACE("Unable to GetDIBits\n");
}
BYTE* pvBitsSRC = (BYTE*)bm.bmBits;
BYTE* pvBitsDST = NULL;
// create dib for rotated image with bitmap set to all null
HBITMAP hCurrentDib = ::CreateDIBSection(hdcComp , (const BITMAPINFO*) DIBinfo, DIB_RGB_COLORS, (VOID**)&pvBitsDST, NULL, 0);
ATLASSERT( hCurrentDib != NULL);
DWORD dwImageSize = DIBinfo.bmiHeader.biSizeImage;
if (dwImageSize == 0)
{
int nBytesPerLine = BytesPerLine(DIBinfo.bmiHeader.biWidth,
DIBinfo.bmiHeader.biBitCount);
dwImageSize = nBytesPerLine * DIBinfo.bmiHeader.biHeight;
}
CreateHalftonePalette(DIBinfo, 256);
m_hCurrentBitmap = hCurrentDib;
//memcpy(pvBitsDST, pvBitsSRC, dwImageSize);
return TRUE;
}
/***********************************************************************
* WinGCreateHalftonePalette (WING32.@)
*/
HPALETTE WINAPI WinGCreateHalftonePalette( void )
{
HDC hdc;
HPALETTE hpal;
hdc = GetDC( 0 );
hpal = CreateHalftonePalette( hdc );
ReleaseDC( 0, hdc );
return hpal;
}
static void test_halftone_palette(void)
{
HDC hdc;
HPALETTE pal;
PALETTEENTRY entries[256];
PALETTEENTRY defpal[20];
int i, count;
hdc = GetDC(0);
count = GetPaletteEntries( GetStockObject(DEFAULT_PALETTE), 0, 20, defpal );
ok( count == 20, "wrong size %u\n", count );
pal = CreateHalftonePalette( hdc );
count = GetPaletteEntries( pal, 0, 256, entries );
ok( count == 256 || broken(count <= 20), /* nt 4 */
"wrong size %u\n", count );
/* first and last 10 match the default palette */
if (count >= 20)
{
for (i = 0; i < 10; i++)
{
ok( entries[i].peRed == defpal[i].peRed &&
entries[i].peGreen == defpal[i].peGreen &&
entries[i].peBlue == defpal[i].peBlue &&
!entries[i].peFlags,
"%u: wrong color %02x,%02x,%02x,%02x instead of %02x,%02x,%02x\n", i,
entries[i].peRed, entries[i].peGreen, entries[i].peBlue, entries[i].peFlags,
defpal[i].peRed, defpal[i].peGreen, defpal[i].peBlue );
}
for (i = count - 10; i < count; i++)
{
int idx = i - count + 20;
ok( entries[i].peRed == defpal[idx].peRed &&
entries[i].peGreen == defpal[idx].peGreen &&
entries[i].peBlue == defpal[idx].peBlue &&
!entries[i].peFlags,
"%u: wrong color %02x,%02x,%02x,%02x instead of %02x,%02x,%02x\n", i,
entries[i].peRed, entries[i].peGreen, entries[i].peBlue, entries[i].peFlags,
defpal[idx].peRed, defpal[idx].peGreen, defpal[idx].peBlue );
}
}
DeleteObject( pal );
ReleaseDC( 0, hdc );
}
void Demo_Bitmap(HDC hDC, const RECT * rcPaint, int width, int height, HINSTANCE hInst)
{
HDC hMemDC = CreateCompatibleDC(NULL);
// load difference BITMAP as resource
HPALETTE hPal = CreateHalftonePalette(hDC);
HPALETTE hOld = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
SetStretchBltMode(hDC, STRETCH_DELETESCANS);
for (int i=0; i<6; i++)
{
int x = 100 + (i%3) * 3200;
int y = 100 + (i/3) * 3200;
HBITMAP hBmp = LoadBitmap(hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));
KGDIObject bmp(hMemDC, hBmp);
if ( hBmp==NULL ) break;
BITMAP info;
GetObject(hBmp, sizeof(BITMAP), & info);
StretchBlt(hDC, x, y,
info.bmWidth * ONEINCH / 120, info.bmHeight * ONEINCH / 120,
hMemDC, 0, 0, info.bmWidth, info.bmHeight, SRCCOPY);
}
SelectPalette(hDC, hOld, FALSE);
RealizePalette(hDC);
DeleteObject(hPal);
DeleteObject(hMemDC);
}
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 AllocatePNG(png_info *p, HGLOBAL *phDIB, HPALETTE *pPal)
{
int dibSize;
HGLOBAL hDIB;
BITMAPINFOHEADER bi;
LPBITMAPINFOHEADER lpbi;
LPBITMAPINFO bmInfo;
LPVOID lpDIBBits = 0;
int lineWidth = 0;
int nColors = 0;
RGBQUAD* pRgb;
copy_size = 0;
pixel_ptr = 0;
row = p->height - 1;
lineWidth = p->width;
if (p->color_type != 2 && p->num_palette <= 256)
nColors = p->num_palette;
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = p->width;
bi.biHeight = p->height;
bi.biPlanes = 1;
bi.biBitCount = (p->color_type == 3) ? 8 : 24; /* bit_depth; */
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = nColors;
bi.biClrImportant = nColors;
effWidth = (long)(((long)lineWidth*bi.biBitCount + 31) / 32) * 4;
dibSize = (effWidth * bi.biHeight);
hDIB = GlobalAlloc(GMEM_FIXED, bi.biSize + (nColors * sizeof(RGBQUAD)) + dibSize);
if (!hDIB)
return FALSE;
lpbi = (LPBITMAPINFOHEADER)hDIB;
memcpy(lpbi, &bi, sizeof(BITMAPINFOHEADER));
pRgb = (RGBQUAD*)((LPSTR)lpbi + bi.biSize);
lpDIBBits = (LPVOID)((LPSTR)lpbi + bi.biSize + (nColors * sizeof(RGBQUAD)));
if (nColors)
{
int i;
/* Convert a PNG palette (3 byte RGBTRIPLEs) to a new color table (4 byte RGBQUADs) */
for (i = 0; i < nColors; i++)
{
RGBQUAD rgb;
rgb.rgbRed = p->palette[i * 3 + 0];
rgb.rgbGreen = p->palette[i * 3 + 1];
rgb.rgbBlue = p->palette[i * 3 + 2];
rgb.rgbReserved = (BYTE)0;
pRgb[i] = rgb;
}
}
bmInfo = (LPBITMAPINFO)hDIB;
/* Create a halftone palette if colors > 256. */
if (0 == nColors || nColors > 256)
{
HDC hDC = CreateCompatibleDC(0); /* Desktop DC */
*pPal = CreateHalftonePalette(hDC);
DeleteDC(hDC);
}
else
{
UINT nSize = sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * nColors);
LOGPALETTE *pLP = (LOGPALETTE *)malloc(nSize);
int i;
pLP->palVersion = 0x300;
pLP->palNumEntries = nColors;
for (i = 0; i < nColors; i++)
{
pLP->palPalEntry[i].peRed = bmInfo->bmiColors[i].rgbRed;
pLP->palPalEntry[i].peGreen = bmInfo->bmiColors[i].rgbGreen;
pLP->palPalEntry[i].peBlue = bmInfo->bmiColors[i].rgbBlue;
pLP->palPalEntry[i].peFlags = 0;
}
*pPal = CreatePalette(pLP);
free (pLP);
}
copy_size = dibSize;
pixel_ptr = (char*)lpDIBBits;
*phDIB = hDIB;
return TRUE;
}
LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static BITMAPINFO * pPackedDib ;
static HPALETTE hPalette ;
static int cxClient, cyClient ;
static OPENFILENAME ofn ;
static TCHAR szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
static TCHAR szFilter[] = TEXT ("Bitmap Files (*.BMP)\0*.bmp\0")
TEXT ("All Files (*.*)\0*.*\0\0") ;
HDC hdc ;
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 ;
// Create the All-Purpose Palette
hdc = GetDC (hwnd) ;
hPalette = CreateHalftonePalette (hdc) ;
ReleaseDC (hwnd, hdc) ;
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 (pPackedDib)
{
free (pPackedDib) ;
pPackedDib = 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)
{
MessageBox (hwnd, TEXT ("Cannot load DIB file"),
szAppName, 0) ;
}
InvalidateRect (hwnd, NULL, TRUE) ;
return 0 ;
}
break ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
if (pPackedDib)
{
// Set halftone stretch mode
SetStretchBltMode (hdc, HALFTONE) ;
SetBrushOrgEx (hdc, 0, 0, NULL) ;
// Select and realize halftone palette
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
// StretchDIBits rather than SetDIBitsToDevice
StretchDIBits (hdc,
0,
0,
PackedDibGetWidth (pPackedDib),
PackedDibGetHeight (pPackedDib),
0,
0,
PackedDibGetWidth (pPackedDib),
PackedDibGetHeight (pPackedDib),
PackedDibGetBitsPtr (pPackedDib),
pPackedDib,
DIB_RGB_COLORS,
SRCCOPY) ;
}
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_QUERYNEWPALETTE:
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
InvalidateRect (hwnd, NULL, TRUE) ;
ReleaseDC (hwnd, hdc) ;
return TRUE ;
case WM_PALETTECHANGED:
if ((HWND) wParam != hwnd)
hdc = GetDC (hwnd) ;
SelectPalette (hdc, hPalette, FALSE) ;
RealizePalette (hdc) ;
UpdateColors (hdc) ;
ReleaseDC (hwnd, hdc) ;
break ;
case WM_DESTROY:
if (pPackedDib)
free (pPackedDib) ;
DeleteObject (hPalette) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
void KEMFPanel::OnDraw(HDC hDC)
{
HPALETTE hOld = NULL;
if ( m_hPalette )
{
hOld = SelectPalette(hDC, m_hPalette, FALSE);
int no = RealizePalette(hDC);
no ++;
}
switch ( m_mode )
{
case 1:
{
KDelayEMF delay(5);
DisplayEMF(hDC, m_hEmf, 5, 5, m_zoom, m_zoom, & delay, true);
}
break;
case 2:
{
KGrayEMF gray;
DisplayEMF(hDC, m_hEmf, 5, 5, m_zoom, m_zoom, & gray, true);
}
break;
case 3:
{
KTraceEMF trace((HINSTANCE) GetWindowLong(WindowFromDC(hDC), GWL_HINSTANCE));
trace.Show(false);
HPALETTE hPal = CreateHalftonePalette(hDC);
HPALETTE hOld = SelectPalette(hDC, hPal, TRUE);
trace.m_pLog->Log("/////////////// Before Drawing //////////////\r\n");
trace.CompareDC(hDC);
trace.m_pLog->Log("/////////////// Starting Drawing //////////////\r\n");
DisplayEMF(hDC, m_hEmf, 5, 5, m_zoom, m_zoom, & trace, true);
trace.m_pLog->Log("/////////////// After Drawing //////////////\r\n");
trace.CompareDC(hDC);
SelectPalette(hDC, hOld, TRUE);
DeleteObject(hPal);
trace.Show(true);
}
break;
default:
DisplayEMF(hDC, m_hEmf, 5, 5, m_zoom, m_zoom, NULL, true);
}
m_mode = 0; // reset
if ( hOld )
SelectPalette(hDC, hOld, TRUE);
}
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++;
}
static void test_GetCurrentObject(void)
{
DWORD type;
HPEN hpen;
HBRUSH hbrush;
HPALETTE hpal;
HFONT hfont;
HBITMAP hbmp;
HRGN hrgn;
HDC hdc;
HCOLORSPACE hcs;
HGDIOBJ hobj;
LOGBRUSH lb;
LOGCOLORSPACEA lcs;
hdc = CreateCompatibleDC(0);
assert(hdc != 0);
type = GetObjectType(hdc);
ok(type == OBJ_MEMDC, "GetObjectType returned %u\n", type);
hpen = CreatePen(PS_SOLID, 10, RGB(10, 20, 30));
assert(hpen != 0);
SelectObject(hdc, hpen);
hobj = GetCurrentObject(hdc, OBJ_PEN);
ok(hobj == hpen, "OBJ_PEN is wrong: %p\n", hobj);
hobj = GetCurrentObject(hdc, OBJ_EXTPEN);
ok(hobj == hpen, "OBJ_EXTPEN is wrong: %p\n", hobj);
hbrush = CreateSolidBrush(RGB(10, 20, 30));
assert(hbrush != 0);
SelectObject(hdc, hbrush);
hobj = GetCurrentObject(hdc, OBJ_BRUSH);
ok(hobj == hbrush, "OBJ_BRUSH is wrong: %p\n", hobj);
hpal = CreateHalftonePalette(hdc);
assert(hpal != 0);
SelectPalette(hdc, hpal, FALSE);
hobj = GetCurrentObject(hdc, OBJ_PAL);
ok(hobj == hpal, "OBJ_PAL is wrong: %p\n", hobj);
hfont = CreateFontA(10, 5, 0, 0, FW_DONTCARE, 0, 0, 0, ANSI_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH, "MS Sans Serif");
assert(hfont != 0);
SelectObject(hdc, hfont);
hobj = GetCurrentObject(hdc, OBJ_FONT);
ok(hobj == hfont, "OBJ_FONT is wrong: %p\n", hobj);
hbmp = CreateBitmap(100, 100, 1, 1, NULL);
assert(hbmp != 0);
SelectObject(hdc, hbmp);
hobj = GetCurrentObject(hdc, OBJ_BITMAP);
ok(hobj == hbmp, "OBJ_BITMAP is wrong: %p\n", hobj);
assert(GetObjectA(hbrush, sizeof(lb), &lb) == sizeof(lb));
hpen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_SQUARE | PS_JOIN_BEVEL,
10, &lb, 0, NULL);
assert(hpen != 0);
SelectObject(hdc, hpen);
hobj = GetCurrentObject(hdc, OBJ_PEN);
ok(hobj == hpen, "OBJ_PEN is wrong: %p\n", hobj);
hobj = GetCurrentObject(hdc, OBJ_EXTPEN);
ok(hobj == hpen, "OBJ_EXTPEN is wrong: %p\n", hobj);
hcs = GetColorSpace(hdc);
if (hcs)
{
trace("current color space is not NULL\n");
ok(GetLogColorSpaceA(hcs, &lcs, sizeof(lcs)), "GetLogColorSpace failed\n");
hcs = CreateColorSpaceA(&lcs);
ok(hcs != 0, "CreateColorSpace failed\n");
SelectObject(hdc, hcs);
hobj = GetCurrentObject(hdc, OBJ_COLORSPACE);
ok(hobj == hcs, "OBJ_COLORSPACE is wrong: %p\n", hobj);
}
hrgn = CreateRectRgn(1, 1, 100, 100);
assert(hrgn != 0);
SelectObject(hdc, hrgn);
hobj = GetCurrentObject(hdc, OBJ_REGION);
ok(!hobj, "OBJ_REGION is wrong: %p\n", hobj);
DeleteDC(hdc);
}
/****************************************************************************
*
* FUNCTION: CopyColorTable
*
* PURPOSE: Copies the color table from one CF_DIB to another.
*
* PARAMS: LPBITMAPINFO lpTarget - pointer to target DIB
* LPBITMAPINFO lpSource - pointer to source DIB
*
* RETURNS: BOOL - TRUE for success, FALSE for failure
*
* History:
* July '95 - Created
*
\****************************************************************************/
BOOL CopyColorTable( LPBITMAPINFO lpTarget, LPBITMAPINFO lpSource )
{
// What we do depends on the target's color depth
switch( lpTarget->bmiHeader.biBitCount )
{
// 8bpp - need 256 entry color table
case 8:
if( lpSource->bmiHeader.biBitCount == 8 )
{ // Source is 8bpp too, copy color table
memcpy( lpTarget->bmiColors, lpSource->bmiColors, 256*sizeof(RGBQUAD) );
return TRUE;
}
else
{ // Source is != 8bpp, use halftone palette
HPALETTE hPal;
HDC hDC = GetDC( NULL );
PALETTEENTRY pe[256];
UINT i;
hPal = CreateHalftonePalette( hDC );
ReleaseDC( NULL, hDC );
GetPaletteEntries( hPal, 0, 256, pe );
DeleteObject( hPal );
for(i=0;i<256;i++)
{
lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
}
return TRUE;
}
break; // end 8bpp
// 4bpp - need 16 entry color table
case 4:
if( lpSource->bmiHeader.biBitCount == 4 )
{ // Source is 4bpp too, copy color table
memcpy( lpTarget->bmiColors, lpSource->bmiColors, 16*sizeof(RGBQUAD) );
return TRUE;
}
else
{ // Source is != 4bpp, use system palette
HPALETTE hPal;
PALETTEENTRY pe[256];
UINT i;
hPal = GetStockObject( DEFAULT_PALETTE );
GetPaletteEntries( hPal, 0, 16, pe );
for(i=0;i<16;i++)
{
lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
}
return TRUE;
}
break; // end 4bpp
// 1bpp - need 2 entry mono color table
case 1:
lpTarget->bmiColors[0].rgbRed = 0;
lpTarget->bmiColors[0].rgbGreen = 0;
lpTarget->bmiColors[0].rgbBlue = 0;
lpTarget->bmiColors[0].rgbReserved = 0;
lpTarget->bmiColors[1].rgbRed = 255;
lpTarget->bmiColors[1].rgbGreen = 255;
lpTarget->bmiColors[1].rgbBlue = 255;
lpTarget->bmiColors[1].rgbReserved = 0;
break; // end 1bpp
// no color table for the > 8bpp modes
case 32:
case 24:
case 16:
default:
return TRUE;
break;
}
return TRUE;
}
BOOL CDIB::CreatePalette()
{
//m_hPal DeleteObject();
if (!m_hBitmap)
return FALSE;
// Create a 256 color halftone palette if there is no color table in the DIBSection
if (m_iColorTableSize == 0)
return CreateHalftonePalette(m_hPal, 256);
// Get space for the color entries
RGBQUAD *pRGB = new RGBQUAD[m_iColorTableSize];
if (!pRGB)
return CreateHalftonePalette(m_hPal, m_iColorTableSize);
HDC hDC = ::GetDC(NULL);
if (!hDC)
{
delete [] pRGB;
return FALSE;
}
// Create a memory DC compatible with the current DC
HDC hMemDC = CreateCompatibleDC(hDC);
if (!hMemDC)
{
delete [] pRGB;
ReleaseDC(NULL, hDC);
return CreateHalftonePalette(m_hPal, m_iColorTableSize);
}
ReleaseDC(NULL, hDC);
HBITMAP hOldBitmap = (HBITMAP) SelectObject(hMemDC, m_hBitmap);
if (!hOldBitmap)
{
delete [] pRGB;
return CreateHalftonePalette(m_hPal, m_iColorTableSize);
}
// Get the colors used. WinCE does not support GetDIBColorTable so if you
// are using this on a CE device with palettes, then you need to replace
// the call with code that manually gets the color table from the m_DIBinfo structure.
int nColors = CEGetDIBColorTable(hDC, 0, m_iColorTableSize, pRGB);
// Clean up
SelectObject(hMemDC, hOldBitmap);
if (!nColors) // No colors retrieved => the bitmap in the DC is not a DIB section
{
delete [] pRGB;
return CreateHalftonePalette(m_hPal, m_iColorTableSize);
}
// Create and fill a LOGPALETTE structure with the colors used.
PALETTEINFO PaletteInfo;
PaletteInfo.palNumEntries = m_iColorTableSize;
for (int ii = 0; ii < nColors; ii++)
{
PaletteInfo.palPalEntry[ii].peRed = pRGB[ii].rgbRed;
PaletteInfo.palPalEntry[ii].peGreen = pRGB[ii].rgbGreen;
PaletteInfo.palPalEntry[ii].peBlue = pRGB[ii].rgbBlue;
PaletteInfo.palPalEntry[ii].peFlags = 0;
}
delete [] pRGB;
// Create Palette!
m_hPal = ::CreatePalette( &PaletteInfo );
return (NULL != m_hPal);
}
