自学教程：C++ DeleteDC函数代码示例

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. */voidSplashRedrawWindow(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)//.........这里部分代码省略.........

// 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);}

//.........这里部分代码省略.........		//	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++)            {//.........这里部分代码省略.........

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)//.........这里部分代码省略.........

//.........这里部分代码省略.........        }      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;}

//.........这里部分代码省略.........        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_boolWIN_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);}

//.........这里部分代码省略.........	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)		{//.........这里部分代码省略.........

//.........这里部分代码省略.........                            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);    }}