void GetCurDisplay(HDC& rCompatibleHDC, HBITMAP& rHbitmap) { HDC desktopDC = CreateDCW(L"DISPLAY", NULL, NULL, NULL); ASSERT_NOTNULL(desktopDC); int cx = GetDeviceCaps(desktopDC, HORZRES); int cy = GetDeviceCaps(desktopDC, VERTRES); rCompatibleHDC = CreateCompatibleDC(desktopDC); ASSERT_NOTNULL(rCompatibleHDC); rHbitmap = CreateCompatibleBitmap(desktopDC, cx, cy); ASSERT_NOTNULL(rHbitmap); HBITMAP oldbitMap = (HBITMAP)SelectObject(rCompatibleHDC, rHbitmap); // 因为在正常得到的图像是颠倒的,所以需要在之前处理成反的 //int res = BitBlt(rCompatibleHDC, 0, cy, cx, -1*cy, desktopDC, 0, 0, SRCCOPY); /* StretchBlt也允许水平或垂直翻转图像。如果cxSrc和cxDst标记(转换成设备单位以后)不同, 那么StretchBlt就建立一个镜像:左右翻转。在STRETCH程序中,通过将xDst参数改为cxClient并将cxDst参数改成-cxClient, 就可以做到这一点。如果cySrc和cyDst不同,则StretchBlt会上下翻转图像。要在STRETCH程序中测试这一点, 可将yDst参数改为cyClient并将cyDst参数改成-cyClient。 */ int res = StretchBlt(rCompatibleHDC, 0, cy, cx, -1*cy, desktopDC, 0, 0, cx, cy,SRCCOPY); //int res = StretchDIBits(rCompatibleHDC, 0, 0, cx, -1*cy, desktopDC, 0, 0, cx, cy,SRCCOPY); ASSERT_NOTZERO(res); rHbitmap = (HBITMAP)SelectObject(rCompatibleHDC, oldbitMap); DeleteDC(desktopDC); }
void swapchain_update_surface(struct wined3d_swapchain *swapchain) { const struct wined3d_gl_info *gl_info = &swapchain->device->adapter->gl_info; if (gl_info->supported[WGL_WINE_SURFACE]) { HDC hdc; if (swapchain->surface && !GL_EXTCALL(wglDestroySurfaceWINE(swapchain->surface))) ERR("wglDestroySurfaceWINE failed to destroy surface %p\n", swapchain->surface); if (swapchain->desc.windowed) hdc = GetDC(swapchain->win_handle); else hdc = CreateDCW(swapchain->device->adapter->DeviceName, swapchain->device->adapter->DeviceName, NULL, NULL); swapchain->surface = GL_EXTCALL(wglCreateSurfaceWINE(hdc, swapchain->win_handle)); if (!swapchain->surface) WARN("wglCreateSurfaceWINE failed to create surface for window %p\n", swapchain->desc.windowed ? swapchain->win_handle : NULL); if (swapchain->desc.windowed) ReleaseDC(swapchain->win_handle, hdc); else DeleteDC(hdc); } }
BOOL DoFontEnum( HDC hDC, LPWSTR pwszFace, SHORT TTPointSize) { ULONG ulFE = 0; BOOL bDeleteDC = FALSE; BOOL bFindFaces = (pwszFace == NULL); FONTENUMDC fed; DBGFONTS(("DoFontEnum \"%ls\"\n", pwszFace)); if (hDC == NULL) { hDC = CreateDCW(L"DISPLAY",NULL,NULL,NULL); bDeleteDC = TRUE; } fed.hDC = hDC; fed.bFindFaces = bFindFaces; fed.ulFE = 0; fed.TTPointSize = TTPointSize; EnumFontFamiliesW(hDC, (LPCWSTR)pwszFace, (FONTENUMPROC)FontEnum, (LPARAM)&fed); if (bDeleteDC) { DeleteDC(hDC); } return (fed.ulFE & FE_FONTOK) != 0; }
//Parameter needed on win32.. bool PrinterUtil::isPostscriptPrinter( QString printerName) { #ifdef _WIN32 HDC dc; int escapeCode; char technology[MAX_PATH] = {0}; // Create the default device context dc = CreateDCW( NULL, (LPCWSTR) printerName.utf16(), NULL, NULL ); if ( !dc ) { qWarning("isPostscriptPrinter() failed to create device context for %s", printerName.toAscii().data()); return false; } // test if printer support the POSTSCRIPT_PASSTHROUGH escape code escapeCode = POSTSCRIPT_PASSTHROUGH; if ( ExtEscape( dc, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&escapeCode, 0, NULL ) > 0 ) { DeleteDC( dc ); return true; } // test if printer support the POSTSCRIPT_DATA escape code escapeCode = POSTSCRIPT_DATA; if ( ExtEscape( dc, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&escapeCode, 0, NULL ) > 0 ) { DeleteDC( dc ); return true; } // try to get postscript support by testing the printer technology escapeCode = GETTECHNOLOGY; if ( ExtEscape( dc, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&escapeCode, 0, NULL ) > 0 ) { // if GETTECHNOLOGY is supported, then ... get technology if ( ExtEscape( dc, GETTECHNOLOGY, 0, NULL, MAX_PATH, (LPSTR) technology ) > 0 ) { // check technology string for postscript word strupr( technology ); if ( strstr( technology, "POSTSCRIPT" ) ) { DeleteDC( dc ); return true; } } } DeleteDC( dc ); return false; #else return true; #endif }
// Create monitor from an adapter and (optionally) a display // static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter, DISPLAY_DEVICEW* display) { _GLFWmonitor* monitor; char* name; HDC dc; if (display) name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString); else name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString); if (!name) { _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to convert string to UTF-8"); return NULL; } dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL); monitor = _glfwAllocMonitor(name, GetDeviceCaps(dc, HORZSIZE), GetDeviceCaps(dc, VERTSIZE)); DeleteDC(dc); free(name); if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED) monitor->win32.modesPruned = GLFW_TRUE; wcscpy(monitor->win32.adapterName, adapter->DeviceName); WideCharToMultiByte(CP_UTF8, 0, adapter->DeviceName, -1, monitor->win32.publicAdapterName, sizeof(monitor->win32.publicAdapterName), NULL, NULL); if (display) { wcscpy(monitor->win32.displayName, display->DeviceName); WideCharToMultiByte(CP_UTF8, 0, display->DeviceName, -1, monitor->win32.publicDisplayName, sizeof(monitor->win32.publicDisplayName), NULL, NULL); } return monitor; }
void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp) { HDC dc; WORD values[768]; dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL); GetDeviceGammaRamp(dc, values); DeleteDC(dc); _glfwAllocGammaArrays(ramp, 256); memcpy(ramp->red, values + 0, 256 * sizeof(unsigned short)); memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short)); memcpy(ramp->blue, values + 512, 256 * sizeof(unsigned short)); }
/* * Test see if we getting a DirectDrawObject from win32k * */ HANDLE test_NtGdiDdCreateDirectDrawObject() { HANDLE retValue=0; int fails=0; HDC hdc=CreateDCW(L"Display",NULL,NULL,NULL); if (hdc == NULL) { printf("No hdc was created with Display, trying now with DISPLAY\n"); hdc=CreateDCW(L"DISPLAY",NULL,NULL,NULL); if (hdc == NULL) { printf("No hdc was created with DISPLAY, trying now with NULL\n"); hdc=CreateDCW(NULL,NULL,NULL,NULL); } } if (hdc == NULL) { printf("No hdc was created at all perpare all test will fail\n"); return NULL; } printf("Start testing of NtGdiDdCreateDirectDrawObject\n"); retValue = OsThunkDdCreateDirectDrawObject(NULL); testing_noteq(retValue,NULL,fails,"NtGdiDdCreateDirectDrawObject(NULL);\0"); retValue = OsThunkDdCreateDirectDrawObject(hdc); testing_eq(retValue,NULL,fails,"NtGdiDdCreateDirectDrawObject(hdc);\0"); show_status(fails, "NtGdiDdCreateDirectDrawObject\0"); return retValue; }
static void test_SetICMMode( HDC dc ) { INT ret, knob, save; BOOL impl; SetLastError( 0xdeadbeef ); impl = GetICMProfileA( NULL, NULL, NULL ); if ( !impl && ( GetLastError() == ERROR_CALL_NOT_IMPLEMENTED ) ) { win_skip( "On NT4 where SetICMMode is not implemented but this is not advertised\n" ); return; } SetLastError( 0xdeadbeef ); ret = SetICMMode( NULL, 0 ); ok( !ret, "SetICMMode succeeded (%d)\n", GetLastError() ); ret = SetICMMode( dc, -1 ); ok( !ret, "SetICMMode succeeded (%d)\n", GetLastError() ); save = SetICMMode( dc, ICM_QUERY ); ok( save == ICM_ON || save == ICM_OFF, "SetICMMode failed (%d)\n", GetLastError() ); if (save == ICM_ON) knob = ICM_OFF; else knob = ICM_ON; ret = SetICMMode( dc, knob ); todo_wine ok( ret, "SetICMMode failed (%d)\n", GetLastError() ); ret = SetICMMode( dc, ICM_QUERY ); todo_wine ok( ret == knob, "SetICMMode failed (%d)\n", GetLastError() ); ret = SetICMMode( dc, save ); ok( ret, "SetICMMode failed (%d)\n", GetLastError() ); SetLastError( 0xdeadbeef ); dc = CreateDCW( displayW, NULL, NULL, NULL ); if ( !dc && ( GetLastError() == ERROR_CALL_NOT_IMPLEMENTED ) ) { win_skip( "CreateDCW is not implemented\n" ); return; } ok( dc != NULL, "CreateDCW failed (%d)\n", GetLastError() ); ret = SetICMMode( dc, ICM_QUERY ); ok( ret == ICM_OFF, "SetICMMode failed (%d)\n", GetLastError() ); DeleteDC( dc ); }
/*! This function obtains a DC for the default printer The caller needs to call DeleteDC when dc is no longer needed. */ HDC UT_GetDefaultPrinterDC() { wchar_t * pPrinterName = UT_GetDefaultPrinterName(); if(!pPrinterName || !*pPrinterName) return NULL; // HANDLE hPrinter; // if(!OpenPrinter(pPrinterName, &hPrinter, NULL)) // return NULL; const wchar_t * pDriver = UT_IsWinNT() ? L"WINSPOOL" : NULL; HDC hdc = CreateDCW(pDriver, pPrinterName, NULL, NULL); g_free(pPrinterName); return hdc; }
INT Test_NtGdiSelectFont(PTESTINFO pti) { HDC hDC; HFONT hFont, hOldFont; hDC = CreateDCW(L"DISPLAY", NULL, NULL, NULL); hFont = GetStockObject(DEFAULT_GUI_FONT); /* Test NULL DC */ SetLastError(ERROR_SUCCESS); hOldFont = NtGdiSelectFont(NULL, hFont); TEST(hOldFont == NULL); TEST(GetLastError() == ERROR_SUCCESS); /* Test invalid DC */ SetLastError(ERROR_SUCCESS); hOldFont = NtGdiSelectFont((HDC)((ULONG_PTR)hDC & 0x0000ffff), hFont); TEST(hOldFont == NULL); TEST(GetLastError() == ERROR_SUCCESS); /* Test NULL font */ SetLastError(ERROR_SUCCESS); hOldFont = NtGdiSelectFont(hDC, NULL); TEST(hOldFont == NULL); TEST(GetLastError() == ERROR_SUCCESS); /* Test invalid font */ SetLastError(ERROR_SUCCESS); hOldFont = NtGdiSelectFont(hDC, (HFONT)((ULONG_PTR)hFont & 0x0000ffff)); TEST(hOldFont == NULL); TEST(GetLastError() == ERROR_SUCCESS); SetLastError(ERROR_SUCCESS); hOldFont = NtGdiSelectFont(hDC, hFont); TEST(hOldFont != NULL); hOldFont = NtGdiSelectFont(hDC, hOldFont); TEST(hOldFont == hFont); TEST(GetLastError() == ERROR_SUCCESS); DeleteDC(hDC); return APISTATUS_NORMAL; }
INT Test_NtGdiDdDeleteDirectDrawObject(PTESTINFO pti) { HANDLE hDirectDraw; HDC hdc = CreateDCW(L"DISPLAY",NULL,NULL,NULL); ASSERT(hdc != NULL); /* Test ReactX */ RTEST(NtGdiDdDeleteDirectDrawObject(NULL) == FALSE); RTEST((hDirectDraw=NtGdiDdCreateDirectDrawObject(hdc)) != NULL); ASSERT(hDirectDraw != NULL); RTEST(NtGdiDdDeleteDirectDrawObject(hDirectDraw) == TRUE); /* Cleanup ReactX setup */ DeleteDC(hdc); Syscall(L"NtGdiDdDeleteDirectDrawObject", 1, &hDirectDraw); return APISTATUS_NORMAL; }
static HDC make_dc(void) { if(devNames && devMode) { LPDEVNAMES dn = GlobalLock(devNames); LPDEVMODEW dm = GlobalLock(devMode); HDC ret; ret = CreateDCW((LPWSTR)dn + dn->wDriverOffset, (LPWSTR)dn + dn->wDeviceOffset, 0, dm); GlobalUnlock(dn); GlobalUnlock(dm); return ret; } else { return 0; } }
void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp) { HDC dc; WORD values[768]; if (ramp->size != 256) { _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Gamma ramp size must be 256"); return; } memcpy(values + 0, ramp->red, 256 * sizeof(unsigned short)); memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short)); memcpy(values + 512, ramp->blue, 256 * sizeof(unsigned short)); dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL); SetDeviceGammaRamp(dc, values); DeleteDC(dc); }
/*********************************************************************** * AtlCreateTargetDC [atl100.@] */ HDC WINAPI AtlCreateTargetDC( HDC hdc, DVTARGETDEVICE *dv ) { static const WCHAR displayW[] = {'d','i','s','p','l','a','y',0}; const WCHAR *driver = NULL, *device = NULL, *port = NULL; DEVMODEW *devmode = NULL; TRACE( "(%p, %p)\n", hdc, dv ); if (dv) { if (dv->tdDriverNameOffset) driver = (WCHAR *)((char *)dv + dv->tdDriverNameOffset); if (dv->tdDeviceNameOffset) device = (WCHAR *)((char *)dv + dv->tdDeviceNameOffset); if (dv->tdPortNameOffset) port = (WCHAR *)((char *)dv + dv->tdPortNameOffset); if (dv->tdExtDevmodeOffset) devmode = (DEVMODEW *)((char *)dv + dv->tdExtDevmodeOffset); } else { if (hdc) return hdc; driver = displayW; } return CreateDCW( driver, device, port, devmode ); }
/** * \brief Initialize w32_common framework. * * The first function that should be called from the w32_common framework. * It handles window creation on the screen with proper title and attributes. * It also initializes the framework's internal variables. The function should * be called after your own preinit initialization and you shouldn't do any * window management on your own. * * Global libvo variables changed: * vo_w32_window * vo_screenwidth * vo_screenheight * * \return 1 = Success, 0 = Failure */ int vo_w32_init(struct vo *vo) { struct vo_w32_state *w32 = vo->w32; if (w32 && w32->window) return 1; if (!w32) w32 = vo->w32 = talloc_zero(vo, struct vo_w32_state); HINSTANCE hInstance = GetModuleHandleW(NULL); HICON mplayerIcon = LoadIconW(hInstance, L"IDI_ICON1"); WNDCLASSEXW wcex = { .cbSize = sizeof wcex, .style = CS_OWNDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, .lpfnWndProc = WndProc, .hInstance = hInstance, .hIcon = mplayerIcon, .hCursor = LoadCursor(0, IDC_ARROW), .lpszClassName = classname, .hIconSm = mplayerIcon, }; if (!RegisterClassExW(&wcex)) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to register window class!\n"); return 0; } if (WinID >= 0) { RECT r; GetClientRect(WIN_ID_TO_HWND(WinID), &r); vo->dwidth = r.right; vo->dheight = r.bottom; w32->window = CreateWindowExW(WS_EX_NOPARENTNOTIFY, classname, classname, WS_CHILD | WS_VISIBLE, 0, 0, vo->dwidth, vo->dheight, WIN_ID_TO_HWND(WinID), 0, hInstance, vo); } else { w32->window = CreateWindowExW(0, classname, classname, update_style(vo, 0), CW_USEDEFAULT, 0, 100, 100, 0, 0, hInstance, vo); } if (!w32->window) { mp_msg(MSGT_VO, MSGL_ERR, "vo: win32: unable to create window!\n"); return 0; } if (WinID >= 0) EnableWindow(w32->window, 0); w32->dev_hdc = 0; wchar_t *dev = get_display_name(); if (dev) w32->dev_hdc = CreateDCW(dev, NULL, NULL, NULL); free(dev); updateScreenProperties(vo); mp_msg(MSGT_VO, MSGL_V, "vo: win32: running at %dx%d with depth %d\n", vo->opts->vo_screenwidth, vo->opts->vo_screenheight, w32->depthonscreen); return 1; } /** * \brief Toogle fullscreen / windowed mode. * * Should be called on VOCTRL_FULLSCREEN event. The window is * always resized during this call, so the rendering context * should be reinitialized with the new dimensions. * It is unspecified if vo_check_events will create a resize * event in addition or not. */ void vo_w32_fullscreen(struct vo *vo) { vo_fs = !vo_fs; reinit_window_state(vo); }
/********************************************************************** * CreateEnhMetaFileW (GDI32.@) */ HDC WINAPI CreateEnhMetaFileW( HDC hdc, /* [in] optional reference DC */ LPCWSTR filename, /* [in] optional filename for disk metafiles */ const RECT* rect, /* [in] optional bounding rectangle */ LPCWSTR description /* [in] optional description */ ) { static const WCHAR displayW[] = {'D','I','S','P','L','A','Y',0}; HDC ret; DC *dc; EMFDRV_PDEVICE *physDev; HANDLE hFile; DWORD size = 0, length = 0; TRACE("%s\n", debugstr_w(filename) ); if (!(dc = alloc_dc_ptr( OBJ_ENHMETADC ))) return 0; physDev = HeapAlloc(GetProcessHeap(),0,sizeof(*physDev)); if (!physDev) { free_dc_ptr( dc ); return 0; } if(description) { /* App name\0Title\0\0 */ length = lstrlenW(description); length += lstrlenW(description + length + 1); length += 3; length *= 2; } size = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4; if (!(physDev->emh = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size))) { HeapFree( GetProcessHeap(), 0, physDev ); free_dc_ptr( dc ); return 0; } push_dc_driver( &dc->physDev, &physDev->dev, &EMFDRV_Funcs ); physDev->handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, HANDLE_LIST_INC * sizeof(physDev->handles[0])); physDev->handles_size = HANDLE_LIST_INC; physDev->cur_handles = 1; physDev->hFile = 0; physDev->dc_brush = 0; physDev->dc_pen = 0; physDev->screen_dc = 0; physDev->restoring = 0; if (hdc) /* if no ref, use current display */ physDev->ref_dc = hdc; else physDev->ref_dc = physDev->screen_dc = CreateDCW( displayW, NULL, NULL, NULL ); SetVirtualResolution(physDev->dev.hdc, 0, 0, 0, 0); physDev->emh->iType = EMR_HEADER; physDev->emh->nSize = size; physDev->emh->rclBounds.left = physDev->emh->rclBounds.top = 0; physDev->emh->rclBounds.right = physDev->emh->rclBounds.bottom = -1; if(rect) { physDev->emh->rclFrame.left = rect->left; physDev->emh->rclFrame.top = rect->top; physDev->emh->rclFrame.right = rect->right; physDev->emh->rclFrame.bottom = rect->bottom; } else { /* Set this to {0,0 - -1,-1} and update it at the end */ physDev->emh->rclFrame.left = physDev->emh->rclFrame.top = 0; physDev->emh->rclFrame.right = physDev->emh->rclFrame.bottom = -1; } physDev->emh->dSignature = ENHMETA_SIGNATURE; physDev->emh->nVersion = 0x10000; physDev->emh->nBytes = physDev->emh->nSize; physDev->emh->nRecords = 1; physDev->emh->nHandles = 1; physDev->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */ physDev->emh->nDescription = length / 2; physDev->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0; physDev->emh->nPalEntries = 0; /* I guess this should start at 0 */ /* Size in pixels */ physDev->emh->szlDevice.cx = GetDeviceCaps( physDev->ref_dc, HORZRES ); physDev->emh->szlDevice.cy = GetDeviceCaps( physDev->ref_dc, VERTRES ); /* Size in millimeters */ physDev->emh->szlMillimeters.cx = GetDeviceCaps( physDev->ref_dc, HORZSIZE ); physDev->emh->szlMillimeters.cy = GetDeviceCaps( physDev->ref_dc, VERTSIZE ); /* Size in micrometers */ physDev->emh->szlMicrometers.cx = physDev->emh->szlMillimeters.cx * 1000; physDev->emh->szlMicrometers.cy = physDev->emh->szlMillimeters.cy * 1000; memcpy((char *)physDev->emh + sizeof(ENHMETAHEADER), description, length); if (filename) /* disk based metafile */ { if ((hFile = CreateFileW(filename, GENERIC_WRITE | GENERIC_READ, 0, NULL, CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) { free_dc_ptr( dc ); return 0; } if (!WriteFile( hFile, physDev->emh, size, NULL, NULL )) { free_dc_ptr( dc ); CloseHandle( hFile ); return 0; } physDev->hFile = hFile; } TRACE("returning %p\n", physDev->dev.hdc); ret = physDev->dev.hdc; release_dc_ptr( dc ); return ret; }
NTSTATUS EnumerateFonts( DWORD Flags) { TEXTMETRIC tmi; HDC hDC; PFACENODE pFN; ULONG ulOldEnumFilter; DWORD FontIndex; DWORD dwFontType = 0; DBGFONTS(("EnumerateFonts %lx\n", Flags)); dwFontType = (EF_TTFONT|EF_OEMFONT|EF_DEFFACE) & Flags; if (FontInfo == NULL) { // // allocate memory for the font array // NumberOfFonts = 0; FontInfo = (PFONT_INFO)HeapAlloc(pConHeap,MAKE_TAG( FONT_TAG ),sizeof(FONT_INFO) * INITIAL_FONTS); if (FontInfo == NULL) return STATUS_NO_MEMORY; FontInfoLength = INITIAL_FONTS; } hDC = CreateDCW(L"DISPLAY",NULL,NULL,NULL); // Before enumeration, turn off font enumeration filters. ulOldEnumFilter = SetFontEnumeration(0); // restore all the other flags SetFontEnumeration(ulOldEnumFilter & ~FE_FILTER_TRUETYPE); if (Flags & EF_DEFFACE) { SelectObject(hDC,GetStockObject(OEM_FIXED_FONT)); if (GetTextMetricsW(hDC, &tmi)) { DefaultFontSize.X = (SHORT)(tmi.tmMaxCharWidth); DefaultFontSize.Y = (SHORT)(tmi.tmHeight+tmi.tmExternalLeading); DefaultFontFamily = tmi.tmPitchAndFamily; } GetTextFaceW(hDC, LF_FACESIZE, DefaultFaceName); DBGFONTS(("Default (OEM) Font %ls (%d,%d)\n", DefaultFaceName, DefaultFontSize.X, DefaultFontSize.Y)); // Make sure we are going to enumerate the OEM face. pFN = AddFaceNode(&gpFaceNames, DefaultFaceName); pFN->dwFlag |= EF_DEFFACE | EF_OEMFONT; } // Use DoFontEnum to get all fonts from the system. Our FontEnum // proc puts just the ones we want into an array // for (pFN = gpFaceNames; pFN; pFN = pFN->pNext) { DBGFONTS(("\"%ls\" is %s%s%s%s%s%s\n", pFN->awch, pFN->dwFlag & EF_NEW ? "NEW " : " ", pFN->dwFlag & EF_OLD ? "OLD " : " ", pFN->dwFlag & EF_ENUMERATED ? "ENUMERATED " : " ", pFN->dwFlag & EF_OEMFONT ? "OEMFONT " : " ", pFN->dwFlag & EF_TTFONT ? "TTFONT " : " ", pFN->dwFlag & EF_DEFFACE ? "DEFFACE " : " ")); if ((pFN->dwFlag & dwFontType) == 0) { // not the kind of face we want continue; } if (pFN->dwFlag & EF_ENUMERATED) { // we already enumerated this face continue; } DoFontEnum(hDC, pFN->awch, DefaultFontSize.Y); pFN->dwFlag |= EF_ENUMERATED; } // After enumerating fonts, restore the font enumeration filter. SetFontEnumeration(ulOldEnumFilter); DeleteDC(hDC); // Make sure the default font is set correctly if (NumberOfFonts > 0 && DefaultFontSize.X == 0 && DefaultFontSize.Y == 0) { DefaultFontSize.X = FontInfo[0].Size.X; DefaultFontSize.Y = FontInfo[0].Size.Y; DefaultFontFamily = FontInfo[0].Family; } for (FontIndex = 0; FontIndex < NumberOfFonts; FontIndex++) { if (FontInfo[FontIndex].Size.X == DefaultFontSize.X && FontInfo[FontIndex].Size.Y == DefaultFontSize.Y && FontInfo[FontIndex].Family == DefaultFontFamily) { break; } } ASSERT(FontIndex < NumberOfFonts); if (FontIndex < NumberOfFonts) { DefaultFontIndex = FontIndex; } else { DefaultFontIndex = 0; } DBGFONTS(("EnumerateFonts : DefaultFontIndex = %ld\n", DefaultFontIndex)); return STATUS_SUCCESS; }
static HRESULT fill_groups( struct d3dadapter9 *This ) { DISPLAY_DEVICEW dd; DEVMODEW dm; POINT pt; HDC hdc; HRESULT hr; int i, j, k; WCHAR wdisp[] = {'D','I','S','P','L','A','Y',0}; ZeroMemory(&dd, sizeof(dd)); ZeroMemory(&dm, sizeof(dm)); dd.cb = sizeof(dd); dm.dmSize = sizeof(dm); for (i = 0; EnumDisplayDevicesW(NULL, i, &dd, 0); ++i) { struct adapter_group *group = add_group(This); if (!group) { ERR("Out of memory.\n"); return E_OUTOFMEMORY; } hdc = CreateDCW(wdisp, dd.DeviceName, NULL, NULL); if (!hdc) { remove_group(This); WARN("Unable to create DC for display %d.\n", i); goto end_group; } hr = present_create_adapter9(This->gdi_display, hdc, &group->adapter); DeleteDC(hdc); if (FAILED(hr)) { remove_group(This); goto end_group; } CopyMemory(group->devname, dd.DeviceName, sizeof(group->devname)); for (j = 0; EnumDisplayDevicesW(group->devname, j, &dd, 0); ++j) { struct output *out = add_output(This); boolean orient = FALSE, monit = FALSE; if (!out) { ERR("Out of memory.\n"); return E_OUTOFMEMORY; } for (k = 0; EnumDisplaySettingsExW(dd.DeviceName, k, &dm, 0); ++k) { D3DDISPLAYMODEEX *mode = add_mode(This); if (!out) { ERR("Out of memory.\n"); return E_OUTOFMEMORY; } mode->Size = sizeof(D3DDISPLAYMODEEX); mode->Width = dm.dmPelsWidth; mode->Height = dm.dmPelsHeight; mode->RefreshRate = dm.dmDisplayFrequency; mode->ScanLineOrdering = (dm.dmDisplayFlags & DM_INTERLACED) ? D3DSCANLINEORDERING_INTERLACED : D3DSCANLINEORDERING_PROGRESSIVE; switch (dm.dmBitsPerPel) { case 32: mode->Format = D3DFMT_X8R8G8B8; break; case 24: mode->Format = D3DFMT_R8G8B8; break; case 16: mode->Format = D3DFMT_R5G6B5; break; case 8: remove_mode(This); goto end_mode; default: remove_mode(This); WARN("Unknown format (%u bpp) in display %d, monitor " "%d, mode %d.\n", dm.dmBitsPerPel, i, j, k); goto end_mode; } if (!orient) { switch (dm.dmDisplayOrientation) { case DMDO_DEFAULT: out->rotation = D3DDISPLAYROTATION_IDENTITY; break; case DMDO_90: out->rotation = D3DDISPLAYROTATION_90; break; case DMDO_180: out->rotation = D3DDISPLAYROTATION_180; break; case DMDO_270: out->rotation = D3DDISPLAYROTATION_270; break; default: remove_output(This); WARN("Unknown display rotation in display %d, " "monitor %d\n", i, j); goto end_output; } orient = TRUE; } if (!monit) { pt.x = dm.dmPosition.x; pt.y = dm.dmPosition.y; out->monitor = MonitorFromPoint(pt, 0); if (!out->monitor) { remove_output(This); WARN("Unable to get monitor handle for display %d, " "monitor %d.\n", i, j); goto end_output; } monit = TRUE; } end_mode: ZeroMemory(&dm, sizeof(dm)); dm.dmSize = sizeof(dm); } end_output: ZeroMemory(&dd, sizeof(dd)); dd.cb = sizeof(dd); } end_group: ZeroMemory(&dd, sizeof(dd)); dd.cb = sizeof(dd); } return D3D_OK; }
bool PrinterUtil::getPrinterMarginValues(const QString& printerName, const QString& pageSize, double& ptsTopMargin, double& ptsBottomMargin, double& ptsLeftMargin, double& ptsRightMargin) { bool retVal=false; #if defined(HAVE_CUPS) const char *filename; // tmp PPD filename filename=cupsGetPPD(printerName.toLocal8Bit().constData()); if (filename!=NULL) { ppd_file_t *ppd; // PPD data ppd = ppdOpenFile(filename); if (ppd!=NULL) { ppd_size_t *size; // page size data, null if printer doesnt support selected size size = ppdPageSize(ppd, pageSize.toLocal8Bit().constData()); if (size!=NULL) { //Store in pts for returning via getNewPrinterMargins in pts retVal=true; ptsTopMargin=size->length-size->top; ptsBottomMargin=size->bottom; ptsLeftMargin=size->left; ptsRightMargin=size->width-size->right; } ppdClose(ppd); } } #elif defined(_WIN32) DWORD nPaper; DWORD nPaperNames; typedef WCHAR wchar64[64]; nPaper = DeviceCapabilitiesW( (LPCWSTR) printerName.utf16(), NULL, DC_PAPERS, NULL, NULL ); nPaperNames = DeviceCapabilitiesW( (LPCWSTR) printerName.utf16(), NULL, DC_PAPERNAMES, NULL, NULL ); if ( (nPaper > 0) && (nPaperNames > 0) && (nPaper == nPaperNames) ) { int paperIndex = -1; DWORD *papers = new DWORD[nPaper]; wchar64 *paperNames = new wchar64[nPaperNames]; DWORD s1 = DeviceCapabilitiesW( (LPCWSTR) printerName.utf16(), NULL, DC_PAPERS, (LPWSTR) papers, NULL ); DWORD s2 = DeviceCapabilitiesW( (LPCWSTR) printerName.utf16(), NULL, DC_PAPERNAMES, (LPWSTR) paperNames, NULL ); for ( uint i = 0; i < nPaperNames; i++ ) { if ( pageSize == QString::fromUtf16((const ushort*) paperNames[i]) ) { paperIndex = i; break; } } if ( paperIndex >= 0 ) { Qt::HANDLE handle = NULL; if( OpenPrinterW( (LPWSTR) printerName.utf16(), &handle, NULL ) ) { // Retrieve DEVMODE structure for selected device uint size = DocumentPropertiesW( ScCore->primaryMainWindow()->winId(), handle, (LPWSTR) printerName.utf16(), NULL, NULL, 0); QByteArray devModeW(size, 0); DEVMODEW* devMode = (DEVMODEW*) devModeW.data(); DocumentPropertiesW( ScCore->primaryMainWindow()->winId(), handle, (LPWSTR) printerName.utf16(), devMode, NULL, DM_OUT_BUFFER); ClosePrinter( handle ); // Set paper size devMode->dmPaperSize = papers[paperIndex]; // Create device context HDC printerDC = CreateDCW( NULL, (LPWSTR) printerName.utf16(), NULL, devMode ); if( printerDC ) { retVal = true; int logPixelsX = GetDeviceCaps( printerDC, LOGPIXELSX ); int logPixelsY = GetDeviceCaps( printerDC, LOGPIXELSY ); int physicalOffsetX = GetDeviceCaps( printerDC, PHYSICALOFFSETX ); int physicalOffsetY = GetDeviceCaps( printerDC, PHYSICALOFFSETY ); ptsLeftMargin = ptsRightMargin = ( physicalOffsetX / (double) logPixelsX * 72 ); ptsTopMargin = ptsBottomMargin = ( physicalOffsetY / (double) logPixelsY * 72 ); DeleteDC(printerDC); } } } delete[] papers; delete[] paperNames; } #endif return retVal; }
// Create monitor from an adapter and (optionally) a display // static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter, DISPLAY_DEVICEW* display) { _GLFWmonitor* monitor; int widthMM, heightMM; char* name; HDC dc; DEVMODEW dm; RECT rect; if (display) name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString); else name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString); if (!name) return NULL; ZeroMemory(&dm, sizeof(dm)); dm.dmSize = sizeof(dm); EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm); dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL); if (IsWindows8Point1OrGreater()) { widthMM = GetDeviceCaps(dc, HORZSIZE); heightMM = GetDeviceCaps(dc, VERTSIZE); } else { widthMM = (int) (dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX)); heightMM = (int) (dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY)); } DeleteDC(dc); monitor = _glfwAllocMonitor(name, widthMM, heightMM); free(name); if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED) monitor->win32.modesPruned = GLFW_TRUE; wcscpy(monitor->win32.adapterName, adapter->DeviceName); WideCharToMultiByte(CP_UTF8, 0, adapter->DeviceName, -1, monitor->win32.publicAdapterName, sizeof(monitor->win32.publicAdapterName), NULL, NULL); if (display) { wcscpy(monitor->win32.displayName, display->DeviceName); WideCharToMultiByte(CP_UTF8, 0, display->DeviceName, -1, monitor->win32.publicDisplayName, sizeof(monitor->win32.publicDisplayName), NULL, NULL); } rect.left = dm.dmPosition.x; rect.top = dm.dmPosition.y; rect.right = dm.dmPosition.x + dm.dmPelsWidth; rect.bottom = dm.dmPosition.y + dm.dmPelsHeight; EnumDisplayMonitors(NULL, &rect, monitorCallback, (LPARAM) monitor); return monitor; }
static void collectMonitorInfo() { DISPLAY_DEVICEW adapter; adapter.cb = sizeof(adapter); int found = 0; int size = 0; for (int adapterIndex = 0;; ++adapterIndex) { if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0)) break; if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE)) continue; for (int displayIndex = 0; ; displayIndex++) { DISPLAY_DEVICEW display; HDC dc; display.cb = sizeof(display); if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0)) break; dc = CreateDCW(L"DISPLAY", adapter.DeviceName, NULL, NULL); MonitorDesc desc; desc.modesPruned = (adapter.StateFlags & DISPLAY_DEVICE_MODESPRUNED) != 0; wcsncpy_s(desc.adapterName, adapter.DeviceName, elementsOf(adapter.DeviceName)); wcsncpy_s(desc.publicAdapterName, adapter.DeviceName, elementsOf(adapter.DeviceName)); wcsncpy_s(desc.displayName, display.DeviceName, elementsOf(display.DeviceName)); wcsncpy_s(desc.publicDisplayName, display.DeviceName, elementsOf(display.DeviceName)); gMonitors.push_back(desc); EnumDisplayMonitors(NULL, NULL, monitorCallback, gMonitors.size() - 1); DeleteDC(dc); if ((adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) && displayIndex == 0) { MonitorDesc desc = gMonitors[0]; gMonitors[0] = gMonitors[found]; gMonitors[found] = desc; } found++; } } for (uint32_t monitor = 0; monitor < (uint32_t)gMonitors.size(); ++monitor) { MonitorDesc* pMonitor = &gMonitors[monitor]; DEVMODEW devMode = {}; devMode.dmSize = sizeof(DEVMODEW); devMode.dmFields = DM_PELSHEIGHT | DM_PELSWIDTH; EnumDisplaySettingsW(pMonitor->adapterName, ENUM_CURRENT_SETTINGS, &devMode); pMonitor->defaultResolution.mHeight = devMode.dmPelsHeight; pMonitor->defaultResolution.mWidth = devMode.dmPelsWidth; tinystl::vector<Resolution> displays; DWORD current = 0; while (EnumDisplaySettingsW(pMonitor->adapterName, current++, &devMode)) { bool duplicate = false; for (uint32_t i = 0; i < (uint32_t)displays.size(); ++i) { if (displays[i].mWidth == (uint32_t)devMode.dmPelsWidth && displays[i].mHeight == (uint32_t)devMode.dmPelsHeight) { duplicate = true; break; } } if (duplicate) continue; Resolution videoMode = {}; videoMode.mHeight = devMode.dmPelsHeight; videoMode.mWidth = devMode.dmPelsWidth; displays.emplace_back(videoMode); } qsort(displays.data(), displays.size(), sizeof(Resolution), [](const void* lhs, const void* rhs) { Resolution* pLhs = (Resolution*)lhs; Resolution* pRhs = (Resolution*)rhs; if (pLhs->mHeight == pRhs->mHeight) return (int)(pLhs->mWidth - pRhs->mWidth); return (int)(pLhs->mHeight - pRhs->mHeight); }); pMonitor->resolutionCount = (uint32_t)displays.size(); pMonitor->resolutions = (Resolution*)conf_calloc(pMonitor->resolutionCount, sizeof(Resolution)); memcpy(pMonitor->resolutions, displays.data(), pMonitor->resolutionCount * sizeof(Resolution)); } }
/* load the graphics driver */ static const USER_DRIVER *load_driver(void) { static const WCHAR displayW[] = {'D','I','S','P','L','A','Y',0}; HDC hdc; void *ptr; HMODULE graphics_driver; USER_DRIVER *driver, *prev; driver = HeapAlloc( GetProcessHeap(), 0, sizeof(*driver) ); *driver = null_driver; hdc = CreateDCW( displayW, NULL, NULL, NULL ); graphics_driver = __wine_get_driver_module( hdc ); if (graphics_driver) { #define GET_USER_FUNC(name) \ do { if ((ptr = GetProcAddress( graphics_driver, #name ))) driver->p##name = ptr; } while(0) GET_USER_FUNC(ActivateKeyboardLayout); GET_USER_FUNC(Beep); GET_USER_FUNC(GetAsyncKeyState); GET_USER_FUNC(GetKeyNameText); GET_USER_FUNC(GetKeyboardLayout); GET_USER_FUNC(GetKeyboardLayoutName); GET_USER_FUNC(LoadKeyboardLayout); GET_USER_FUNC(MapVirtualKeyEx); GET_USER_FUNC(RegisterHotKey); GET_USER_FUNC(ToUnicodeEx); GET_USER_FUNC(UnloadKeyboardLayout); GET_USER_FUNC(UnregisterHotKey); GET_USER_FUNC(VkKeyScanEx); GET_USER_FUNC(CreateCursorIcon); GET_USER_FUNC(DestroyCursorIcon); GET_USER_FUNC(SetCursor); GET_USER_FUNC(GetCursorPos); GET_USER_FUNC(SetCursorPos); GET_USER_FUNC(ClipCursor); GET_USER_FUNC(GetScreenSaveActive); GET_USER_FUNC(SetScreenSaveActive); GET_USER_FUNC(AcquireClipboard); GET_USER_FUNC(EmptyClipboard); GET_USER_FUNC(SetClipboardData); GET_USER_FUNC(GetClipboardData); GET_USER_FUNC(CountClipboardFormats); GET_USER_FUNC(EnumClipboardFormats); GET_USER_FUNC(IsClipboardFormatAvailable); GET_USER_FUNC(EndClipboardUpdate); GET_USER_FUNC(ChangeDisplaySettingsEx); GET_USER_FUNC(EnumDisplayMonitors); GET_USER_FUNC(EnumDisplaySettingsEx); GET_USER_FUNC(GetMonitorInfo); GET_USER_FUNC(CreateDesktopWindow); GET_USER_FUNC(CreateWindow); GET_USER_FUNC(DestroyWindow); GET_USER_FUNC(GetDC); GET_USER_FUNC(MsgWaitForMultipleObjectsEx); GET_USER_FUNC(ReleaseDC); GET_USER_FUNC(ScrollDC); GET_USER_FUNC(SetCapture); GET_USER_FUNC(SetFocus); GET_USER_FUNC(SetLayeredWindowAttributes); GET_USER_FUNC(SetParent); GET_USER_FUNC(SetWindowRgn); GET_USER_FUNC(SetWindowIcon); GET_USER_FUNC(SetWindowStyle); GET_USER_FUNC(SetWindowText); GET_USER_FUNC(ShowWindow); GET_USER_FUNC(SysCommand); GET_USER_FUNC(UpdateLayeredWindow); GET_USER_FUNC(WindowMessage); GET_USER_FUNC(WindowPosChanging); GET_USER_FUNC(WindowPosChanged); #undef GET_USER_FUNC } else driver_load_error = GetLastError(); prev = InterlockedCompareExchangePointer( (void **)&USER_Driver, driver, &lazy_load_driver ); if (prev != &lazy_load_driver) { /* another thread beat us to it */ HeapFree( GetProcessHeap(), 0, driver ); driver = prev; } else LdrAddRefDll( 0, graphics_driver ); DeleteDC( hdc ); return driver; }
/*********************************************************************** * create_icon_from_bmi * * Create an icon from its BITMAPINFO. */ static HICON create_icon_from_bmi( const BITMAPINFO *bmi, DWORD maxsize, HMODULE module, LPCWSTR resname, HRSRC rsrc, POINT hotspot, BOOL bIcon, INT width, INT height, UINT cFlag ) { DWORD size, color_size, mask_size; HBITMAP color = 0, mask = 0, alpha = 0; const void *color_bits, *mask_bits; BITMAPINFO *bmi_copy; BOOL ret = FALSE; BOOL do_stretch; HICON hObj = 0; HDC hdc = 0; /* Check bitmap header */ if (maxsize < sizeof(BITMAPCOREHEADER)) { return 0; } if (maxsize < bmi->bmiHeader.biSize) { WARN( "invalid header size %u\n", bmi->bmiHeader.biSize ); return 0; } if ( (bmi->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) && (bmi->bmiHeader.biSize != sizeof(BITMAPINFOHEADER) || (bmi->bmiHeader.biCompression != BI_RGB && bmi->bmiHeader.biCompression != BI_BITFIELDS)) ) { WARN( "invalid bitmap header %u\n", bmi->bmiHeader.biSize ); return 0; } size = bitmap_info_size( bmi, DIB_RGB_COLORS ); color_size = get_dib_image_size( bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight / 2, bmi->bmiHeader.biBitCount ); mask_size = get_dib_image_size( bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight / 2, 1 ); if (size > maxsize || color_size > maxsize - size) { WARN( "truncated file %u < %u+%u+%u\n", maxsize, size, color_size, mask_size ); return 0; } if (mask_size > maxsize - size - color_size) mask_size = 0; /* no mask */ if (cFlag & LR_DEFAULTSIZE) { if (!width) width = GetSystemMetrics( bIcon ? SM_CXICON : SM_CXCURSOR ); if (!height) height = GetSystemMetrics( bIcon ? SM_CYICON : SM_CYCURSOR ); } else { if (!width) width = bmi->bmiHeader.biWidth; if (!height) height = bmi->bmiHeader.biHeight/2; } do_stretch = (bmi->bmiHeader.biHeight/2 != height) || (bmi->bmiHeader.biWidth != width); /* Scale the hotspot */ if (bIcon) { hotspot.x = width / 2; hotspot.y = height / 2; } else if (do_stretch) { hotspot.x = (hotspot.x * width) / bmi->bmiHeader.biWidth; hotspot.y = (hotspot.y * height) / (bmi->bmiHeader.biHeight / 2); } if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL ); if (!screen_dc) return 0; if (!(bmi_copy = (BITMAPINFO*)HeapAlloc( GetProcessHeap(), 0, max( size, FIELD_OFFSET( BITMAPINFO, bmiColors[2] ))))) return 0; if (!(hdc = CreateCompatibleDC( 0 ))) goto done; memcpy( bmi_copy, bmi, size ); bmi_copy->bmiHeader.biHeight /= 2; color_bits = (const char*)bmi + size; mask_bits = (const char*)color_bits + color_size; alpha = 0; if (is_dib_monochrome( bmi )) { if (!(mask = CreateBitmap( width, height * 2, 1, 1, NULL ))) goto done; color = 0; /* copy color data into second half of mask bitmap */ SelectObject( hdc, mask ); StretchDIBits( hdc, 0, height, width, height, 0, 0, bmi_copy->bmiHeader.biWidth, bmi_copy->bmiHeader.biHeight, color_bits, bmi_copy, DIB_RGB_COLORS, SRCCOPY ); } else { if (!(mask = CreateBitmap( width, height, 1, 1, NULL ))) goto done; if (!(color = CreateBitmap( width, height, GetDeviceCaps( screen_dc, PLANES ), GetDeviceCaps( screen_dc, BITSPIXEL ), NULL ))) { DeleteObject( mask ); goto done; } SelectObject( hdc, color ); StretchDIBits( hdc, 0, 0, width, height, 0, 0, bmi_copy->bmiHeader.biWidth, bmi_copy->bmiHeader.biHeight, color_bits, bmi_copy, DIB_RGB_COLORS, SRCCOPY ); if (bmi_has_alpha( bmi_copy, color_bits )) alpha = create_alpha_bitmap(bmi_copy, color_bits ,width,height); /* convert info to monochrome to copy the mask */ bmi_copy->bmiHeader.biBitCount = 1; if (bmi_copy->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) { RGBQUAD *rgb = bmi_copy->bmiColors; bmi_copy->bmiHeader.biClrUsed = bmi_copy->bmiHeader.biClrImportant = 2; rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00; rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff; rgb[0].rgbReserved = rgb[1].rgbReserved = 0; } else { RGBTRIPLE *rgb = (RGBTRIPLE *)(((BITMAPCOREHEADER *)bmi_copy) + 1); rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00; rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff; } } if (mask_size) { SelectObject( hdc, mask ); StretchDIBits( hdc, 0, 0, width, height, 0, 0, bmi_copy->bmiHeader.biWidth, bmi_copy->bmiHeader.biHeight, mask_bits, bmi_copy, DIB_RGB_COLORS, SRCCOPY ); } ret = TRUE; done: DeleteDC( hdc ); HeapFree( GetProcessHeap(), 0, bmi_copy ); if(ret) { ICONINFO iconInfo={0}; iconInfo.fIcon=bIcon; iconInfo.xHotspot=hotspot.x; iconInfo.yHotspot=hotspot.y; if(alpha) { iconInfo.hbmColor=alpha; iconInfo.hbmMask=mask; } else { iconInfo.hbmColor=color; iconInfo.hbmMask=mask; } hObj=CreateIconIndirect(&iconInfo); if(color) DeleteObject( color ); if(alpha) DeleteObject( alpha ); if(mask) DeleteObject( mask ); } return hObj; }
/********************************************************************** * CreateEnhMetaFileW (GDI32.@) */ HDC WINAPI CreateEnhMetaFileW( HDC hdc, /* [in] optional reference DC */ LPCWSTR filename, /* [in] optional filename for disk metafiles */ const RECT* rect, /* [in] optional bounding rectangle */ LPCWSTR description /* [in] optional description */ ) { static const WCHAR displayW[] = {'D','I','S','P','L','A','Y',0}; HDC ret; DC *dc; HDC hRefDC = hdc ? hdc : CreateDCW(displayW,NULL,NULL,NULL); /* If no ref, use current display */ EMFDRV_PDEVICE *physDev; HANDLE hFile; DWORD size = 0, length = 0; TRACE("%s\n", debugstr_w(filename) ); if (!(dc = alloc_dc_ptr( &EMFDRV_Funcs, OBJ_ENHMETADC ))) return 0; physDev = HeapAlloc(GetProcessHeap(),0,sizeof(*physDev)); if (!physDev) { free_dc_ptr( dc ); return 0; } dc->physDev = (PHYSDEV)physDev; physDev->hdc = dc->hSelf; if(description) { /* App name\0Title\0\0 */ length = lstrlenW(description); length += lstrlenW(description + length + 1); length += 3; length *= 2; } size = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4; if (!(physDev->emh = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size))) { HeapFree( GetProcessHeap(), 0, physDev ); free_dc_ptr( dc ); return 0; } physDev->handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, HANDLE_LIST_INC * sizeof(physDev->handles[0])); physDev->handles_size = HANDLE_LIST_INC; physDev->cur_handles = 1; physDev->hFile = 0; physDev->horzres = GetDeviceCaps(hRefDC, HORZRES); physDev->vertres = GetDeviceCaps(hRefDC, VERTRES); physDev->logpixelsx = GetDeviceCaps(hRefDC, LOGPIXELSX); physDev->logpixelsy = GetDeviceCaps(hRefDC, LOGPIXELSY); physDev->horzsize = GetDeviceCaps(hRefDC, HORZSIZE); physDev->vertsize = GetDeviceCaps(hRefDC, VERTSIZE); physDev->bitspixel = GetDeviceCaps(hRefDC, BITSPIXEL); physDev->textcaps = GetDeviceCaps(hRefDC, TEXTCAPS); physDev->rastercaps = GetDeviceCaps(hRefDC, RASTERCAPS); physDev->technology = GetDeviceCaps(hRefDC, TECHNOLOGY); physDev->planes = GetDeviceCaps(hRefDC, PLANES); physDev->numcolors = GetDeviceCaps(hRefDC, NUMCOLORS); physDev->restoring = 0; SetVirtualResolution(dc->hSelf, 0, 0, 0, 0); physDev->emh->iType = EMR_HEADER; physDev->emh->nSize = size; physDev->emh->rclBounds.left = physDev->emh->rclBounds.top = 0; physDev->emh->rclBounds.right = physDev->emh->rclBounds.bottom = -1; if(rect) { physDev->emh->rclFrame.left = rect->left; physDev->emh->rclFrame.top = rect->top; physDev->emh->rclFrame.right = rect->right; physDev->emh->rclFrame.bottom = rect->bottom; } else { /* Set this to {0,0 - -1,-1} and update it at the end */ physDev->emh->rclFrame.left = physDev->emh->rclFrame.top = 0; physDev->emh->rclFrame.right = physDev->emh->rclFrame.bottom = -1; } physDev->emh->dSignature = ENHMETA_SIGNATURE; physDev->emh->nVersion = 0x10000; physDev->emh->nBytes = physDev->emh->nSize; physDev->emh->nRecords = 1; physDev->emh->nHandles = 1; physDev->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */ physDev->emh->nDescription = length / 2; physDev->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0; physDev->emh->nPalEntries = 0; /* I guess this should start at 0 */ /* Size in pixels */ physDev->emh->szlDevice.cx = physDev->horzres; physDev->emh->szlDevice.cy = physDev->vertres; /* Size in millimeters */ physDev->emh->szlMillimeters.cx = physDev->horzsize; physDev->emh->szlMillimeters.cy = physDev->vertsize; /* Size in micrometers */ physDev->emh->szlMicrometers.cx = physDev->horzsize * 1000; physDev->emh->szlMicrometers.cy = physDev->vertsize * 1000; memcpy((char *)physDev->emh + sizeof(ENHMETAHEADER), description, length); if (filename) /* disk based metafile */ { if ((hFile = CreateFileW(filename, GENERIC_WRITE | GENERIC_READ, 0, NULL, CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) { EMFDRV_DeleteDC( dc ); return 0; } if (!WriteFile( hFile, physDev->emh, size, NULL, NULL )) { EMFDRV_DeleteDC( dc ); return 0; } physDev->hFile = hFile; } TRACE("returning %p\n", dc->hSelf); ret = dc->hSelf; release_dc_ptr( dc ); if( !hdc ) DeleteDC( hRefDC ); return ret; }