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