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 );
}
/* The function makes the window visible if it is hidden
or is not yet shown. */
void
SplashRedrawWindow(Splash * splash)
{
if (!SplashIsStillLooping(splash)) {
KillTimer(splash->hWnd, 0);
}
if (splash->currentFrame < 0) {
return;
}
SplashUpdateScreenData(splash);
if (splash->isLayered) {
BLENDFUNCTION bf;
POINT ptSrc;
HDC hdcSrc = CreateCompatibleDC(NULL), hdcDst;
BITMAPINFOHEADER bmi;
void *bitmapBits;
HBITMAP hBitmap, hOldBitmap;
RECT rect;
POINT ptDst;
SIZE size;
bf.BlendOp = AC_SRC_OVER;
bf.BlendFlags = 0;
bf.AlphaFormat = AC_SRC_ALPHA;
bf.SourceConstantAlpha = 0xFF;
ptSrc.x = ptSrc.y = 0;
memset(&bmi, 0, sizeof(bmi));
bmi.biSize = sizeof(BITMAPINFOHEADER);
bmi.biWidth = splash->width;
bmi.biHeight = -splash->height;
bmi.biPlanes = 1;
bmi.biBitCount = 32;
bmi.biCompression = BI_RGB;
// FIXME: this is somewhat ineffective
// maybe if we allocate memory for all frames as DIBSections,
// then we could select the frames into the DC directly
hBitmap = CreateDIBSection(NULL, (BITMAPINFO *) & bmi, DIB_RGB_COLORS,
&bitmapBits, NULL, 0);
memcpy(bitmapBits, splash->screenData,
splash->screenStride * splash->height);
hOldBitmap = (HBITMAP) SelectObject(hdcSrc, hBitmap);
hdcDst = GetDC(splash->hWnd);
GetWindowRect(splash->hWnd, &rect);
ptDst.x = rect.left;
ptDst.y = rect.top;
size.cx = splash->width;
size.cy = splash->height;
UpdateLayeredWindow(splash->hWnd, hdcDst, &ptDst, &size,
hdcSrc, &ptSrc, 0, &bf, ULW_ALPHA);
ReleaseDC(splash->hWnd, hdcDst);
SelectObject(hdcSrc, hOldBitmap);
DeleteObject(hBitmap);
DeleteDC(hdcSrc);
}
else {
InvalidateRect(splash->hWnd, NULL, FALSE);
if (splash->maskRequired) {
HRGN hRgn = CreateRectRgn(0, 0, 0, 0);
CombineRgn(hRgn, splash->frames[splash->currentFrame].hRgn,
splash->frames[splash->currentFrame].hRgn, RGN_COPY);
SetWindowRgn(splash->hWnd, hRgn, TRUE);
} else {
SetWindowRgn(splash->hWnd, NULL, TRUE);
}
UpdateWindow(splash->hWnd);
}
if (!IsWindowVisible(splash->hWnd)) {
POINT cursorPos;
ShowWindow(splash->hWnd, SW_SHOW);
// Windows won't update the cursor after the window is shown,
// if the cursor is already above the window. need to do this manually.
GetCursorPos(&cursorPos);
if (WindowFromPoint(cursorPos) == splash->hWnd) {
// unfortunately Windows fail to understand that the window
// thread should own the cursor, even though the mouse pointer
// is over the window, until the mouse has been moved.
// we're using SetCursorPos here to fake the mouse movement
// and enable proper update of the cursor.
SetCursorPos(cursorPos.x, cursorPos.y);
SetCursor(LoadCursor(NULL, IDC_WAIT));
}
}
if (SplashIsStillLooping(splash)) {
int time = splash->time +
splash->frames[splash->currentFrame].delay - SplashTime();
if (time < 0)
time = 0;
SetTimer(splash->hWnd, 0, time, NULL);
}
}
// Handles OS messages, is driven by the 'main loop' above.
LRESULT CALLBACK MainWindowProcedure(HWND windowHandle, UINT messageCode, WPARAM wParam, LPARAM lParam)
{
switch (messageCode) {
// On window creation.
case WM_CREATE:
DEBUG_OUT(TEXT("WM_CREATE message"));
// Start game loop timer.
DEBUG_VAL(TEXT("SetTimer()"), SetTimer(windowHandle, MAIN_CYCLE_TIMER_ID, MAIN_CYCLE_WAIT, NULL));
break;
// Upon redraw request or something else changing we draw the window.
case WM_PAINT:
{
PAINTSTRUCT paintJobStruct;
HDC deviceContextHandle = BeginPaint(windowHandle, &paintJobStruct);
HDC bufferDeviceContextHandle = CreateCompatibleDC(deviceContextHandle);
HBITMAP bufferBitmapHandle = CreateCompatibleBitmap(deviceContextHandle, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT);
HGDIOBJ oldBufferBitmapHandle = SelectObject(bufferDeviceContextHandle, bufferBitmapHandle);
Gdiplus::Graphics graphics(bufferDeviceContextHandle);
graphics.SetSmoothingMode(GRAPHICS_SMOOTHING_MODE);
DrawGame(graphics, *mainGameObject);
BitBlt(deviceContextHandle, 0, 0, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT, bufferDeviceContextHandle, 0, 0, SRCCOPY);
SelectObject(bufferDeviceContextHandle, oldBufferBitmapHandle);
DeleteDC(bufferDeviceContextHandle);
DeleteObject(bufferBitmapHandle);
EndPaint(windowHandle, &paintJobStruct);
}
break;
// When a user presses a key (can be triggered by auto-repeat).
case WM_KEYDOWN:
DEBUG_OUT(TEXT("WM_KEYDOWN message"));
DEBUG_VAL(TEXT("wParam"), wParam);
switch(wParam) {
case VK_LEFT:
case VK_UP:
case VK_RIGHT:
case VK_DOWN:
DEBUG_OUT(TEXT("Arrow key pressed"));
mainGameObject->Input(wParam);
}
break;
case WM_TIMER:
if (wParam == MAIN_CYCLE_TIMER_ID) {
// This is where the 'main game loop' kicks in. This line should be reached at a frequency of about 60Hz.
mainGameObject->Step(windowHandle);
RedrawWindow(windowHandle, NULL, NULL, RDW_INVALIDATE);
//InvalidateRect(windowHandle, NULL, TRUE);
//UpdateWindow(windowHandle);
}
break;
case WM_CLOSE:
DEBUG_OUT(TEXT("WM_CLOSE message"));
// Clean up Windows API objects and etc.
KillTimer(windowHandle, MAIN_CYCLE_TIMER_ID);
DestroyWindow(windowHandle);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(windowHandle, messageCode, wParam, lParam);
break;
}
return 0;
}
static void Paint(HWND hWnd, LPPAINTSTRUCT lpPS) {
GetClientRect(hWnd, &rc);
hdcMem = CreateCompatibleDC(lpPS->hdc);
hbmMem = CreateCompatibleBitmap(lpPS->hdc, rc.right-rc.left, rc.bottom-rc.top);
hbmOld = (HBITMAP) SelectObject(hdcMem, hbmMem);
hbrBkGnd = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
FillRect(hdcMem, &rc, hbrBkGnd);
for(int i = 0; i < vectorSize; i++){
x = vec[i].getX();
y = vec[i].getY();
hbrBkGnd = CreateSolidBrush(RGB(vec[i].getR(), vec[i].getG(), vec[i].getB()));
SelectObject(hdcMem, hbrBkGnd);
for(int j = 0; j < vectorSize; j++){
if(j != i){
if(vec[i].trueCollision(vec[j].getX(), vec[j].getY())){
vec[i].setColor(rand()%250, rand()%250, rand()%250);
vec[j].setColor(rand()%250, rand()%250, rand()%250);
}
}
}
vec[i].collision(rect.right, rect.bottom);
switch(vec[i].getDir()) {
case 0:
x += vec[i].getVelocity() + velocity;
y += vec[i].getVelocity() + velocity;
break;
case 1:
x -= vec[i].getVelocity() + velocity;
y += vec[i].getVelocity() + velocity;
break;
case 2:
x += vec[i].getVelocity() + velocity;
y -= vec[i].getVelocity() + velocity;
break;
case 3:
x -= vec[i].getVelocity() + velocity;
y -= vec[i].getVelocity() + velocity;
break;
}
vec[i].setPosition(x, y);
if(vec[i].trueCircle()){
Ellipse(hdcMem, vec[i].getX(), vec[i].getY(), vec[i].getX() + vec[i].getWidth(),
vec[i].getY() + vec[i].getHeight());
}else{
Rectangle(hdcMem, vec[i].getX(), vec[i].getY(), vec[i].getX() + vec[i].getWidth(),
vec[i].getY() + vec[i].getHeight());
}
}
DeleteObject(hbrBkGnd);
SetBkMode(hdcMem, BACKGROUND_BLUE);
SetTextColor(hdcMem, GetSysColor(COLOR_WINDOWTEXT));
if (hfntOld) {
SelectObject(hdcMem, hfntOld);
}
BitBlt(lpPS->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
}
ALERROR rgnCreateFromBitmap (HBITMAP hBitmap, HRGN *rethRgn)
// rgnCreateFromBitmap
//
// Creates a region from a bitmap
{
ALERROR error;
HDC hDC = NULL;
DWORD *pLine = NULL;
RGNDATAHEADER rdh;
BITMAP bm;
int x, y;
int iLineSize;
char bitmapinfo[sizeof(BITMAPINFOHEADER) + 2 * sizeof(DWORD)];
BITMAPINFOHEADER *pbmi = (BITMAPINFOHEADER *)bitmapinfo;
// Figure out the size of the bitmap
GetObject(hBitmap, sizeof(bm), &bm);
// Prepare an output stream
CMemoryWriteStream Output(bm.bmWidth * bm.bmHeight * sizeof(RECT));
if (error = Output.Create())
goto Fail;
rdh.dwSize = sizeof(rdh);
rdh.iType = RDH_RECTANGLES;
rdh.nCount = 0;
rdh.nRgnSize = 0;
// We assume that the bitmap already represents the bounding rect
rdh.rcBound.top = 0;
rdh.rcBound.left = 0;
rdh.rcBound.bottom = bm.bmHeight;
rdh.rcBound.right = bm.bmWidth;
// Write out the unitialized header; we will fill it in later
if (error = Output.Write((char *)&rdh, sizeof(rdh), NULL))
goto Fail;
// Prepare
hDC = CreateCompatibleDC(NULL);
iLineSize = AlignUp(bm.bmWidth, 32) / 32;
pLine = (DWORD *)MemAlloc(iLineSize * sizeof(DWORD));
ZeroMemory(pbmi, sizeof(BITMAPINFOHEADER));
pbmi->biSize = sizeof(BITMAPINFOHEADER);
pbmi->biWidth = bm.bmWidth;
pbmi->biHeight = bm.bmHeight;
pbmi->biPlanes = 1;
pbmi->biBitCount = 1;
pbmi->biCompression = BI_RGB;
// Loop over each scan line
for (y = 0; y < bm.bmHeight; y++)
{
int xRunStart;
GetDIBits(hDC,
hBitmap,
y,
1,
pLine,
(BITMAPINFO *)pbmi,
DIB_RGB_COLORS);
// Look for the beginning of a run
x = 0;
xRunStart = -1;
while (x < bm.bmWidth)
{
if (xRunStart == -1)
{
// If we're not in a run and we suddenly find a white pixel
// then we know that we begin a run
if (PixelAt(pLine, x))
xRunStart = x;
}
else
{
// If we're in a run and we suddenly find a black pixel
// then we know that we're done
if (!PixelAt(pLine, x))
{
RECT rcRect;
rcRect.left = xRunStart;
rcRect.top = y;
rcRect.right = x;
rcRect.bottom = y + 1;
// Add the rect to the region
if (error = Output.Write((char *)&rcRect, sizeof(rcRect), NULL))
goto Fail;
rdh.nCount++;
rdh.nRgnSize += sizeof(RECT);
xRunStart = -1;
}
}
x++;
}
// If we were in a run, then end it
if (xRunStart != -1)
{
RECT rcRect;
rcRect.left = xRunStart;
rcRect.top = y;
rcRect.right = x;
rcRect.bottom = y + 1;
// Add the rect to the region
if (error = Output.Write((char *)&rcRect, sizeof(rcRect), NULL))
goto Fail;
rdh.nCount++;
rdh.nRgnSize += sizeof(RECT);
}
}
// Close it out
MemFree(pLine);
pLine = NULL;
DeleteDC(hDC);
hDC = NULL;
if (error = Output.Close())
goto Fail;
// Update the header
*(RGNDATAHEADER *)Output.GetPointer() = rdh;
// Create the region
*rethRgn = ExtCreateRegion(NULL,
Output.GetLength(),
(RGNDATA *)Output.GetPointer());
// Done
return NOERROR;
Fail:
if (pLine)
MemFree(pLine);
if (hDC)
DeleteDC(hDC);
return error;
}
CMonitorDC::~CMonitorDC()
{
VERIFY( DeleteDC() );
}
void CDrawCheckbox::Draw(HDC hDC)
{
RECT rcWnd = {};
GetClientRect(m_hWnd, &rcWnd);
int nWidth = rcWnd.right - rcWnd.left;
int nHeight = rcWnd.bottom - rcWnd.top;
HDC hMemDC = CreateCompatibleDC(hDC);
HBITMAP hBmpMem = CreateCompatibleBitmap(hDC, nWidth, nHeight);
HBITMAP hOldBmpMem = (HBITMAP)SelectObject(hMemDC, hBmpMem);
Image *pDrawImg = NULL;
if(!m_fLight)
{
pDrawImg = m_pNormalStateImg;
}
else
{
pDrawImg = m_pLightStateImg;
}
int nBmpWidth = pDrawImg->GetWidth();
int nBmpHeight = pDrawImg->GetHeight();
if (m_bkimState == BKLS_HORIZONTAL)
{
nBmpWidth = pDrawImg->GetWidth() / 8;
nBmpHeight = pDrawImg->GetHeight();
}
else
{
nBmpWidth = pDrawImg->GetWidth();
nBmpHeight = pDrawImg->GetHeight() / 8;
}
//绘制父窗口背景图
BitBlt(hMemDC, 0, 0, nWidth, nHeight, m_DrawBackgroundDC.m_hDC, 0, 0, SRCCOPY);
//绘制背景图，高宽一样大小
//StretchBlt(hDC, 0, nYPos, nWidth, nHeight - nYPos, hMemDC, nXBmpPos,\
// 0, nBmpWidth, nBmpHeight, SRCCOPY);
SetBkMode(hMemDC, TRANSPARENT);
Graphics graphics(hMemDC); // Create a GDI+ graphics object
RectF gRect;
gRect.X = (REAL)0;
gRect.Y = (REAL)0;
gRect.Width = (REAL)nHeight;
gRect.Height = (REAL)nHeight;
if (m_bkimState == BKLS_HORIZONTAL)
{
graphics.DrawImage(pDrawImg, gRect, (REAL)nBmpWidth * m_nCtrlState + m_bCheck * 4 * nBmpWidth, 0, (REAL)nBmpWidth, (REAL)nBmpHeight, UnitPixel);
}
else
{
graphics.DrawImage(pDrawImg, gRect, 0, (REAL)nBmpHeight * m_nCtrlState + m_bCheck * 4 * nBmpWidth, (REAL)nBmpWidth, (REAL)nBmpHeight, UnitPixel);
}
// 绘制文本
// 当前绘制文本为单行,若绘制多行，可修改一下源码
TCHAR szCaption[g_nCaptionLen] = {};
GetWindowText(m_hWnd, szCaption, g_nCaptionLen - 1);
if(_tcslen(szCaption) > 0)
{
HFONT hOldFont = (HFONT)SelectObject(hMemDC, m_hFont);
rcWnd.left += nHeight + 2;
rcWnd.top ++;
SetTextColor(hMemDC, m_colorText);
DrawText(hMemDC, szCaption, _tcslen(szCaption), &rcWnd, DT_VCENTER|DT_SINGLELINE);
SelectObject(hMemDC, hOldFont);
}
BitBlt(hDC, 0, 0, nWidth, nHeight, hMemDC, 0, 0, SRCCOPY);
SetBkMode(hMemDC, OPAQUE);
graphics.ReleaseHDC(hMemDC);
SelectObject(hMemDC, hOldBmpMem);
DeleteObject(hBmpMem);
DeleteDC(hMemDC);
}
static void test_surface_from_dc3(void)
{
IDirectDrawSurface3 *surf3;
IDirectDrawSurface *surf1;
IDirectDrawSurface *tmp;
DDSURFACEDESC ddsd;
IDirectDraw3 *dd3;
IDirectDraw *dd1;
HRESULT hr;
HDC dc;
dd1 = createDD();
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw3, (void **)&dd3);
ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed, hr %#x.\n", hr);
IDirectDraw_Release(dd1);
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.dwWidth = 64;
ddsd.dwHeight = 64;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
hr = IDirectDraw3_CreateSurface(dd3, &ddsd, &surf1, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
IDirectDraw3_Release(dd3);
return;
}
ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr);
hr = IDirectDrawSurface3_QueryInterface(surf1, &IID_IDirectDrawSurface, (void **)&surf3);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
IDirectDrawSurface_Release(surf1);
hr = IDirectDrawSurface3_GetDC(surf3, &dc);
ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr);
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, NULL);
ok(hr == E_POINTER, "Expected E_POINTER, got %#x.\n", hr);
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, &tmp);
ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr);
ok((IDirectDrawSurface3 *)tmp == surf3, "Expected surface != %p.\n", surf3);
IUnknown_Release(tmp);
hr = IDirectDrawSurface3_ReleaseDC(surf3, dc);
ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr);
dc = CreateCompatibleDC(NULL);
ok(!!dc, "CreateCompatibleDC failed.\n");
tmp = (IDirectDrawSurface *)0xdeadbeef;
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, &tmp);
ok(hr == DDERR_NOTFOUND, "Expected DDERR_NOTFOUND, got %#x.\n", hr);
ok(!tmp, "Expected surface NULL, got %p.\n", tmp);
ok(DeleteDC(dc), "DeleteDC failed.\n");
IDirectDrawSurface3_Release(surf3);
IDirectDraw3_Release(dd3);
}
static void test_surface_from_dc4(void)
{
IDirectDrawSurface4 *surf4;
IDirectDrawSurface *surf1;
DDSURFACEDESC2 ddsd2;
IUnknown *tmp, *tmp2;
IDirectDraw4 *dd4;
IDirectDraw *dd1;
DWORD priv, size;
HRESULT hr;
HDC dc;
dd1 = createDD();
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw4, (void **)&dd4);
if (hr == E_NOINTERFACE) {
win_skip("DirectDraw4 is not supported\n");
IDirectDraw_Release(dd1);
return;
}
ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed, hr %#x.\n", hr);
IDirectDraw_Release(dd1);
memset(&ddsd2, 0, sizeof(ddsd2));
ddsd2.dwSize = sizeof(ddsd2);
ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd2.dwWidth = 64;
ddsd2.dwHeight = 64;
ddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
hr = IDirectDraw4_CreateSurface(dd4, &ddsd2, &surf4, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
IDirectDraw3_Release(dd4);
return;
}
ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr);
hr = IDirectDrawSurface4_QueryInterface(surf4, &IID_IDirectDrawSurface, (void **)&surf1);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
priv = 0xdeadbeef;
size = sizeof(priv);
hr = IDirectDrawSurface4_SetPrivateData(surf4, &guid, &priv, size, 0);
ok(SUCCEEDED(hr), "SetPrivateData failed, hr %#x.\n", hr);
priv = 0;
hr = IDirectDrawSurface4_GetPrivateData(surf4, &guid, &priv, &size);
ok(SUCCEEDED(hr), "GetPrivateData failed, hr %#x.\n", hr);
ok(priv == 0xdeadbeef, "Expected private data 0xdeadbeef, got %#x.\n", priv);
hr = IDirectDrawSurface4_GetDC(surf4, &dc);
ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr);
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %#x.\n", hr);
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp);
ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr);
ok((IDirectDrawSurface4 *)tmp != surf4, "Expected surface != %p.\n", surf4);
hr = IUnknown_QueryInterface(tmp, &IID_IDirectDrawSurface, (void **)&tmp2);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
ok(tmp2 == tmp, "Expected %p, got %p.\n", tmp, tmp2);
ok((IDirectDrawSurface *)tmp2 != surf1, "Expected surface != %p.\n", surf1);
IUnknown_Release(tmp2);
hr = IUnknown_QueryInterface(tmp, &IID_IDirectDrawSurface4, (void **)&tmp2);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
ok((IDirectDrawSurface4 *)tmp2 != surf4, "Expected surface != %p.\n", surf4);
priv = 0;
hr = IDirectDrawSurface4_GetPrivateData((IDirectDrawSurface4 *)tmp2, &guid, &priv, &size);
ok(SUCCEEDED(hr), "GetPrivateData failed, hr %#x.\n", hr);
ok(priv == 0xdeadbeef, "Expected private data 0xdeadbeef, got %#x.\n", priv);
IUnknown_Release(tmp2);
IUnknown_Release(tmp);
hr = IDirectDrawSurface4_ReleaseDC(surf4, dc);
ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr);
dc = CreateCompatibleDC(NULL);
ok(!!dc, "CreateCompatibleDC failed.\n");
tmp = (IUnknown *)0xdeadbeef;
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp);
ok(hr == DDERR_NOTFOUND, "Expected DDERR_NOTFOUND, got %#x.\n", hr);
ok(!tmp, "Expected surface NULL, got %p.\n", tmp);
ok(DeleteDC(dc), "DeleteDC failed.\n");
tmp = (IUnknown *)0xdeadbeef;
hr = IDirectDraw4_GetSurfaceFromDC(dd4, NULL, (IDirectDrawSurface4 **)&tmp);
ok(hr == DDERR_NOTFOUND, "Expected DDERR_NOTFOUND, got %#x.\n", hr);
ok(!tmp, "Expected surface NULL, got %p.\n", tmp);
IDirectDrawSurface_Release(surf1);
IDirectDrawSurface4_Release(surf4);
IDirectDraw4_Release(dd4);
}
static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface,
HICON hicon, IWICBitmap **bitmap)
{
IWICBitmapLock *lock;
ICONINFO info;
BITMAP bm;
int width, height, x, y;
UINT stride, size;
BYTE *buffer;
DWORD *bits;
BITMAPINFO bi;
HDC hdc;
BOOL has_alpha;
HRESULT hr;
TRACE("(%p,%p,%p)\n", iface, hicon, bitmap);
if (!bitmap) return E_INVALIDARG;
if (!GetIconInfo(hicon, &info))
return HRESULT_FROM_WIN32(GetLastError());
GetObjectW(info.hbmColor ? info.hbmColor : info.hbmMask, sizeof(bm), &bm);
width = bm.bmWidth;
height = info.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
stride = width * 4;
size = stride * height;
hr = BitmapImpl_Create(width, height, stride, size, NULL, 0,
&GUID_WICPixelFormat32bppBGRA, WICBitmapCacheOnLoad, bitmap);
if (hr != S_OK) goto failed;
hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
if (hr != S_OK)
{
IWICBitmap_Release(*bitmap);
goto failed;
}
IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
hdc = CreateCompatibleDC(0);
memset(&bi, 0, sizeof(bi));
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = width;
bi.bmiHeader.biHeight = info.hbmColor ? -height: -height * 2;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
has_alpha = FALSE;
if (info.hbmColor)
{
GetDIBits(hdc, info.hbmColor, 0, height, buffer, &bi, DIB_RGB_COLORS);
if (bm.bmBitsPixel == 32)
{
/* If any pixel has a non-zero alpha, ignore hbmMask */
bits = (DWORD *)buffer;
for (x = 0; x < width && !has_alpha; x++, bits++)
{
for (y = 0; y < height; y++)
{
if (*bits & 0xff000000)
{
has_alpha = TRUE;
break;
}
}
}
}
}
else
GetDIBits(hdc, info.hbmMask, 0, height, buffer, &bi, DIB_RGB_COLORS);
if (!has_alpha)
{
DWORD *rgba;
if (info.hbmMask)
{
BYTE *mask;
mask = HeapAlloc(GetProcessHeap(), 0, size);
if (!mask)
{
IWICBitmapLock_Release(lock);
IWICBitmap_Release(*bitmap);
DeleteDC(hdc);
hr = E_OUTOFMEMORY;
goto failed;
}
/* read alpha data from the mask */
GetDIBits(hdc, info.hbmMask, info.hbmColor ? 0 : height, height, mask, &bi, DIB_RGB_COLORS);
for (y = 0; y < height; y++)
{
rgba = (DWORD *)(buffer + y * stride);
bits = (DWORD *)(mask + y * stride);
for (x = 0; x < width; x++, rgba++, bits++)
{
if (*bits)
*rgba = 0;
else
*rgba |= 0xff000000;
}
}
HeapFree(GetProcessHeap(), 0, mask);
}
else
{
/* set constant alpha of 255 */
for (y = 0; y < height; y++)
{
rgba = (DWORD *)(buffer + y * stride);
for (x = 0; x < width; x++, rgba++)
*rgba |= 0xff000000;
}
}
}
IWICBitmapLock_Release(lock);
DeleteDC(hdc);
failed:
DeleteObject(info.hbmColor);
DeleteObject(info.hbmMask);
return hr;
}
UINT OnShowdireNum(LPVOID lParam)
{
int x=0;
int y=0;
int t=0;
double pi=3.1415926535898;
double r=170;
int a=0;
int b=0;
int m_shownum=0;
BITMAP m_bitmapinfo; //位图信息结构
CBitmap m_bitmap; //位图处理类
CDC m_men;
m_men.CreateCompatibleDC(m_diredashdc);
CPen m_pen1(NULL,3,RGB(255,0,0));
CPen m_pen2(NULL,5,RGB(255,0,0));
CRect m_childrect;
m_childrect.top=0;
m_childrect.left=0;
m_childrect.bottom=600;
m_childrect.right=700;
while(1){
m_bitmap.LoadBitmapA(MAKEINTRESOURCEA(IDB_YAM));
m_bitmap.GetBitmap(&m_bitmapinfo);
m_men.SelectObject(&m_bitmap);
m_shownum=(int)m_flightinfo.m_udirection;
m_men.SelectObject(&m_pen1);
m_men.SelectStockObject(NULL_BRUSH);
m_men.Ellipse(m_direrect.Width()/2-14-15+5+120,m_direrect.Height()/2+6-15-2+110,m_direrect.Width()/2-14+15+5+120,m_direrect.Height()/2+6+15-2+110);
m_pen1.DeleteObject();
m_men.SelectObject(&m_pen2);
m_men.Ellipse(m_direrect.Width()/2-14-5+5+120,m_direrect.Height()/2+6-5-2+110,m_direrect.Width()/2-14+5+5+120,m_direrect.Height()/2+6+5-2+110);
m_pen2.DeleteObject();
m_men.SelectObject(&m_pen1);
m_men.MoveTo(m_direrect.Width()/2-14+5+120,m_direrect.Height()/2+6-2+110);
x=m_direrect.Width()/2-14+5+120;
y=m_direrect.Height()/2+6-2+110;
t=(int)((m_shownum-1050)*180/900);
a=x-(int)(r*cos(t*pi/180));
b=y-(int)(r*sin(t*pi/180));
m_men.LineTo(a,b);
m_pen1.DeleteObject();
m_diredashdc->SetStretchBltMode(HALFTONE);
m_diredashdc->StretchBlt(m_direrect.top,m_direrect.left,m_direrect.Width(),m_direrect.Height(),&m_men,0,0,m_bitmapinfo.bmWidth,m_bitmapinfo.bmHeight,SRCCOPY);
m_bitmap.DeleteObject();
Sleep(14);
}
DeleteDC(m_men.m_hDC);
return 1;
}
static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface,
HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap **bitmap)
{
BITMAP bm;
HRESULT hr;
WICPixelFormatGUID format;
IWICBitmapLock *lock;
UINT size, num_palette_entries = 0;
PALETTEENTRY entry[256];
TRACE("(%p,%p,%p,%u,%p)\n", iface, hbm, hpal, option, bitmap);
if (!bitmap) return E_INVALIDARG;
if (GetObjectW(hbm, sizeof(bm), &bm) != sizeof(bm))
return WINCODEC_ERR_WIN32ERROR;
if (hpal)
{
num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
if (!num_palette_entries)
return WINCODEC_ERR_WIN32ERROR;
}
/* TODO: Figure out the correct format for 16, 32, 64 bpp */
switch(bm.bmBitsPixel)
{
case 1:
format = GUID_WICPixelFormat1bppIndexed;
break;
case 4:
format = GUID_WICPixelFormat4bppIndexed;
break;
case 8:
format = GUID_WICPixelFormat8bppIndexed;
break;
case 16:
if (!get_16bpp_format(hbm, &format))
return E_INVALIDARG;
break;
case 24:
format = GUID_WICPixelFormat24bppBGR;
break;
case 32:
switch (option)
{
case WICBitmapUseAlpha:
format = GUID_WICPixelFormat32bppBGRA;
break;
case WICBitmapUsePremultipliedAlpha:
format = GUID_WICPixelFormat32bppPBGRA;
break;
case WICBitmapIgnoreAlpha:
format = GUID_WICPixelFormat32bppBGR;
break;
default:
return E_INVALIDARG;
}
break;
case 48:
format = GUID_WICPixelFormat48bppRGB;
break;
default:
FIXME("unsupported %d bpp\n", bm.bmBitsPixel);
return E_INVALIDARG;
}
hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, 0, &format,
WICBitmapCacheOnLoad, bitmap);
if (hr != S_OK) return hr;
hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock);
if (hr == S_OK)
{
BYTE *buffer;
HDC hdc;
char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
IWICBitmapLock_GetDataPointer(lock, &size, &buffer);
hdc = CreateCompatibleDC(0);
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi->bmiHeader.biBitCount = 0;
GetDIBits(hdc, hbm, 0, 0, NULL, bmi, DIB_RGB_COLORS);
bmi->bmiHeader.biHeight = -bm.bmHeight;
GetDIBits(hdc, hbm, 0, bm.bmHeight, buffer, bmi, DIB_RGB_COLORS);
DeleteDC(hdc);
IWICBitmapLock_Release(lock);
if (num_palette_entries)
{
IWICPalette *palette;
WICColor colors[256];
UINT i;
hr = PaletteImpl_Create(&palette);
if (hr == S_OK)
{
for (i = 0; i < num_palette_entries; i++)
colors[i] = 0xff000000 | entry[i].peRed << 16 |
entry[i].peGreen << 8 | entry[i].peBlue;
hr = IWICPalette_InitializeCustom(palette, colors, num_palette_entries);
if (hr == S_OK)
hr = IWICBitmap_SetPalette(*bitmap, palette);
IWICPalette_Release(palette);
}
}
}
if (hr != S_OK)
{
IWICBitmap_Release(*bitmap);
*bitmap = NULL;
}
return hr;
}
static Image *ReadEMFImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
BITMAPINFO
DIBinfo;
HBITMAP
hBitmap,
hOldBitmap;
HDC
hDC;
HENHMETAFILE
hemf;
Image
*image;
RECT
rect;
register ssize_t
x;
register PixelPacket
*q;
RGBQUAD
*pBits,
*ppBits;
ssize_t
height,
width,
y;
image=AcquireImage(image_info);
hemf=ReadEnhMetaFile(image_info->filename,&width,&height);
if (hemf == (HENHMETAFILE) NULL)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
if ((image->columns == 0) || (image->rows == 0))
{
double
y_resolution,
x_resolution;
y_resolution=DefaultResolution;
x_resolution=DefaultResolution;
if (image->y_resolution > 0)
{
y_resolution=image->y_resolution;
if (image->units == PixelsPerCentimeterResolution)
y_resolution*=CENTIMETERS_INCH;
}
if (image->x_resolution > 0)
{
x_resolution=image->x_resolution;
if (image->units == PixelsPerCentimeterResolution)
x_resolution*=CENTIMETERS_INCH;
}
image->rows=(size_t) ((height/1000.0/CENTIMETERS_INCH)*y_resolution+0.5);
image->columns=(size_t) ((width/1000.0/CENTIMETERS_INCH)*
x_resolution+0.5);
}
if (image_info->size != (char *) NULL)
{
ssize_t
x;
image->columns=width;
image->rows=height;
x=0;
y=0;
(void) GetGeometry(image_info->size,&x,&y,&image->columns,&image->rows);
}
if (image_info->page != (char *) NULL)
{
char
*geometry;
register char
*p;
MagickStatusType
flags;
ssize_t
sans;
geometry=GetPageGeometry(image_info->page);
p=strchr(geometry,'>');
if (p == (char *) NULL)
{
flags=ParseMetaGeometry(geometry,&sans,&sans,&image->columns,
&image->rows);
if (image->x_resolution != 0.0)
image->columns=(size_t) floor((image->columns*image->x_resolution)+
0.5);
if (image->y_resolution != 0.0)
image->rows=(size_t) floor((image->rows*image->y_resolution)+0.5);
}
else
{
*p='\0';
flags=ParseMetaGeometry(geometry,&sans,&sans,&image->columns,
&image->rows);
if (image->x_resolution != 0.0)
image->columns=(size_t) floor(((image->columns*image->x_resolution)/
DefaultResolution)+0.5);
if (image->y_resolution != 0.0)
image->rows=(size_t) floor(((image->rows*image->y_resolution)/
DefaultResolution)+0.5);
}
geometry=DestroyString(geometry);
}
hDC=GetDC(NULL);
if (hDC == (HDC) NULL)
{
DeleteEnhMetaFile(hemf);
ThrowReaderException(ResourceLimitError,"UnableToCreateADC");
}
/*
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;
hBitmap=CreateDIBSection(hDC,&DIBinfo,DIB_RGB_COLORS,(void **) &ppBits,NULL,
0);
ReleaseDC(NULL,hDC);
if (hBitmap == (HBITMAP) NULL)
{
DeleteEnhMetaFile(hemf);
ThrowReaderException(ResourceLimitError,"UnableToCreateBitmap");
}
hDC=CreateCompatibleDC(NULL);
if (hDC == (HDC) NULL)
{
DeleteEnhMetaFile(hemf);
DeleteObject(hBitmap);
ThrowReaderException(ResourceLimitError,"UnableToCreateADC");
}
hOldBitmap=(HBITMAP) SelectObject(hDC,hBitmap);
if (hOldBitmap == (HBITMAP) NULL)
{
DeleteEnhMetaFile(hemf);
DeleteDC(hDC);
DeleteObject(hBitmap);
ThrowReaderException(ResourceLimitError,"UnableToCreateBitmap");
}
/*
Initialize the bitmap to the image background color.
*/
pBits=ppBits;
for (y=0; y < (ssize_t) image->rows; y++)
{
for (x=0; x < (ssize_t) image->columns; x++)
{
pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
pBits->rgbGreen=ScaleQuantumToChar(image->background_color.green);
pBits->rgbBlue=ScaleQuantumToChar(image->background_color.blue);
pBits++;
}
}
rect.top=0;
rect.left=0;
rect.right=(LONG) image->columns;
rect.bottom=(LONG) image->rows;
/*
Convert metafile pixels.
*/
PlayEnhMetaFile(hDC,hemf,&rect);
pBits=ppBits;
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelRed(q,ScaleCharToQuantum(pBits->rgbRed));
SetPixelGreen(q,ScaleCharToQuantum(pBits->rgbGreen));
SetPixelBlue(q,ScaleCharToQuantum(pBits->rgbBlue));
SetPixelOpacity(q,OpaqueOpacity);
pBits++;
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
DeleteEnhMetaFile(hemf);
SelectObject(hDC,hOldBitmap);
DeleteDC(hDC);
DeleteObject(hBitmap);
return(GetFirstImageInList(image));
}
int GBK_InitVisibleTable()
{
HDC hdc = CreateCompatibleDC( GetWindowDC( GetDesktopWindow() ) );
HBITMAP hBmp = CreateCompatibleBitmap(hdc, 12, 12);
RECT rect = {0, 0, 12, 12};
BITMAPINFO bi;
ZeroMemory(&bi, sizeof(bi));
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bi.bmiHeader.biWidth = 12;
bi.bmiHeader.biHeight = 12;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 16;
bi.bmiHeader.biCompression = BI_RGB;
LOGFONT lf;
lf.lfHeight = 0xfffffff4;
lf.lfWidth = 0x00000000;
lf.lfEscapement = 0x00000000;
lf.lfOrientation = 0x00000000;
lf.lfWeight = 0x00000190;
lf.lfItalic = 0;
lf.lfUnderline = 0;
lf.lfStrikeOut = 0;
lf.lfCharSet = 0;
lf.lfOutPrecision = 0x03;
lf.lfClipPrecision = 0x02;
lf.lfQuality = 0x01;
lf.lfPitchAndFamily = 0x02;
strcpy(lf.lfFaceName, "宋体");
HFONT hFont = CreateFontIndirect(&lf);
if(hFont == 0)
{
MessageBox(NULL, "字体创建失败！", "Error", MB_OK | MB_ICONEXCLAMATION);
return 0;
}
SelectObject(hdc, hFont);
SelectObject(hdc, hBmp);
SetBkColor(hdc, RGB(0, 0, 0));
SetTextColor(hdc, RGB(255, 255, 255));
unsigned short TestBuf[12][12];
for (unsigned short lead=0x81; lead<0xff; lead++)
for (unsigned short follow=0x40; follow<0xff; follow++)
{
bool test = false;
if (follow != 0x7f)
{
unsigned short ucode = MAKEWORD(lead, follow);
DrawText(hdc, (char *)&ucode, 2, &rect, 0);
GetDIBits(hdc, hBmp, 0, 12, *TestBuf, &bi, 0);
for (int nY=0; nY<12; nY++)
{
for(int nX = 0; nX<12; nX++)
{
test |= (TestBuf[nY][nX] != 0);
}
}
}
GBK_VisibleTable[lead - 0x81][follow - 0x40] = test;
}
DeleteObject(hFont);
DeleteObject(hBmp);
DeleteDC(hdc);
return 1;
}
/* Функция обработки сообщения окна.
* АРГУМЕНТЫ:
* - дескриптор окна:
* HWND hWnd;
* - номер сообщения (см. WM_***):
* UINT Msg;
* - параметр сообшения ('word parameter'):
* WPARAM wParam;
* - параметр сообшения ('long parameter'):
* LPARAM lParam;
* ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ:
* (LRESULT) - в зависимости от сообщения.
*/
LRESULT CALLBACK MyWindowFunc( HWND hWnd, UINT Msg,
WPARAM wParam, LPARAM lParam )
{
HDC hDC;
static HDC hMemDC;
static INT w, h;
static BITMAP bm;
static HBITMAP hBm;
switch (Msg)
{
case WM_CREATE:
SetTimer(hWnd, 111, 50, NULL);
/* создаем контекст в памяти */
hDC = GetDC(hWnd);
hMemDC = CreateCompatibleDC(hDC);
ReleaseDC(hWnd, hDC);
return 0;
case WM_SIZE:
w = LOWORD(lParam);
h = HIWORD(lParam);
/* создаем картинку размером с окно */
if (hBm != NULL)
DeleteObject(hBm);
hDC = GetDC(hWnd);
hBm = CreateCompatibleBitmap(hDC, w, h);
ReleaseDC(hWnd, hDC);
SelectObject(hMemDC, hBm);
SendMessage(hWnd, WM_TIMER, 111, 0);
return 0;
case WM_TIMER:
/* Clear Background */
SelectObject(hMemDC, GetStockObject(NULL_PEN));
SelectObject(hMemDC, GetStockObject(DC_BRUSH));
SetDCBrushColor(hMemDC, RGB(255, 255, 255));
Rectangle(hMemDC, 0, 0, w + 1, h + 1);
SelectObject(hMemDC, GetStockObject(NULL_PEN));
SelectObject(hMemDC, GetStockObject(DC_BRUSH));
SetDCBrushColor(hMemDC, RGB(255, 0, 0));
GlobeBuild();
GlobeDraw(hMemDC, w, h);
InvalidateRect(hWnd, NULL, TRUE);
return 0;
case WM_KEYDOWN:
if (wParam == 'F')
FlipFullScreen(hWnd);
if (wParam == 27)
SendMessage(hWnd, WM_CLOSE, 0, 0);
if (wParam == 'W')
IsWire = !IsWire;
return 0;
case WM_CLOSE:
if (MessageBox(hWnd, "Are you shure to exit from program?",
"Exit", MB_YESNO | MB_ICONQUESTION) == IDNO)
return 0;
break;
case WM_ERASEBKGND:
BitBlt((HDC)wParam, 0, 0, w, h, hMemDC, 0, 0, SRCCOPY);
return 0;
case WM_DESTROY:
DeleteDC(hMemDC);
DeleteObject(hBm);
KillTimer(hWnd, 111);
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc,bmp_dc;
HGDIOBJ oldbmp;
OGUI::Image target(640, 480, (unsigned char*)bitmap_pixels);
RECT rect;
int x, y;
rect.left = rect.top = 0;
rect.right = 640;
rect.bottom = 480;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_TIMER:
if (OGUI::OGUIManager::instance()->get_desktop()->draw(target, OGUI::Rect(0, 0, 640, 480)))
InvalidateRect(hWnd, &rect, FALSE);
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
bmp_dc = CreateCompatibleDC(hdc);
oldbmp=SelectObject(bmp_dc, bitmap);
BitBlt(hdc, 0, 0, 640, 480, bmp_dc, 0, 0, SRCCOPY);
SelectObject(bmp_dc, oldbmp);
DeleteDC(bmp_dc);
EndPaint(hWnd, &ps);
break;
case WM_LBUTTONDOWN:
x = GET_X_LPARAM(lParam);
y = GET_Y_LPARAM(lParam);
OGUI::OGUIManager::instance()->mouse_down(0, x, y);
break;
case WM_LBUTTONUP:
x = GET_X_LPARAM(lParam);
y = GET_Y_LPARAM(lParam);
OGUI::OGUIManager::instance()->mouse_up(0, x, y);
break;
case WM_MOUSEMOVE:
x = GET_X_LPARAM(lParam);
y = GET_Y_LPARAM(lParam);
OGUI::OGUIManager::instance()->mouse_move(x, y);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
HDC W32HandleDibDrv (PVPVOID vpbmi16)
{
HDC hdcMem = NULL;
HBITMAP hbm = NULL;
PVOID pvBits, pvIntelBits;
STACKBMI32 bmi32;
LPBITMAPINFO lpbmi32;
DWORD dwClrUsed,nSize,nAlignmentSpace;
PBITMAPINFOHEADER16 pbmi16;
INT nbmiSize,nBytesWritten;
HANDLE hfile=NULL,hsec=NULL;
ULONG RetVal,OriginalSelLimit,SelectorLimit,OriginalFlags;
PARM16 Parm16;
CHAR pchTempFile[MAX_PATH];
BOOL bRet = FALSE;
PVPVOID vpBase16 = (PVPVOID) ((ULONG) vpbmi16 & 0xffff0000);
if ((hdcMem = W32FindAndLockDibInfo((USHORT)HIWORD(vpbmi16))) != (HDC)NULL) {
return hdcMem;
}
// First create a memory device context compatible to
// the app's current screen
if ((hdcMem = CreateCompatibleDC (NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateCompatibleDC failed\n"));
return NULL;
}
// Copy bmi16 to bmi32. DIB.DRV only supports DIB_RGB_COLORS
lpbmi32 = CopyBMI16ToBMI32(
vpbmi16,
(LPBITMAPINFO)&bmi32,
(WORD) DIB_RGB_COLORS);
// this hack for Director 4.0 does essentially what WFW does
// if this bitmap is 0 sized, just return an hDC for something simple
if(bmi32.bmiHeader.biSizeImage == 0 &&
(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_DIBDRVIMAGESIZEZERO)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv:Zero biSizeImage, returning memory DC!\n"));
return hdcMem;
}
try {
// Copy the wholething into a temp file. First get a temp file name
if ((nSize = GetTempPath (MAX_PATH, pchTempFile)) == 0 ||
nSize >= MAX_PATH)
goto hdd_err;
if (GetTempFileName (pchTempFile,
"DIB",
0,
pchTempFile) == 0)
goto hdd_err;
if ((hfile = CreateFile (pchTempFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
(FILE_ATTRIBUTE_NORMAL |
FILE_ATTRIBUTE_TEMPORARY |
FILE_FLAG_DELETE_ON_CLOSE),
NULL)) == INVALID_HANDLE_VALUE) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFile failed\n"));
goto hdd_err;
}
// call back to get the size of the global object
// associated with vpbmi16
Parm16.WndProc.wParam = HIWORD(vpbmi16);
CallBack16(RET_GETDIBSIZE,
&Parm16,
0,
(PVPVOID)&SelectorLimit);
Parm16.WndProc.wParam = HIWORD(vpbmi16);
if (SelectorLimit == 0xffffffff || SelectorLimit == 0) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Invalid Selector %x\n",HIWORD(vpbmi16)));
goto hdd_err;
}
SelectorLimit++;
OriginalSelLimit = SelectorLimit;
CallBack16(RET_GETDIBFLAGS,
&Parm16,
0,
(PVPVOID)&OriginalFlags);
if (OriginalFlags == 0x4) { //GA_DGROUP
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv GA_DGROUP Not Handled\n"));
goto hdd_err;
}
GETVDMPTR(vpBase16, SelectorLimit, pbmi16);
nbmiSize = GetBMI16Size(vpbmi16, (WORD) DIB_RGB_COLORS, &dwClrUsed);
// Under NT CreateDIBSection will fail if the offset to the bits
// is not dword aligned. So we may have to add some space at the top
// of the section to get the offset correctly aligned.
nAlignmentSpace = (nbmiSize+LOWORD(vpbmi16)) % 4;
if (nAlignmentSpace) {
if (WriteFile (hfile,
pbmi16,
nAlignmentSpace,
&nBytesWritten,
NULL) == FALSE ||
nBytesWritten != (INT) nAlignmentSpace)
goto hdd_err;
}
//
// detect a clinical case of bitedit screwing around dib.drv
//
// code below is using dib macros declared in wdib.h
// namely:
// DibNumColors - yields max number of colors in dib
// DibColors - yields pointer to a dib color table
//
// Function W32CheckDibColorIndices checks to see if DIB color
// table looks like a number (defined usually by biClrImportant)
// of WORD indices in a sequential order (0, 1, 2, ...)
// if this is the case, app is trying to use undocumented feature
// of DIB.DRV that turns color matching off in this case.
// Since we cannot enforce that rule, we approximate it by filling
// color table by a number of known (and always same) entries
// When blitting occurs, no color matching will be performed (when
// both target and destination are of this very nature).
// For no reason at all we fill color table with vga colors.
// Sequential indices could have worked just as well.
//
// Modifications are made to memory pointed to by lpbmi32
if (W32CheckDibColorIndices((LPBITMAPINFOHEADER)lpbmi32)) {
INT i, nColors;
LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)lpbmi32;
LPRGBQUAD lprgbq = (LPRGBQUAD)DibColors(lpbmi);
nColors = DibNumColors(lpbmi);
lpbmi->biClrImportant = nColors;
switch (lpbmi->biBitCount) {
case 1:
lprgbq[0] = rgbVGA[0];
lprgbq[1] = rgbVGA[0x0f];
break;
case 4:
RtlCopyMemory(lprgbq, rgbVGA, sizeof(rgbVGA));
break;
case 8:
RtlCopyMemory(lprgbq, rgbVGA, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+248, rgbVGA+8, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+8, rgb4, 2*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+246, rgb4+2, 2*sizeof(RGBQUAD));
for (i = 10; i < 246; ++i) {
lprgbq[i].rgbBlue = i;
lprgbq[i].rgbGreen= 0;
lprgbq[i].rgbRed = 0;
lprgbq[i].rgbReserved = 0;
}
break;
default: // this should never happen
break;
}
}
if (WriteFile (hfile,
pbmi16,
SelectorLimit,
&nBytesWritten,
NULL) == FALSE || nBytesWritten != (INT) SelectorLimit)
goto hdd_err;
if (SelectorLimit < 64*1024) {
if (SetFilePointer (hfile,
64*1024+nAlignmentSpace,
NULL,
FILE_BEGIN) == -1)
goto hdd_err;
if (SetEndOfFile (hfile) == FALSE)
goto hdd_err;
SelectorLimit = 64*1024;
}
if ((hsec = CreateFileMapping (hfile,
NULL,
PAGE_READWRITE | SEC_COMMIT,
0,
SelectorLimit+nAlignmentSpace,
NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFileMapping Failed\n"));
goto hdd_err;
}
// Now create the DIB section
if ((hbm = CreateDIBSection (hdcMem,
lpbmi32,
DIB_RGB_COLORS,
&pvBits,
hsec,
nAlignmentSpace + LOWORD(vpbmi16) + nbmiSize
)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateDibSection Failed\n"));
goto hdd_err;
}
FREEVDMPTR(pbmi16);
if((pvBits = MapViewOfFile(hsec,
FILE_MAP_WRITE,
0,
0,
SelectorLimit+nAlignmentSpace)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv MapViewOfFile Failed\n"));
goto hdd_err;
}
pvBits = (PVOID) ((ULONG)pvBits + nAlignmentSpace);
SelectObject (hdcMem, hbm);
GdiSetBatchLimit(1);
#ifndef i386
if (!NT_SUCCESS(VdmAddVirtualMemory((ULONG)pvBits,
(ULONG)SelectorLimit,
(PULONG)&pvIntelBits))) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddVirtualMemory failed\n"));
goto hdd_err;
}
// On risc platforms, the intel base + the intel linear address
// of the DIB section is not equal to the DIB section's process
// address. This is because of the VdmAddVirtualMemory call
// above. So here we zap the correct address into the flataddress
// array.
if (!VdmAddDescriptorMapping(HIWORD(vpbmi16),
(USHORT) ((SelectorLimit+65535)/65536),
(ULONG) pvIntelBits,
(ULONG) pvBits)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddDescriptorMapping failed\n"));
goto hdd_err;
}
#else
pvIntelBits = pvBits;
#endif
// Finally set the selectors to the new DIB
Parm16.WndProc.wParam = HIWORD(vpbmi16);
Parm16.WndProc.lParam = (LONG)pvIntelBits;
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 1; // set so it's not randomly 0
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&RetVal);
if (!RetVal) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Callback set_sel_for_dib failed\n"));
goto hdd_err;
}
// Store all the relevant information so that DeleteDC could
// free all the resources later.
if (W32AddDibInfo(hdcMem,
hfile,
hsec,
nAlignmentSpace,
pvBits,
pvIntelBits,
hbm,
OriginalSelLimit,
(USHORT)OriginalFlags,
(USHORT)((HIWORD(vpbmi16)))) == FALSE)
goto hdd_err;
// Finally spit out the dump for debugging
LOGDEBUG(6,("\t\tWOW::W32HandleDibDrv hdc=%04x nAlignment=%04x\n\t\tNewDib=%x OldDib=%04x:%04x DibSize=%x DibFlags=%x\n",hdcMem,nAlignmentSpace,pvBits,HIWORD(vpbmi16),LOWORD(vpbmi16),OriginalSelLimit,(USHORT)OriginalFlags));
bRet = TRUE;
hdd_err:;
}
finally {
if (!bRet) {
if (hdcMem) {
DeleteDC (hdcMem);
hdcMem = NULL;
}
if (hfile)
CloseHandle (hfile);
if (hsec)
CloseHandle (hsec);
if (hbm)
CloseHandle (hbm);
}
}
return hdcMem;
}
static SDL_bool
WIN_GetDisplayMode(LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mode)
{
SDL_DisplayModeData *data;
DEVMODE devmode;
HDC hdc;
devmode.dmSize = sizeof(devmode);
devmode.dmDriverExtra = 0;
if (!EnumDisplaySettings(deviceName, index, &devmode)) {
return SDL_FALSE;
}
data = (SDL_DisplayModeData *) SDL_malloc(sizeof(*data));
if (!data) {
return SDL_FALSE;
}
data->DeviceMode = devmode;
data->DeviceMode.dmFields =
(DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY |
DM_DISPLAYFLAGS);
data->ScaleX = 1.0f;
data->ScaleY = 1.0f;
/* Fill in the mode information */
mode->format = SDL_PIXELFORMAT_UNKNOWN;
mode->w = devmode.dmPelsWidth;
mode->h = devmode.dmPelsHeight;
mode->refresh_rate = devmode.dmDisplayFrequency;
mode->driverdata = data;
if (index == ENUM_CURRENT_SETTINGS
&& (hdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL) {
char bmi_data[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
LPBITMAPINFO bmi;
HBITMAP hbm;
int logical_width = GetDeviceCaps( hdc, HORZRES );
int logical_height = GetDeviceCaps( hdc, VERTRES );
data->ScaleX = (float)logical_width / devmode.dmPelsWidth;
data->ScaleY = (float)logical_height / devmode.dmPelsHeight;
mode->w = logical_width;
mode->h = logical_height;
SDL_zero(bmi_data);
bmi = (LPBITMAPINFO) bmi_data;
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hbm = CreateCompatibleBitmap(hdc, 1, 1);
GetDIBits(hdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
GetDIBits(hdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
DeleteObject(hbm);
DeleteDC(hdc);
if (bmi->bmiHeader.biCompression == BI_BITFIELDS) {
switch (*(Uint32 *) bmi->bmiColors) {
case 0x00FF0000:
mode->format = SDL_PIXELFORMAT_RGB888;
break;
case 0x000000FF:
mode->format = SDL_PIXELFORMAT_BGR888;
break;
case 0xF800:
mode->format = SDL_PIXELFORMAT_RGB565;
break;
case 0x7C00:
mode->format = SDL_PIXELFORMAT_RGB555;
break;
}
} else if (bmi->bmiHeader.biBitCount == 8) {
mode->format = SDL_PIXELFORMAT_INDEX8;
} else if (bmi->bmiHeader.biBitCount == 4) {
mode->format = SDL_PIXELFORMAT_INDEX4LSB;
}
} else {
/* FIXME: Can we tell what this will be? */
if ((devmode.dmFields & DM_BITSPERPEL) == DM_BITSPERPEL) {
switch (devmode.dmBitsPerPel) {
case 32:
mode->format = SDL_PIXELFORMAT_RGB888;
break;
case 24:
mode->format = SDL_PIXELFORMAT_RGB24;
break;
case 16:
mode->format = SDL_PIXELFORMAT_RGB565;
break;
case 15:
mode->format = SDL_PIXELFORMAT_RGB555;
break;
case 8:
mode->format = SDL_PIXELFORMAT_INDEX8;
break;
case 4:
mode->format = SDL_PIXELFORMAT_INDEX4LSB;
break;
}
}
}
return SDL_TRUE;
}
HBITMAP ContextMenu::IconToBitmap(int ResourceID)
{
RECT rect;
rect.right = GetSystemMetrics(SM_CXMENUCHECK);
rect.bottom = GetSystemMetrics(SM_CYMENUCHECK);
rect.left = rect.top = 0;
HICON hIcon = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(ResourceID), IMAGE_BITMAP, rect.right, rect.bottom, LR_DEFAULTCOLOR);
if (!hIcon)
{
return NULL;
}
HWND desktop = GetDesktopWindow();
if (desktop == NULL)
{
DestroyIcon(hIcon);
return NULL;
}
HDC screen_dev = GetDC(desktop);
if (screen_dev == NULL)
{
DestroyIcon(hIcon);
return NULL;
}
// Create a compatible DC
HDC dst_hdc = CreateCompatibleDC(screen_dev);
if (dst_hdc == NULL)
{
DestroyIcon(hIcon);
ReleaseDC(desktop, screen_dev);
return NULL;
}
// Create a new bitmap of icon size
HBITMAP bmp = CreateCompatibleBitmap(screen_dev, rect.right, rect.bottom);
if (bmp == NULL)
{
DestroyIcon(hIcon);
DeleteDC(dst_hdc);
ReleaseDC(desktop, screen_dev);
return NULL;
}
// Select it into the compatible DC
HBITMAP old_dst_bmp = (HBITMAP)SelectObject(dst_hdc, bmp);
if (old_dst_bmp == NULL)
{
DestroyIcon(hIcon);
return NULL;
}
// Fill the background of the compatible DC with the given colour
SetBkColor(dst_hdc, RGB(255, 255, 255));
ExtTextOut(dst_hdc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
// Draw the icon into the compatible DC
DrawIconEx(dst_hdc, 0, 0, hIcon, rect.right, rect.bottom, 0, NULL, DI_NORMAL);
// Restore settings
SelectObject(dst_hdc, old_dst_bmp);
DeleteDC(dst_hdc);
ReleaseDC(desktop, screen_dev);
DestroyIcon(hIcon);
return bmp;
}
CDlgVDetail::~CDlgVDetail()
{
DeleteDC(m_memdcBkBmp);
DeleteObject(m_cBitmapBkBmp);
}
static LRESULT MHeaderbar_OnPaint(HWND hwndDlg, MHeaderbarCtrl *mit, UINT msg, WPARAM wParam, LPARAM lParam)
{
int iTopSpace = IsAeroMode() ? 0 : 3;
PAINTSTRUCT ps;
HBITMAP hBmp, hOldBmp;
int titleLength = GetWindowTextLength(hwndDlg) + 1;
TCHAR *szTitle = (TCHAR *)mir_alloc(sizeof(TCHAR) * titleLength);
GetWindowText(hwndDlg, szTitle, titleLength);
TCHAR *szSubTitle = _tcschr(szTitle, _T('\n'));
if (szSubTitle) *szSubTitle++=0;
HDC hdc = BeginPaint(hwndDlg, &ps);
HDC tempDC = CreateCompatibleDC(hdc);
BITMAPINFO bmi;
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = mit->width;
bmi.bmiHeader.biHeight = -mit->height; // we need this for DrawThemeTextEx
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
hBmp = CreateDIBSection(tempDC, &bmi, DIB_RGB_COLORS, NULL, NULL, 0);
hOldBmp = (HBITMAP)SelectObject(tempDC, hBmp);
if (IsAeroMode()) {
RECT temprc;
temprc.left = 0;
temprc.right = mit->width;
temprc.top = 0;
temprc.bottom = mit->width;
FillRect(tempDC, &temprc, (HBRUSH)GetStockObject(BLACK_BRUSH));
MARGINS margins = {0, 0, mit->height, 0};
dwmExtendFrameIntoClientArea(GetParent(hwndDlg), &margins);
WTA_OPTIONS opts;
opts.dwFlags = opts.dwMask = WTNCA_NODRAWCAPTION | WTNCA_NODRAWICON;
setWindowThemeAttribute(GetParent(hwndDlg), WTA_NONCLIENT, &opts, sizeof(opts));
}
else {
if (IsVSMode())
MHeaderbar_FillRect(tempDC, 0, 0, mit->width, mit->height, GetSysColor(COLOR_WINDOW));
else
MHeaderbar_DrawGradient(tempDC, 0, 0, mit->width, mit->height, &mit->rgbBkgTop, &mit->rgbBkgBottom);
MHeaderbar_FillRect(tempDC, 0, mit->height-2, mit->width, 1, GetSysColor(COLOR_BTNSHADOW));
MHeaderbar_FillRect(tempDC, 0, mit->height-1, mit->width, 1, GetSysColor(COLOR_BTNHIGHLIGHT));
}
HFONT hFont = mit->hFont;
SetBkMode(tempDC, TRANSPARENT);
SetTextColor(tempDC, mit->clText);
LOGFONT lf;
GetObject(hFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
HFONT hFntBold = CreateFontIndirect(&lf), hOldFont;
if (mit->hIcon)
DrawIcon(tempDC, 10, iTopSpace, mit->hIcon);
else {
HICON hIcon = (HICON)SendMessage(GetParent(hwndDlg), WM_GETICON, ICON_BIG, 0);
if (hIcon == NULL)
hIcon = (HICON)SendMessage(GetParent(hwndDlg), WM_GETICON, ICON_SMALL, 0);
DrawIcon(tempDC, 10, iTopSpace, hIcon);
}
RECT textRect;
textRect.left = 50;
textRect.right = mit->width;
textRect.top = 2 + iTopSpace;
textRect.bottom = GetSystemMetrics(SM_CYICON)-2 + iTopSpace;
if (IsAeroMode()) {
DTTOPTS dto = {0};
dto.dwSize = sizeof(dto);
dto.dwFlags = DTT_COMPOSITED|DTT_GLOWSIZE;
dto.iGlowSize = 10;
HANDLE hTheme = OpenThemeData(hwndDlg, L"Window");
textRect.left = 50;
hOldFont = (HFONT)SelectObject(tempDC, hFntBold);
wchar_t *szTitleW = mir_t2u(szTitle);
drawThemeTextEx(hTheme, tempDC, WP_CAPTION, CS_ACTIVE, szTitleW, -1, DT_TOP|DT_LEFT|DT_SINGLELINE|DT_NOPREFIX|DT_NOCLIP|DT_END_ELLIPSIS, &textRect, &dto);
mir_free(szTitleW);
if (szSubTitle) {
textRect.left = 66;
SelectObject(tempDC, hFont);
wchar_t *szSubTitleW = mir_t2u(szSubTitle);
drawThemeTextEx(hTheme, tempDC, WP_CAPTION, CS_ACTIVE, szSubTitleW, -1, DT_BOTTOM|DT_LEFT|DT_SINGLELINE|DT_NOPREFIX|DT_NOCLIP|DT_END_ELLIPSIS, &textRect, &dto);
mir_free(szSubTitleW);
}
CloseThemeData(hTheme);
}
else {
textRect.left = 50;
hOldFont = (HFONT)SelectObject(tempDC, hFntBold);
DrawText(tempDC, szTitle, -1, &textRect, DT_TOP|DT_LEFT|DT_SINGLELINE|DT_NOPREFIX|DT_NOCLIP|DT_END_ELLIPSIS);
if (szSubTitle) {
textRect.left = 66;
SelectObject(tempDC, hFont);
DrawText(tempDC, szSubTitle, -1, &textRect, DT_BOTTOM|DT_LEFT|DT_SINGLELINE|DT_NOPREFIX|DT_NOCLIP|DT_END_ELLIPSIS);
}
}
DeleteObject(hFntBold);
mir_free(szTitle);
//Copy to output
if (mit->nControlsToRedraw)
{
RECT temprc;
temprc.left = 0;
temprc.right = mit->width;
temprc.top = 0;
temprc.bottom = mit->width;
HRGN hRgn = CreateRectRgnIndirect(&temprc);
for (int i=0; i < mit->nControlsToRedraw; i++)
{
GetWindowRect(mit->controlsToRedraw[i], &temprc);
MapWindowPoints(NULL, hwndDlg, (LPPOINT)&temprc, 2);
HRGN hRgnTmp = CreateRectRgnIndirect(&temprc);
CombineRgn(hRgn, hRgn, hRgnTmp, RGN_DIFF);
DeleteObject(hRgnTmp);
}
SelectClipRgn(hdc, hRgn);
DeleteObject(hRgn);
}
BitBlt(hdc, mit->rc.left, mit->rc.top, mit->width, mit->height, tempDC, 0, 0, SRCCOPY);
SelectClipRgn(hdc, NULL);
SelectObject(tempDC, hOldBmp);
DeleteObject(hBmp);
SelectObject(tempDC,hOldFont);
DeleteDC(tempDC);
EndPaint(hwndDlg, &ps);
return TRUE;
}
void CDlgVDetail::OnPaint()
{
CPaintDC dc(this); // device context for painting
// TODO: 在此处添加消息处理程序代码
// 不为绘图消息调用 CDialog::OnPaint()
CDC *pDC = this->GetDC();
if (m_memdcBkBmp.m_hDC != NULL)
{
CRect rect;
CDC memDC;
GetWindowRect(&rect);
memDC.CreateCompatibleDC(pDC);
CBitmap* pOldMemBmp = NULL;
pOldMemBmp = memDC.SelectObject(&m_cBitmapBkBmp);
memDC.BitBlt(0,0,rect.Width(),rect.Height(),&m_memdcBkBmp,0,0,SRCCOPY);
memDC.SetBkMode(TRANSPARENT);
//CFont fontText;
//VERIFY(fontText.CreateFont(
// 43, // nHeight
// 0, // nWidth
// 0, // nEscapement
// 0, // nOrientation
// FW_BOLD, //FW_NORMAL,加粗 // nWeight
// FALSE, // bItalic
// FALSE, // bUnderline
// 0, // cStrikeOut
// ANSI_CHARSET, // nCharSet
// OUT_DEFAULT_PRECIS, // nOutPrecision
// CLIP_DEFAULT_PRECIS, // nClipPrecision
// DEFAULT_QUALITY, // nQuality
// DEFAULT_PITCH | FF_SWISS, // nPitchAndFamily
// _T("Arial Rounded MT"))); // lpszFacename
//CRect rc;
//m_staticTime.GetWindowRect(&rc);
//ScreenToClient(&rc);
//DWORD dwStyle = m_staticTime.GetStyle();
//int nDTFlags = 0;
//if((dwStyle & SS_NOPREFIX) != 0)
//{
// nDTFlags |= DT_NOPREFIX;
//}
//if((dwStyle & SS_CENTER) != 0)
//{
// nDTFlags |= DT_CENTER;
//}
//else if((dwStyle & SS_RIGHT) != 0)
//{
// nDTFlags |= DT_RIGHT;
//}
//else
//{
// nDTFlags |= DT_LEFT;
//}
//if((dwStyle & SS_LEFTNOWORDWRAP) != 0)
//{
// nDTFlags |= DT_SINGLELINE;
//}
//else
//{
// nDTFlags |= DT_WORDBREAK;
//}
//memDC.SelectObject(&fontText);
//fontText.DeleteObject();
//memDC.SetTextColor(RGB(255,255,255)); //设置字体颜色白色
//memDC.DrawText(strTime, -1, &rc, nDTFlags);
//memDC.SetTextColor(RGB(249,223,4));
//m_staticSS.GetWindowRect(&rc);
//ScreenToClient(&rc);
//memDC.DrawText(m_strSS, -1, &rc, nDTFlags);
//将背景位图复制到窗口客户区
pDC-> BitBlt(0,0,rect.Width(),rect.Height(),&memDC,0,0,SRCCOPY);
if(pOldMemBmp)
memDC.SelectObject(pOldMemBmp);
DeleteObject(pOldMemBmp);
DeleteDC(memDC);
ReleaseDC(pDC);
}
}
static LRESULT MDescButton_OnPaint(HWND hwndDlg, MDescButtonCtrl *dat)
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwndDlg, &ps);
HDC tempDC = CreateCompatibleDC(hdc);
SIZE titleSize = { 0 };
HBITMAP hBmp = CreateCompatibleBitmap(hdc, dat->width, dat->height);
HBITMAP hOldBmp = (HBITMAP)SelectObject(tempDC, hBmp);
RECT temprc;
temprc.left = 0;
temprc.right = dat->width;
temprc.top = 0;
// Draw background
if (dat->bMouseInside || (GetFocus() == hwndDlg)) {
MDescButton_FillRect(tempDC, 0, 0, dat->width, dat->height, dat->clSelBorder);
MDescButton_DrawGradient(tempDC, 1, 1, dat->width - 2, dat->height - 2, &dat->rgbSelTop, &dat->rgbSelBottom);
SetTextColor(tempDC, dat->clSelText);
}
else {
MDescButton_FillRect(tempDC, 0, 0, dat->width, dat->height, dat->clBackground);
SetTextColor(tempDC, dat->clText);
}
if (dat->hIcon)
DrawIcon(tempDC, DBC_BORDER_SIZE, DBC_BORDER_SIZE, dat->hIcon);
HFONT hfntSave = (HFONT)SelectObject(tempDC, dat->hFont);
SetBkMode(tempDC, TRANSPARENT);
if (dat->lpzTitle) {
LOGFONT lf;
GetObject(dat->hFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
lf.lfHeight *= 1.5;
HFONT hOldFont = (HFONT)SelectObject(tempDC, CreateFontIndirect(&lf));
RECT textRect;
textRect.left = DBC_BORDER_SIZE + (dat->hIcon ? 32 + DBC_VSPACING : 0);
textRect.right = dat->width - DBC_BORDER_SIZE;
textRect.top = DBC_BORDER_SIZE;
textRect.bottom = dat->height - DBC_BORDER_SIZE;
DrawText(tempDC, dat->lpzTitle, -1, &textRect, DT_TOP | DT_LEFT | DT_END_ELLIPSIS);
GetTextExtentPoint32(tempDC, dat->lpzTitle, (int)mir_tstrlen(dat->lpzTitle), &titleSize);
DeleteObject(SelectObject(tempDC, hOldFont));
}
if (dat->lpzDescription) {
RECT textRect;
textRect.left = DBC_BORDER_SIZE + (dat->hIcon ? 32 + DBC_VSPACING : 0);
textRect.right = dat->width - DBC_BORDER_SIZE;
textRect.top = DBC_BORDER_SIZE + titleSize.cy ? titleSize.cy + DBC_HSPACING : 0;
textRect.bottom = dat->height - DBC_BORDER_SIZE;
DrawText(tempDC, dat->lpzDescription, -1, &textRect, DT_TOP | DT_LEFT | DT_WORDBREAK | DT_END_ELLIPSIS);
GetTextExtentPoint32(tempDC, dat->lpzTitle, (int)mir_tstrlen(dat->lpzTitle), &titleSize);
}
SelectObject(tempDC, hfntSave);
//Copy to output
BitBlt(hdc, dat->rc.left, dat->rc.top, dat->width, dat->height, tempDC, 0, 0, SRCCOPY);
SelectObject(tempDC, hOldBmp);
DeleteObject(hBmp);
DeleteDC(tempDC);
EndPaint(hwndDlg, &ps);
return TRUE;
}
HBITMAP FAR CopyScreenToBitmap(LPRECT lpRect)
{
HDC hScrDC, hMemDC; // screen DC and memory DC
HBITMAP hBitmap, hOldBitmap; // handles to deice-dependent bitmaps
int nX, nY, nX2, nY2; // coordinates of rectangle to grab
int nWidth, nHeight; // DIB width and height
int xScrn, yScrn; // screen resolution
/* check for an empty rectangle */
if (IsRectEmpty(lpRect))
return NULL;
/* create a DC for the screen and create
* a memory DC compatible to screen DC
*/
hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
hMemDC = CreateCompatibleDC(hScrDC);
/* get points of rectangle to grab */
nX = lpRect->left;
nY = lpRect->top;
nX2 = lpRect->right;
nY2 = lpRect->bottom;
/* get screen resolution */
xScrn = GetDeviceCaps(hScrDC, HORZRES);
yScrn = GetDeviceCaps(hScrDC, VERTRES);
/* make sure bitmap rectangle is visible */
if (nX < 0)
nX = 0;
if (nY < 0)
nY = 0;
if (nX2 > xScrn)
nX2 = xScrn;
if (nY2 > yScrn)
nY2 = yScrn;
nWidth = nX2 - nX;
nHeight = nY2 - nY;
/* create a bitmap compatible with the screen DC */
hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
/* select new bitmap into memory DC */
hOldBitmap = SelectObject(hMemDC, hBitmap);
/* bitblt screen DC to memory DC */
BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
/* select old bitmap back into memory DC and get handle to
* bitmap of the screen
*/
hBitmap = SelectObject(hMemDC, hOldBitmap);
/* clean up */
DeleteDC(hScrDC);
DeleteDC(hMemDC);
/* return handle to the bitmap */
return hBitmap;
}
//*增加的函数
//考贝屏幕
HBITMAP CCatchScreenDlg::CopyScreenToBitmap(LPRECT lpRect, BOOL bSave)
//lpRect 代表选定区域
{
HDC hScrDC, hMemDC;
// 屏幕和内存设备描述表
HBITMAP hBitmap, hOldBitmap;
// 位图句柄
int nX, nY, nX2, nY2;
// 选定区域坐标
int nWidth, nHeight;
// 确保选定区域不为空矩形
if (IsRectEmpty(lpRect))
return NULL;
//为屏幕创建设备描述表
hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
//为屏幕设备描述表创建兼容的内存设备描述表
hMemDC = CreateCompatibleDC(hScrDC);
// 获得选定区域坐标
nX = lpRect->left;
nY = lpRect->top;
nX2 = lpRect->right;
nY2 = lpRect->bottom;
//确保选定区域是可见的
if (nX < 0)
nX = 0;
if (nY < 0)
nY = 0;
if (nX2 > m_nCXScreen)
nX2 = m_nCXScreen;
if (nY2 > m_nCYScreen)
nY2 = m_nCYScreen;
nWidth = nX2 - nX;
nHeight = nY2 - nY;
// 创建一个与屏幕设备描述表兼容的位图
hBitmap = CreateCompatibleBitmap
(hScrDC, nWidth, nHeight);
// 把新位图选到内存设备描述表中
hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap);
// 把屏幕设备描述表拷贝到内存设备描述表中
if(bSave)
{
CDC dcCompatible;
dcCompatible.CreateCompatibleDC(CDC::FromHandle(hMemDC));
dcCompatible.SelectObject(m_BackgroundBitmap);
BitBlt(hMemDC, 0, 0, nWidth, nHeight,
dcCompatible, nX, nY, SRCCOPY);
}
else
{
BitBlt(hMemDC, 0, 0, nWidth, nHeight,
hScrDC, nX, nY, SRCCOPY);
}
hBitmap = (HBITMAP)SelectObject(hMemDC, hOldBitmap);
//得到屏幕位图的句柄
//清除
DeleteDC(hScrDC);
DeleteDC(hMemDC);
// 返回位图句柄
if(bSave)
{
if (OpenClipboard())
{
//清空剪贴板
EmptyClipboard();
//把屏幕内容粘贴到剪贴板上,
//hBitmap 为刚才的屏幕位图句柄
SetClipboardData(CF_BITMAP, hBitmap);
//关闭剪贴板
CloseClipboard();
}
}
return hBitmap;
}
BOOL FAR PaintBitmap(HDC hDC,
LPRECT lpDCRect,
HBITMAP hDDB,
LPRECT lpDDBRect,
HPALETTE hPal)
{
HDC hMemDC; // Handle to memory DC
HBITMAP hOldBitmap; // Handle to previous bitmap
HPALETTE hOldPal1 = NULL; // Handle to previous palette
HPALETTE hOldPal2 = NULL; // Handle to previous palette
BOOL bSuccess = FALSE; // Success/fail flag
/* Create a memory DC */
hMemDC = CreateCompatibleDC (hDC);
/* If this failed, return FALSE */
if (!hMemDC)
return FALSE;
/* If we have a palette, select and realize it */
if (hPal)
{
hOldPal1 = SelectPalette(hMemDC, hPal, TRUE);
hOldPal2 = SelectPalette(hDC, hPal, TRUE);
RealizePalette(hDC);
}
/* Select bitmap into the memory DC */
hOldBitmap = SelectObject (hMemDC, hDDB);
/* Make sure to use the stretching mode best for color pictures */
SetStretchBltMode (hDC, COLORONCOLOR);
/* Determine whether to call StretchBlt() or BitBlt() */
if ((RECTWIDTH(lpDCRect) == RECTWIDTH(lpDDBRect)) &&
(RECTHEIGHT(lpDCRect) == RECTHEIGHT(lpDDBRect)))
bSuccess = BitBlt(hDC,
lpDCRect->left,
lpDCRect->top,
lpDCRect->right - lpDCRect->left,
lpDCRect->bottom - lpDCRect->top,
hMemDC,
lpDDBRect->left,
lpDDBRect->top,
SRCCOPY);
else
bSuccess = StretchBlt(hDC,
lpDCRect->left,
lpDCRect->top,
lpDCRect->right - lpDCRect->left,
lpDCRect->bottom - lpDCRect->top,
hMemDC,
lpDDBRect->left,
lpDDBRect->top,
lpDDBRect->right - lpDDBRect->left,
lpDDBRect->bottom - lpDDBRect->top,
SRCCOPY);
/* Clean up */
SelectObject(hMemDC, hOldBitmap);
if (hOldPal1)
SelectPalette (hMemDC, hOldPal1, FALSE);
if (hOldPal2)
SelectPalette (hDC, hOldPal2, FALSE);
DeleteDC (hMemDC);
/* Return with success/fail flag */
return bSuccess;
}
INT_PTR TlevelsPage::msgProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_DESTROY:
SelectObject(hdcGradient, oldHDCgradient);
DeleteDC(hdcGradient);
DeleteBitmap(bmpGradient);
DeleteFont(fontGradient);
SendMessage(GetDlgItem(m_hwnd, IDC_LBX_LEVELS_CURVES), WM_SETFONT, NULL, FALSE);
DeleteFont(fontCurier);
break;
case WM_DRAWITEM:
switch (wParam) {
case IDC_BMP_HISTOGRAM: {
LPDRAWITEMSTRUCT dis = LPDRAWITEMSTRUCT(lParam);
int full = cfgGet(IDFF_levelsFullY);
StretchDIBits(dis->hDC, 0, 0, dis->rcItem.right, dis->rcItem.bottom, full ? 0 : 16, 0, full ? 256 : 234 - 16 + 1, 64, histogramBits, (BITMAPINFO*)&histogramBmp, DIB_RGB_COLORS, SRCCOPY);
wIn->draw(dis);
return TRUE;
}
case IDC_BMP_LEVELS_IN: {
LPDRAWITEMSTRUCT dis = LPDRAWITEMSTRUCT(lParam);
StretchBlt(dis->hDC, 0, 0, dis->rcItem.right, 10, hdcGradient, 0, 0, 256, 1, SRCCOPY);
RECT r = dis->rcItem;
r.top = 10;
FillRect(dis->hDC, &r, GetSysColorBrush(COLOR_BTNFACE));
if (filter && getCheck(IDC_CHB_LEVELS_INPUT_AUTO)) {
int min, max;
filter->getInAuto(&min, &max);
drawTriangle(dis, min, true);
drawTriangle(dis, max, true);
}
drawTriangle(dis, cfgGet(IDFF_levelsInMin));
drawTriangle(dis, cfgGet(IDFF_levelsInMax));
return TRUE;
}
case IDC_BMP_LEVELS_OUT: {
LPDRAWITEMSTRUCT dis = LPDRAWITEMSTRUCT(lParam);
StretchBlt(dis->hDC, 0, 0, dis->rcItem.right, 10, hdcGradient, 0, 0, 256, 1, SRCCOPY);
RECT r = dis->rcItem;
r.top = 10;
FillRect(dis->hDC, &r, GetSysColorBrush(COLOR_BTNFACE));
drawTriangle(dis, cfgGet(IDFF_levelsOutMin));
drawTriangle(dis, cfgGet(IDFF_levelsOutMax));
return TRUE;
}
case IDC_BMP_LEVELS_CURVES: {
LPDRAWITEMSTRUCT dis = LPDRAWITEMSTRUCT(lParam);
StretchDIBits(dis->hDC, 0, 0, dis->rcItem.right, dis->rcItem.bottom, 0, 0, 256, 256, histogramBits, (BITMAPINFO*)&curvesBmp, DIB_RGB_COLORS, SRCCOPY);
wCurves->draw(dis);
return TRUE;
}
}
break;
case WM_SETCURSOR:
if (HWND(wParam) == hcurves) {
if (wCurves->setCursor()) {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
setDlgResult(TRUE);
}
return TRUE;
}
break;
}
return TconfPageDecVideo::msgProc(uMsg, wParam, lParam);
}
HICON _al_win_create_icon(HWND wnd,
ALLEGRO_BITMAP *sprite, int xfocus, int yfocus, bool is_cursor)
{
int x, y;
int sys_sm_cx, sys_sm_cy;
HDC h_dc;
HDC h_and_dc;
HDC h_xor_dc;
ICONINFO iconinfo;
HBITMAP and_mask;
HBITMAP xor_mask;
HBITMAP hOldAndMaskBitmap;
HBITMAP hOldXorMaskBitmap;
HICON icon;
if (is_cursor) {
/* Get allowed cursor size - Windows can't make cursors of arbitrary size */
sys_sm_cx = GetSystemMetrics(SM_CXCURSOR);
sys_sm_cy = GetSystemMetrics(SM_CYCURSOR);
}
else {
sys_sm_cx = GetSystemMetrics(SM_CXICON);
sys_sm_cy = GetSystemMetrics(SM_CYICON);
}
if ((sprite->w > sys_sm_cx) || (sprite->h > sys_sm_cy)) {
return NULL;
}
/* Create bitmap */
h_dc = GetDC(wnd);
h_xor_dc = CreateCompatibleDC(h_dc);
h_and_dc = CreateCompatibleDC(h_dc);
/* Prepare AND (monochrome) and XOR (colour) mask */
and_mask = CreateBitmap(sys_sm_cx, sys_sm_cy, 1, 1, NULL);
xor_mask = CreateCompatibleBitmap(h_dc, sys_sm_cx, sys_sm_cy);
hOldAndMaskBitmap = (HBITMAP) SelectObject(h_and_dc, and_mask);
hOldXorMaskBitmap = (HBITMAP) SelectObject(h_xor_dc, xor_mask);
/* Create transparent cursor */
for (y = 0; y < sys_sm_cy; y++) {
for (x = 0; x < sys_sm_cx; x++) {
SetPixel(h_and_dc, x, y, WINDOWS_RGB(255, 255, 255));
SetPixel(h_xor_dc, x, y, WINDOWS_RGB(0, 0, 0));
}
}
local_draw_to_hdc(h_xor_dc, sprite, 0, 0);
/* Make cursor background transparent */
for (y = 0; y < sprite->h; y++) {
for (x = 0; x < sprite->w; x++) {
ALLEGRO_COLOR c;
unsigned char r, g, b, a;
c = al_get_pixel(sprite, x, y);
al_unmap_rgba(c, &r, &g, &b, &a);
if (a != 0) {
/* Don't touch XOR value */
SetPixel(h_and_dc, x, y, 0);
}
else {
/* No need to touch AND value */
SetPixel(h_xor_dc, x, y, WINDOWS_RGB(0, 0, 0));
}
}
}
SelectObject(h_and_dc, hOldAndMaskBitmap);
SelectObject(h_xor_dc, hOldXorMaskBitmap);
DeleteDC(h_and_dc);
DeleteDC(h_xor_dc);
ReleaseDC(wnd, h_dc);
iconinfo.fIcon = is_cursor ? false : true;
iconinfo.xHotspot = xfocus;
iconinfo.yHotspot = yfocus;
iconinfo.hbmMask = and_mask;
iconinfo.hbmColor = xor_mask;
icon = CreateIconIndirect(&iconinfo);
DeleteObject(and_mask);
DeleteObject(xor_mask);
return icon;
}
static void drawbmp(fz_context *ctx, fz_document *doc, fz_page *page, fz_display_list *list, int pagenum, fz_cookie *cookie)
{
float zoom;
fz_matrix ctm;
fz_irect ibounds;
fz_rect bounds, tbounds;
int w, h;
fz_device *dev;
HDC dc, dc_main;
RECT rc;
HBRUSH bg_brush;
HBITMAP hbmp;
BITMAPINFO bmi = { 0 };
int bmp_data_len;
unsigned char *bmp_data;
int as_tga = !strstr(output, ".bmp");
fz_bound_page(doc, page, &bounds);
zoom = resolution / 72;
fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
tbounds = bounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
w = width;
h = height;
if (res_specified)
{
fz_round_rect(&ibounds, &tbounds);
if (w && ibounds.x1 - ibounds.x0 <= w)
w = 0;
if (h && ibounds.y1 - ibounds.y0 <= h)
h = 0;
}
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
if (w == 0)
scalex = fit ? 1.0f : scaley;
if (h == 0)
scaley = fit ? 1.0f : scalex;
if (!fit)
scalex = scaley = min(scalex, scaley);
fz_concat(&ctm, &ctm, fz_scale(&scale_mat, scalex, scaley));
tbounds = bounds;
fz_transform_rect(&tbounds, &ctm);
}
fz_round_rect(&ibounds, &tbounds);
fz_rect_from_irect(&tbounds, &ibounds);
w = ibounds.x1 - ibounds.x0;
h = ibounds.y1 - ibounds.y0;
dc_main = GetDC(NULL);
dc = CreateCompatibleDC(dc_main);
hbmp = CreateCompatibleBitmap(dc_main, w, h);
DeleteObject(SelectObject(dc, hbmp));
SetRect(&rc, 0, 0, w, h);
bg_brush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
FillRect(dc, &rc, bg_brush);
DeleteObject(bg_brush);
dev = fz_new_gdiplus_device(ctx, dc, &tbounds);
if (list)
fz_run_display_list(list, dev, &ctm, &tbounds, cookie);
else
fz_run_page(doc, page, dev, &ctm, cookie);
fz_free_device(dev);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = as_tga ? -h : h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = as_tga ? 32 : 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmp_data_len = as_tga ? w * h * 4 : ((w * 3 + 3) / 4) * 4 * h;
bmp_data = fz_malloc(ctx, bmp_data_len);
if (!GetDIBits(dc, hbmp, 0, h, bmp_data, &bmi, DIB_RGB_COLORS))
fz_throw(ctx, "cannot draw page %d in PDF file '%s'", pagenum, filename);
DeleteDC(dc);
ReleaseDC(NULL, dc_main);
DeleteObject(hbmp);
if (output)
{
char buf[512];
FILE *f;
sprintf(buf, output, pagenum);
f = fopen(buf, "wb");
if (!f)
fz_throw(ctx, "could not create raster file '%s'", buf);
if (as_tga)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr, w, h, bmp_data);
fz_write_tga(ctx, pix, buf, 0);
fz_drop_pixmap(ctx, pix);
}
else
{
BITMAPFILEHEADER bmpfh = { 0 };
static const int one = 1;
if (!*(char *)&one)
fz_throw(ctx, "rendering to BMP is not supported on big-endian architectures");
bmpfh.bfType = MAKEWORD('B', 'M');
bmpfh.bfOffBits = sizeof(bmpfh) + sizeof(bmi);
bmpfh.bfSize = bmpfh.bfOffBits + bmp_data_len;
fwrite(&bmpfh, sizeof(bmpfh), 1, f);
fwrite(&bmi, sizeof(bmi), 1, f);
fwrite(bmp_data, 1, bmp_data_len, f);
}
fclose(f);
}
if (showmd5)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr, bmp_data_len / 4 / h, h, bmp_data);
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
fz_drop_pixmap(ctx, pix);
}
fz_free(ctx, bmp_data);
}
static void PaintWorker(MButtonCtrl *ctl, HDC hdcPaint)
{
if (hdcPaint) {
HDC hdcMem;
HBITMAP hbmMem;
HBITMAP hbmOld = 0;
RECT rcClient;
HFONT hOldFont = 0;
int xOffset = 0;
GetClientRect(ctl->hwnd, &rcClient);
hdcMem = CreateCompatibleDC(hdcPaint);
hbmMem = CreateCompatibleBitmap(hdcPaint, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
hbmOld = reinterpret_cast<HBITMAP>(SelectObject(hdcMem, hbmMem));
hOldFont = reinterpret_cast<HFONT>(SelectObject(hdcMem, ctl->hFont));
// If its a push button, check to see if it should stay pressed
if (ctl->pushBtn && ctl->pbState)
ctl->stateId = PBS_PRESSED;
// Draw the flat button
if (ctl->flatBtn) {
if (ctl->hThemeToolbar && ctl->bThemed) {
RECT rc = rcClient;
int state = IsWindowEnabled(ctl->hwnd) ? (ctl->stateId == PBS_NORMAL && ctl->defbutton ? PBS_DEFAULTED : ctl->stateId) : PBS_DISABLED;
SkinDrawBg(ctl->hwnd, hdcMem);
if (API::pfnIsThemeBackgroundPartiallyTransparent(ctl->hThemeToolbar, TP_BUTTON, TBStateConvert2Flat(state))) {
API::pfnDrawThemeParentBackground(ctl->hwnd, hdcMem, &rc);
}
API::pfnDrawThemeBackground(ctl->hThemeToolbar, hdcMem, TP_BUTTON, TBStateConvert2Flat(state), &rc, &rc);
} else {
HBRUSH hbr;
RECT rc = rcClient;
if(ctl->buttonItem) {
RECT rcParent;
POINT pt;
HWND hwndParent = pcli->hwndContactList;
ImageItem *imgItem = ctl->stateId == PBS_HOT ? ctl->buttonItem->imgHover : (ctl->stateId == PBS_PRESSED ? ctl->buttonItem->imgPressed : ctl->buttonItem->imgNormal);
LONG *glyphMetrics = ctl->stateId == PBS_HOT ? ctl->buttonItem->hoverGlyphMetrics : (ctl->stateId == PBS_PRESSED ? ctl->buttonItem->pressedGlyphMetrics : ctl->buttonItem->normalGlyphMetrics);
//if(ctl->stateId == PBS_HOT && glyphMetrics[2] <= 1 && glyphMetrics[3] <= 1)
// glyphMetrics = ctl->lastGlyphMetrics;
GetWindowRect(ctl->hwnd, &rcParent);
pt.x = rcParent.left;
pt.y = rcParent.top;
ScreenToClient(pcli->hwndContactList, &pt);
BitBlt(hdcMem, 0, 0, rc.right, rc.bottom, cfg::dat.hdcBg, pt.x, pt.y, SRCCOPY);
if(imgItem)
DrawAlpha(hdcMem, &rc, 0, 0, 0, 0, 0, 0, 0, imgItem);
if(g_glyphItem) {
API::pfnAlphaBlend(hdcMem, (rc.right - glyphMetrics[2]) / 2, (rc.bottom - glyphMetrics[3]) / 2,
glyphMetrics[2], glyphMetrics[3], g_glyphItem->hdc,
glyphMetrics[0], glyphMetrics[1], glyphMetrics[2],
glyphMetrics[3], g_glyphItem->bf);
//CopyMemory(ctl->lastGlyphMetrics, glyphMetrics, 4 * sizeof(LONG));
}
}
else if(ctl->bSkinned) { // skinned
RECT rcParent;
POINT pt;
HWND hwndParent = pcli->hwndContactList;
StatusItems_t *item;
int item_id;
GetWindowRect(ctl->hwnd, &rcParent);
pt.x = rcParent.left;
pt.y = rcParent.top;
ScreenToClient(pcli->hwndContactList, &pt);
if(HIWORD(ctl->bSkinned))
item_id = ctl->stateId == PBS_HOT ? ID_EXTBKTBBUTTONMOUSEOVER : (ctl->stateId == PBS_PRESSED ? ID_EXTBKTBBUTTONSPRESSED : ID_EXTBKTBBUTTONSNPRESSED);
//GetItemByStatus(ctl->stateId == PBS_HOT ? ID_EXTBKBUTTONSMOUSEOVER : (ctl->stateId == PBS_PRESSED ? ID_EXTBKTBBUTTONSPRESSED : ID_EXTBKTBBUTTONSNPRESSED), &item);
else
item_id = ctl->stateId == PBS_HOT ? ID_EXTBKBUTTONSMOUSEOVER : (ctl->stateId == PBS_PRESSED ? ID_EXTBKBUTTONSPRESSED : ID_EXTBKBUTTONSNPRESSED);
item = &StatusItems[item_id - ID_STATUS_OFFLINE];
//GetItemByStatus(ctl->stateId == PBS_PRESSED ? ID_EXTBKBUTTONSPRESSED : ID_EXTBKBUTTONSNPRESSED, &item);
SetTextColor(hdcMem, item->TEXTCOLOR);
if(item->IGNORED) {
if(pt.y < 10 || cfg::dat.bWallpaperMode)
//SkinDrawBg(ctl->hwnd, hdcMem);
BitBlt(hdcMem, 0, 0, rc.right, rc.bottom, cfg::dat.hdcBg, pt.x, pt.y, SRCCOPY);
else
FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));
}
else {
if(pt.y < 10 || cfg::dat.bWallpaperMode)
//SkinDrawBg(ctl->hwnd, hdcMem);
BitBlt(hdcMem, 0, 0, rc.right, rc.bottom, cfg::dat.hdcBg, pt.x, pt.y, SRCCOPY);
else
FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));
rc.top += item->MARGIN_TOP; rc.bottom -= item->MARGIN_BOTTOM;
rc.left += item->MARGIN_LEFT; rc.right -= item->MARGIN_RIGHT;
DrawAlpha(hdcMem, &rc, item->COLOR, item->ALPHA, item->COLOR2, item->COLOR2_TRANSPARENT, item->GRADIENT,
item->CORNER, item->BORDERSTYLE, item->imageItem);
}
}
else {
if (ctl->stateId == PBS_PRESSED || ctl->stateId == PBS_HOT)
hbr = GetSysColorBrush(COLOR_3DFACE);
else {
HDC dc;
HWND hwndParent;
hwndParent = GetParent(ctl->hwnd);
dc = GetDC(hwndParent);
hbr = (HBRUSH) SendMessage(hwndParent, WM_CTLCOLORDLG, (WPARAM) dc, (LPARAM) hwndParent);
ReleaseDC(hwndParent, dc);
}
if (hbr) {
FillRect(hdcMem, &rc, hbr);
DeleteObject(hbr);
}
}
if(!ctl->bSkinned && ctl->buttonItem == 0) {
if (ctl->stateId == PBS_HOT || ctl->focus) {
if (ctl->pbState)
DrawEdge(hdcMem, &rc, EDGE_ETCHED, BF_RECT | BF_SOFT);
else
DrawEdge(hdcMem, &rc, BDR_RAISEDOUTER, BF_RECT | BF_SOFT);
} else if (ctl->stateId == PBS_PRESSED)
DrawEdge(hdcMem, &rc, BDR_SUNKENOUTER, BF_RECT | BF_SOFT);
}
}
} else {
// Draw background/border
if (ctl->hThemeButton && ctl->bThemed) {
int state = IsWindowEnabled(ctl->hwnd) ? (ctl->stateId == PBS_NORMAL && ctl->defbutton ? PBS_DEFAULTED : ctl->stateId) : PBS_DISABLED;
POINT pt;
RECT rcParent;
GetWindowRect(ctl->hwnd, &rcParent);
pt.x = rcParent.left;
pt.y = rcParent.top;
ScreenToClient(pcli->hwndContactList, &pt);
BitBlt(hdcMem, 0, 0, rcClient.right, rcClient.bottom, cfg::dat.hdcBg, pt.x, pt.y, SRCCOPY);
if (API::pfnIsThemeBackgroundPartiallyTransparent(ctl->hThemeButton, BP_PUSHBUTTON, state)) {
API::pfnDrawThemeParentBackground(ctl->hwnd, hdcMem, &rcClient);
}
API::pfnDrawThemeBackground(ctl->hThemeButton, hdcMem, BP_PUSHBUTTON, state, &rcClient, &rcClient);
} else {
UINT uState = DFCS_BUTTONPUSH | ((ctl->stateId == PBS_HOT) ? DFCS_HOT : 0) | ((ctl->stateId == PBS_PRESSED) ? DFCS_PUSHED : 0);
if (ctl->defbutton && ctl->stateId == PBS_NORMAL)
uState |= DLGC_DEFPUSHBUTTON;
DrawFrameControl(hdcMem, &rcClient, DFC_BUTTON, uState);
}
// Draw focus rectangle if button has focus
if (ctl->focus) {
RECT focusRect = rcClient;
InflateRect(&focusRect, -3, -3);
DrawFocusRect(hdcMem, &focusRect);
}
}
// If we have an icon or a bitmap, ignore text and only draw the image on the button
if (ctl->hIcon || ctl->hIconPrivate || ctl->iIcon) {
int ix = (rcClient.right - rcClient.left) / 2 - (g_cxsmIcon / 2);
int iy = (rcClient.bottom - rcClient.top) / 2 - (g_cxsmIcon / 2);
HICON hIconNew = ctl->hIconPrivate != 0 ? ctl->hIconPrivate : ctl->hIcon;
if (lstrlen(ctl->szText) == 0) {
if (ctl->iIcon)
ImageList_DrawEx(ctl->hIml, ctl->iIcon, hdcMem, ix, iy, g_cxsmIcon, g_cysmIcon, CLR_NONE, CLR_NONE, ILD_NORMAL);
else
DrawState(hdcMem, NULL, NULL, (LPARAM) hIconNew, 0, ix, iy, g_cxsmIcon, g_cysmIcon, IsWindowEnabled(ctl->hwnd) ? DST_ICON | DSS_NORMAL : DST_ICON | DSS_DISABLED);
ctl->sLabel.cx = ctl->sLabel.cy = 0;
} else {
GetTextExtentPoint32(hdcMem, ctl->szText, lstrlen(ctl->szText), &ctl->sLabel);
if(g_cxsmIcon + ctl->sLabel.cx + 8 > rcClient.right - rcClient.left)
ctl->sLabel.cx = (rcClient.right - rcClient.left) - g_cxsmIcon - 8;
else
ctl->sLabel.cx += 4;
ix = (rcClient.right - rcClient.left) / 2 - ((g_cxsmIcon + ctl->sLabel.cx) / 2);
if (ctl->iIcon)
ImageList_DrawEx(ctl->hIml, ctl->iIcon, hdcMem, ix, iy, g_cxsmIcon, g_cysmIcon, CLR_NONE, CLR_NONE, ILD_NORMAL);
else
DrawState(hdcMem, NULL, NULL, (LPARAM) hIconNew, 0, ix, iy, g_cxsmIcon, g_cysmIcon, IsWindowEnabled(ctl->hwnd) ? DST_ICON | DSS_NORMAL : DST_ICON | DSS_DISABLED);
xOffset = ix + g_cxsmIcon + 4;
}
} else if (ctl->hBitmap) {
BITMAP bminfo;
int ix, iy;
GetObject(ctl->hBitmap, sizeof(bminfo), &bminfo);
ix = (rcClient.right - rcClient.left) / 2 - (bminfo.bmWidth / 2);
iy = (rcClient.bottom - rcClient.top) / 2 - (bminfo.bmHeight / 2);
if (ctl->stateId == PBS_PRESSED) {
ix++;
iy++;
}
DrawState(hdcMem, NULL, NULL, (LPARAM) ctl->hBitmap, 0, ix, iy, bminfo.bmWidth, bminfo.bmHeight, IsWindowEnabled(ctl->hwnd) ? DST_BITMAP : DST_BITMAP | DSS_DISABLED);
}
if (GetWindowTextLength(ctl->hwnd)) {
// Draw the text and optinally the arrow
RECT rcText;
CopyRect(&rcText, &rcClient);
SetBkMode(hdcMem, TRANSPARENT);
// XP w/themes doesn't used the glossy disabled text. Is it always using COLOR_GRAYTEXT? Seems so.
if(!ctl->bSkinned)
SetTextColor(hdcMem, IsWindowEnabled(ctl->hwnd) || !ctl->hThemeButton ? GetSysColor(COLOR_BTNTEXT) : GetSysColor(COLOR_GRAYTEXT));
if (ctl->arrow)
DrawState(hdcMem, NULL, NULL, (LPARAM) ctl->arrow, 0, rcClient.right - rcClient.left - 5 - g_cxsmIcon + (!ctl->hThemeButton && ctl->stateId == PBS_PRESSED ? 1 : 0), (rcClient.bottom - rcClient.top) / 2 - g_cysmIcon / 2 + (!ctl->hThemeButton && ctl->stateId == PBS_PRESSED ? 1 : 0), g_cxsmIcon, g_cysmIcon, IsWindowEnabled(ctl->hwnd) ? DST_ICON : DST_ICON | DSS_DISABLED);
DrawState(hdcMem, NULL, NULL, (LPARAM) ctl->szText, 0, xOffset + (!ctl->hThemeButton && ctl->stateId == PBS_PRESSED ? 1 : 0), ctl->hThemeButton ? (rcText.bottom - rcText.top - ctl->sLabel.cy) / 2 + 1 : (rcText.bottom - rcText.top - ctl->sLabel.cy) / 2 + (ctl->stateId == PBS_PRESSED ? 1 : 0), ctl->sLabel.cx, ctl->sLabel.cy, IsWindowEnabled(ctl->hwnd) || ctl->hThemeButton ? DST_PREFIXTEXT | DSS_NORMAL : DST_PREFIXTEXT | DSS_DISABLED);
}
if (hOldFont)
SelectObject(hdcMem, hOldFont);
BitBlt(hdcPaint, 0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
DeleteObject(hbmOld);
}
}