void Test_Pen(void) { LOGPEN logpen; HPEN hPen; FillMemory(&logpen, sizeof(LOGPEN), 0x77); hPen = CreatePen(PS_SOLID, 3, RGB(4,5,6)); ok(hPen != 0, "CreatePen failed, skipping tests.\n"); if (!hPen) return; SetLastError(ERROR_SUCCESS); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_PEN, 0, NULL) == sizeof(LOGPEN), "\n"); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_PEN, 0, NULL) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, sizeof(BITMAP), NULL) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, 0, NULL) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, 5, NULL) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, -5, NULL) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, sizeof(LOGPEN), &logpen) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, sizeof(LOGPEN)-1, &logpen) == 0, "\n"); ok(GetObject(hPen, sizeof(LOGPEN)+2, &logpen) == sizeof(LOGPEN), "\n"); ok(GetObject(hPen, 0, &logpen) == 0, "\n"); ok(GetObject(hPen, -5, &logpen) == sizeof(LOGPEN), "\n"); //ok(GetLastError() == ERROR_SUCCESS, "\n"); fails on win7 /* test if the fields are filled correctly */ ok(logpen.lopnStyle == PS_SOLID, "\n"); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_PEN, sizeof(LOGPEN), &logpen) == 0, "\n"); ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError()); DeleteObject(hPen); }
/****************************************************************** * EMFDRV_CreatePenIndirect */ static DWORD EMFDRV_CreatePenIndirect(PHYSDEV dev, HPEN hPen) { EMRCREATEPEN emr; DWORD index = 0; if (!GetObjectW( hPen, sizeof(emr.lopn), &emr.lopn )) { /* must be an extended pen */ EXTLOGPEN *elp; INT size = GetObjectW( hPen, 0, NULL ); if (!size) return 0; elp = HeapAlloc( GetProcessHeap(), 0, size ); GetObjectW( hPen, size, elp ); /* FIXME: add support for user style pens */ emr.lopn.lopnStyle = elp->elpPenStyle; emr.lopn.lopnWidth.x = elp->elpWidth; emr.lopn.lopnWidth.y = 0; emr.lopn.lopnColor = elp->elpColor; HeapFree( GetProcessHeap(), 0, elp ); } emr.emr.iType = EMR_CREATEPEN; emr.emr.nSize = sizeof(emr); emr.ihPen = index = EMFDRV_AddHandle( dev, hPen ); if(!EMFDRV_WriteRecord( dev, &emr.emr )) index = 0; return index; }
void ME_MakeFirstParagraph(ME_TextEditor *editor) { ME_Context c; CHARFORMAT2W cf; LOGFONTW lf; HFONT hf; ME_TextBuffer *text = editor->pBuffer; ME_DisplayItem *para = make_para(editor); ME_DisplayItem *run; ME_Style *style; int eol_len; WCHAR cr_lf[] = {'\r','\n',0}; ME_InitContext(&c, editor, ITextHost_TxGetDC(editor->texthost)); hf = GetStockObject(SYSTEM_FONT); assert(hf); GetObjectW(hf, sizeof(LOGFONTW), &lf); ZeroMemory(&cf, sizeof(cf)); cf.cbSize = sizeof(cf); cf.dwMask = CFM_BACKCOLOR|CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_CHARSET; cf.dwMask |= CFM_ALLCAPS|CFM_BOLD|CFM_DISABLED|CFM_EMBOSS|CFM_HIDDEN; cf.dwMask |= CFM_IMPRINT|CFM_ITALIC|CFM_LINK|CFM_OUTLINE|CFM_PROTECTED; cf.dwMask |= CFM_REVISED|CFM_SHADOW|CFM_SMALLCAPS|CFM_STRIKEOUT; cf.dwMask |= CFM_SUBSCRIPT|CFM_UNDERLINETYPE|CFM_WEIGHT; cf.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR; lstrcpyW(cf.szFaceName, lf.lfFaceName); /* Convert system font height from logical units to twips for cf.yHeight */ cf.yHeight = (lf.lfHeight * 72 * 1440) / (c.dpi.cy * c.dpi.cy); if (lf.lfWeight > FW_NORMAL) cf.dwEffects |= CFE_BOLD; cf.wWeight = lf.lfWeight; if (lf.lfItalic) cf.dwEffects |= CFE_ITALIC; cf.bUnderlineType = (lf.lfUnderline) ? CFU_CF1UNDERLINE : CFU_UNDERLINENONE; if (lf.lfStrikeOut) cf.dwEffects |= CFE_STRIKEOUT; cf.bPitchAndFamily = lf.lfPitchAndFamily; cf.bCharSet = lf.lfCharSet; style = ME_MakeStyle(&cf); text->pDefaultStyle = style; eol_len = editor->bEmulateVersion10 ? 2 : 1; para->member.para.text = ME_MakeStringN( cr_lf, eol_len ); run = ME_MakeRun(style, MERF_ENDPARA); run->member.run.nCharOfs = 0; run->member.run.len = eol_len; run->member.run.para = ¶->member.para; ME_InsertBefore(text->pLast, para); ME_InsertBefore(text->pLast, run); para->member.para.prev_para = text->pFirst; para->member.para.next_para = text->pLast; text->pFirst->member.para.next_para = para; text->pLast->member.para.prev_para = para; text->pLast->member.para.nCharOfs = editor->bEmulateVersion10 ? 2 : 1; ME_DestroyContext(&c); }
static HRESULT WINAPI gdiinterop_CreateFontFaceFromHdc(IDWriteGdiInterop *iface, HDC hdc, IDWriteFontFace **fontface) { struct gdiinterop *This = impl_from_IDWriteGdiInterop(iface); IDWriteFont *font; LOGFONTW logfont; HFONT hfont; HRESULT hr; TRACE("(%p)->(%p %p)\n", This, hdc, fontface); *fontface = NULL; hfont = GetCurrentObject(hdc, OBJ_FONT); if (!hfont) return E_INVALIDARG; GetObjectW(hfont, sizeof(logfont), &logfont); hr = IDWriteGdiInterop_CreateFontFromLOGFONT(iface, &logfont, &font); if (FAILED(hr)) return hr; hr = IDWriteFont_CreateFontFace(font, fontface); IDWriteFont_Release(font); return hr; }
void Test_CreateFontIndirectW(void) { LOGFONTW logfont; HFONT hFont; ULONG ret; ENUMLOGFONTEXDVW elfedv2; logfont.lfHeight = 12; logfont.lfWidth = 0; logfont.lfEscapement = 0; logfont.lfOrientation = 0; logfont.lfWeight = FW_NORMAL; logfont.lfItalic = 0; logfont.lfUnderline = 0; logfont.lfStrikeOut = 0; logfont.lfCharSet = DEFAULT_CHARSET; logfont.lfOutPrecision = OUT_DEFAULT_PRECIS; logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS; logfont.lfQuality = PROOF_QUALITY; logfont.lfPitchAndFamily = DEFAULT_PITCH; memset(logfont.lfFaceName, 'A', LF_FACESIZE * 2); hFont = CreateFontIndirectW(&logfont); ok(hFont != 0, "CreateFontIndirectW failed\n"); memset(&elfedv2, 0, sizeof(elfedv2)); ret = GetObjectW(hFont, sizeof(elfedv2), &elfedv2); ok(ret == sizeof(ENUMLOGFONTEXW) + 2*sizeof(DWORD), "\n"); ok(elfedv2.elfEnumLogfontEx.elfLogFont.lfFaceName[LF_FACESIZE-1] == ((WCHAR)'A' << 8) + 'A', "\n"); ok(elfedv2.elfEnumLogfontEx.elfFullName[0] == 0, "\n"); /* Theres a bunch of data in elfFullName ... */ }
void CBrandBand::SelectImage() { int screenDepth; RECT clientRect; int clientWidth; int clientHeight; int clientSize; HINSTANCE shell32Instance; BITMAP bitmapInfo; int resourceID; screenDepth = SHGetCurColorRes(); GetClientRect(&clientRect); clientWidth = clientRect.right - clientRect.left; clientHeight = clientRect.bottom - clientRect.top; clientSize = min(clientWidth, clientHeight); if (screenDepth > 8) resourceID = gTrueColorResourceBase; else resourceID = g256ColorResourceBase; if (clientSize >= gLargeImageSize) resourceID += 2; else if (clientSize >= gMediumImageSize) resourceID += 1; shell32Instance = GetModuleHandle(L"shell32.dll"); fImageBitmap = LoadBitmap(shell32Instance, MAKEINTRESOURCE(resourceID)); GetObjectW(fImageBitmap, sizeof(bitmapInfo), &bitmapInfo); fBitmapSize = bitmapInfo.bmWidth; fMaxFrameCount = bitmapInfo.bmHeight / fBitmapSize; }
/****************************************************************** * EMFDRV_CreateFontIndirect */ static BOOL EMFDRV_CreateFontIndirect(PHYSDEV dev, HFONT hFont ) { DWORD index = 0; EMREXTCREATEFONTINDIRECTW emr; int i; if (!GetObjectW( hFont, sizeof(emr.elfw.elfLogFont), &emr.elfw.elfLogFont )) return 0; emr.emr.iType = EMR_EXTCREATEFONTINDIRECTW; emr.emr.nSize = (sizeof(emr) + 3) / 4 * 4; emr.ihFont = index = EMFDRV_AddHandle( dev, hFont ); emr.elfw.elfFullName[0] = '\0'; emr.elfw.elfStyle[0] = '\0'; emr.elfw.elfVersion = 0; emr.elfw.elfStyleSize = 0; emr.elfw.elfMatch = 0; emr.elfw.elfReserved = 0; for(i = 0; i < ELF_VENDOR_SIZE; i++) emr.elfw.elfVendorId[i] = 0; emr.elfw.elfCulture = PAN_CULTURE_LATIN; emr.elfw.elfPanose.bFamilyType = PAN_NO_FIT; emr.elfw.elfPanose.bSerifStyle = PAN_NO_FIT; emr.elfw.elfPanose.bWeight = PAN_NO_FIT; emr.elfw.elfPanose.bProportion = PAN_NO_FIT; emr.elfw.elfPanose.bContrast = PAN_NO_FIT; emr.elfw.elfPanose.bStrokeVariation = PAN_NO_FIT; emr.elfw.elfPanose.bArmStyle = PAN_NO_FIT; emr.elfw.elfPanose.bLetterform = PAN_NO_FIT; emr.elfw.elfPanose.bMidline = PAN_NO_FIT; emr.elfw.elfPanose.bXHeight = PAN_NO_FIT; if(!EMFDRV_WriteRecord( dev, &emr.emr )) index = 0; return index; }
/* Prepare a bitmap to be used for alpha blending */ static BOOL prepare_alpha (HBITMAP bmp, BOOL* hasAlpha) { DIBSECTION dib; int n; BYTE* p; *hasAlpha = FALSE; if (!bmp || GetObjectW( bmp, sizeof(dib), &dib ) != sizeof(dib)) return FALSE; if(dib.dsBm.bmBitsPixel != 32) /* nothing to do */ return TRUE; *hasAlpha = TRUE; p = dib.dsBm.bmBits; n = dib.dsBmih.biHeight * dib.dsBmih.biWidth; /* AlphaBlend() wants premultiplied alpha, so do that now */ while (n-- > 0) { int a = p[3]+1; p[0] = (p[0] * a) >> 8; p[1] = (p[1] * a) >> 8; p[2] = (p[2] * a) >> 8; p += 4; } return TRUE; }
static void test_hatch_brush(void) { int i, size; HBRUSH brush; LOGBRUSH lb; for (i = 0; i < 20; i++) { SetLastError( 0xdeadbeef ); brush = CreateHatchBrush( i, RGB(12,34,56) ); if (i < HS_API_MAX) { ok( brush != 0, "%u: CreateHatchBrush failed err %u\n", i, GetLastError() ); size = GetObjectW( brush, sizeof(lb), &lb ); ok( size == sizeof(lb), "wrong size %u\n", size ); ok( lb.lbColor == RGB(12,34,56), "wrong color %08x\n", lb.lbColor ); if (i <= HS_DIAGCROSS) { ok( lb.lbStyle == BS_HATCHED, "wrong style %u\n", lb.lbStyle ); ok( lb.lbHatch == i, "wrong hatch %lu/%u\n", lb.lbHatch, i ); } else { ok( lb.lbStyle == BS_SOLID, "wrong style %u\n", lb.lbStyle ); ok( lb.lbHatch == 0, "wrong hatch %lu\n", lb.lbHatch ); } DeleteObject( brush ); } else { ok( !brush, "%u: CreateHatchBrush succeeded\n", i ); ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() ); } } }
/****************************************************************************** * CreateCompatibleBitmap [GDI32.@] * * Creates a bitmap compatible with the DC. * * PARAMS * hdc [I] Handle to device context * width [I] Width of bitmap * height [I] Height of bitmap * * RETURNS * Success: Handle to bitmap * Failure: 0 */ HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height) { char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )]; BITMAPINFO *bi = (BITMAPINFO *)buffer; DIBSECTION dib; TRACE("(%p,%d,%d)\n", hdc, width, height); if (GetObjectType( hdc ) != OBJ_MEMDC) return CreateBitmap( width, height, GetDeviceCaps(hdc, PLANES), GetDeviceCaps(hdc, BITSPIXEL), NULL ); switch (GetObjectW( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(dib), &dib )) { case sizeof(BITMAP): /* A device-dependent bitmap is selected in the DC */ return CreateBitmap( width, height, dib.dsBm.bmPlanes, dib.dsBm.bmBitsPixel, NULL ); case sizeof(DIBSECTION): /* A DIB section is selected in the DC */ bi->bmiHeader = dib.dsBmih; bi->bmiHeader.biWidth = width; bi->bmiHeader.biHeight = height; if (dib.dsBmih.biCompression == BI_BITFIELDS) /* copy the color masks */ memcpy(bi->bmiColors, dib.dsBitfields, sizeof(dib.dsBitfields)); else if (dib.dsBmih.biBitCount <= 8) /* copy the color table */ GetDIBColorTable(hdc, 0, 256, bi->bmiColors); return CreateDIBSection( hdc, bi, DIB_RGB_COLORS, NULL, NULL, 0 ); default: return 0; } }
/*********************************************************************** * dibdrv_SelectBrush */ HBRUSH CDECL dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush ) { PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectBrush ); dibdrv_physdev *pdev = get_dibdrv_pdev(dev); LOGBRUSH logbrush; TRACE("(%p, %p)\n", dev, hbrush); if (!GetObjectW( hbrush, sizeof(logbrush), &logbrush )) return 0; if (hbrush == GetStockObject( DC_BRUSH )) logbrush.lbColor = GetDCBrushColor( dev->hdc ); pdev->brush_style = logbrush.lbStyle; pdev->defer |= DEFER_BRUSH; free_pattern_brush( pdev ); switch(logbrush.lbStyle) { case BS_SOLID: pdev->brush_color = pdev->dib.funcs->colorref_to_pixel(&pdev->dib, logbrush.lbColor); calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor); pdev->brush_rects = solid_brush; pdev->defer &= ~DEFER_BRUSH; break; case BS_NULL: pdev->brush_rects = null_brush; pdev->defer &= ~DEFER_BRUSH; break; case BS_DIBPATTERN: { BITMAPINFOHEADER *bi = GlobalLock((HGLOBAL)logbrush.lbHatch); dib_info orig_dib; if(!bi) return NULL; if(init_dib_info_from_packed(&orig_dib, bi, LOWORD(logbrush.lbColor))) { copy_dib_color_info(&pdev->brush_dib, &pdev->dib); if(convert_dib(&pdev->brush_dib, &orig_dib)) { pdev->brush_rects = pattern_brush; pdev->defer &= ~DEFER_BRUSH; } free_dib_info(&orig_dib, FALSE); } GlobalUnlock((HGLOBAL)logbrush.lbHatch); break; } default: break; } return next->funcs->pSelectBrush( next, hbrush ); }
static void test_solidbrush(void) { static const STOCK_BRUSH stock[] = { {RGB(255,255,255), WHITE_BRUSH, "white"}, {RGB(192,192,192), LTGRAY_BRUSH, "ltgray"}, {RGB(128,128,128), GRAY_BRUSH, "gray"}, {RGB(0,0,0), BLACK_BRUSH, "black"}, {RGB(0,0,255), -1, "blue"} }; HBRUSH solidBrush; HBRUSH stockBrush; LOGBRUSH br; size_t i; INT ret; for(i = 0; i < ARRAY_SIZE(stock); i++) { solidBrush = CreateSolidBrush(stock[i].color); if(stock[i].stockobj != -1) { stockBrush = GetStockObject(stock[i].stockobj); ok(stockBrush!=solidBrush || broken(stockBrush==solidBrush), /* win9x does return stock object */ "Stock %s brush equals solid %s brush\n", stock[i].name, stock[i].name); } else stockBrush = NULL; memset(&br, 0, sizeof(br)); ret = GetObjectW(solidBrush, sizeof(br), &br); ok( ret !=0, "GetObject on solid %s brush failed, error=%d\n", stock[i].name, GetLastError()); ok(br.lbStyle==BS_SOLID, "%s brush has wrong style, got %d expected %d\n", stock[i].name, br.lbStyle, BS_SOLID); ok(br.lbColor==stock[i].color, "%s brush has wrong color, got 0x%08x expected 0x%08x\n", stock[i].name, br.lbColor, stock[i].color); if(stockBrush) { /* Sanity check, make sure the colors being compared do in fact have a stock brush */ ret = GetObjectW(stockBrush, sizeof(br), &br); ok( ret !=0, "GetObject on stock %s brush failed, error=%d\n", stock[i].name, GetLastError()); ok(br.lbColor==stock[i].color, "stock %s brush unexpected color, got 0x%08x expected 0x%08x\n", stock[i].name, br.lbColor, stock[i].color); } DeleteObject(solidBrush); ret = GetObjectW(solidBrush, sizeof(br), &br); ok(ret==0 || broken(ret!=0), /* win9x */ "GetObject succeeded on a deleted %s brush\n", stock[i].name); } }
static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate) { IPADDRESS_INFO *infoPtr; RECT rcClient, edit; int i, fieldsize; HFONT hFont, hSysFont; LOGFONTW logFont, logSysFont; TRACE("\n"); SetWindowLongW (hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER); infoPtr = heap_alloc_zero (sizeof(*infoPtr)); if (!infoPtr) return -1; SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr); GetClientRect (hwnd, &rcClient); fieldsize = (rcClient.right - rcClient.left) / 4; edit.top = rcClient.top + 2; edit.bottom = rcClient.bottom - 2; infoPtr->Self = hwnd; infoPtr->Enabled = TRUE; infoPtr->Notify = lpCreate->hwndParent; hSysFont = GetStockObject(ANSI_VAR_FONT); GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont); SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0); lstrcpyW(logFont.lfFaceName, logSysFont.lfFaceName); hFont = CreateFontIndirectW(&logFont); for (i = 0; i < 4; i++) { IPPART_INFO* part = &infoPtr->Part[i]; part->LowerLimit = 0; part->UpperLimit = 255; edit.left = rcClient.left + i*fieldsize + 6; edit.right = rcClient.left + (i+1)*fieldsize - 2; part->EditHwnd = CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER, edit.left, edit.top, edit.right - edit.left, edit.bottom - edit.top, hwnd, (HMENU) 1, (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL); SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE); SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd); part->OrigProc = (WNDPROC) SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)IPADDRESS_SubclassProc); EnableWindow(part->EditHwnd, infoPtr->Enabled); } IPADDRESS_UpdateText (infoPtr); return 0; }
/*********************************************************************** * MFDRV_SelectPen */ HPEN MFDRV_SelectPen( PHYSDEV dev, HPEN hpen ) { METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev; LOGPEN16 logpen; INT16 index; index = MFDRV_FindObject(dev, hpen); if( index < 0 ) { /* must be an extended pen */ INT size = GetObjectW( hpen, 0, NULL ); if (!size) return 0; if (size == sizeof(LOGPEN)) { LOGPEN pen; GetObjectW( hpen, sizeof(pen), &pen ); logpen.lopnStyle = pen.lopnStyle; logpen.lopnWidth.x = pen.lopnWidth.x; logpen.lopnWidth.y = pen.lopnWidth.y; logpen.lopnColor = pen.lopnColor; } else /* must be an extended pen */ { EXTLOGPEN *elp = HeapAlloc( GetProcessHeap(), 0, size ); GetObjectW( hpen, size, elp ); /* FIXME: add support for user style pens */ logpen.lopnStyle = elp->elpPenStyle; logpen.lopnWidth.x = elp->elpWidth; logpen.lopnWidth.y = 0; logpen.lopnColor = elp->elpColor; HeapFree( GetProcessHeap(), 0, elp ); } index = MFDRV_CreatePenIndirect( dev, hpen, &logpen ); if( index < 0 ) return 0; GDI_hdc_using_object(hpen, physDev->hdc); } return MFDRV_SelectObject( dev, index ) ? hpen : HGDI_ERROR; }
/* * Message Action Function */ LRESULT MainWindow::OnCreate(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandle) { auto hr = Initialize(); if (hr != S_OK) { ::MessageBoxW(nullptr, L"Initialize() failed", L"Fatal error", MB_OK | MB_ICONSTOP); std::terminate(); return S_FALSE; } HICON hIcon = LoadIconW(GetModuleHandleW(nullptr), MAKEINTRESOURCEW(IDI_CLANGBUILDERUI)); SetIcon(hIcon, TRUE); HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT); LOGFONTW logFont = { 0 }; GetObjectW(hFont, sizeof(logFont), &logFont); DeleteObject(hFont); hFont = NULL; logFont.lfHeight = 19; logFont.lfWeight = FW_NORMAL; wcscpy_s(logFont.lfFaceName, L"Segoe UI"); hFont = CreateFontIndirectW(&logFont); auto LambdaCreateWindow = [&](LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HMENU hMenu)->HWND{ auto hw = CreateWindowExW(WINDOWEXSTYLE, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, m_hWnd, hMenu, HINST_THISCOMPONENT, nullptr); if (hw) { ::SendMessageW(hw, WM_SETFONT, (WPARAM)hFont, lParam); } return hw; }; hCobVS_ = LambdaCreateWindow(WC_COMBOBOXW, L"", COMBOBOXSTYLE, 200, 20, 400, 30, nullptr); hCobArch_ = LambdaCreateWindow(WC_COMBOBOXW, L"", COMBOBOXSTYLE, 200, 60, 400, 30, nullptr); hCobFlavor_ = LambdaCreateWindow(WC_COMBOBOXW, L"", COMBOBOXSTYLE, 200, 100, 400, 30, nullptr); hCheckBoostrap_ = LambdaCreateWindow(WC_BUTTONW, L"Clang Boostrap", CHECKBOXSTYLE, 200, 160, 360, 27, nullptr); hCheckReleased_ = LambdaCreateWindow(WC_BUTTONW, L"Released Revision", CHECKBOXSTYLE, 200, 190, 360, 27, nullptr); hCheckPackaged_ = LambdaCreateWindow(WC_BUTTONW, L"Make installation package", CHECKBOXSTYLE, 200, 220, 360, 27, nullptr); hCheckCleanEnv_ = LambdaCreateWindow(WC_BUTTONW, L"Use Clean Environment", CHECKBOXSTYLE, 200, 250, 360, 27, nullptr); hCheckLink_ = LambdaCreateWindow(WC_BUTTONW, L"Link Static Runtime Library", CHECKBOXSTYLE, 200, 280, 360, 27, nullptr); hCheckNMake_ = LambdaCreateWindow(WC_BUTTONW, L"Use NMake Makefiles", CHECKBOXSTYLE, 200, 310, 360, 27, nullptr); hCheckLLDB_ = LambdaCreateWindow(WC_BUTTONW, L"Build LLDB (Visual Studio 2015 or Later)", CHECKBOXSTYLE, 200, 340, 360, 27, nullptr); //Button_SetElevationRequiredState hButtonTask_ = LambdaCreateWindow(WC_BUTTONW, L"Build Now", PUSHBUTTONSTYLE, 200, 395, 195, 30, (HMENU)IDC_BUTTON_STARTTASK); hButtonEnv_ = LambdaCreateWindow(WC_BUTTONW, L"Startup Env", PUSHBUTTONSTYLE | BS_ICON, 410, 395, 195, 30, (HMENU)IDC_BUTTON_STARTENV); HMENU hSystemMenu = ::GetSystemMenu(m_hWnd, FALSE); InsertMenuW(hSystemMenu, SC_CLOSE, MF_ENABLED, IDM_CLANGBUILDER_ABOUT, L"About ClangbuilderUI\tAlt+F1"); label_.push_back(KryceLabel(30, 20, 190, 50, L"Visual Studio\t\xD83C\xDD9A:")); label_.push_back(KryceLabel(30, 60, 190, 90, L"Address Mode\t\xD83D\xDEE0:")); label_.push_back(KryceLabel(30, 100, 190, 130, L"Configuration\t\x2699:")); label_.push_back(KryceLabel(30, 160, 190, 200, L"Compile Switch\t\xD83D\xDCE6:")); /// if (!InitializeControl()) { } //DeleteObject(hFont); return S_OK; }
static HICON16 convert_icon_to_16( HINSTANCE16 inst, HICON icon ) { static HICON16 (WINAPI *pCreateIcon16)(HINSTANCE16,INT16,INT16,BYTE,BYTE,LPCVOID,LPCVOID); ICONINFO info; BITMAP bm; UINT and_size, xor_size; void *xor_bits = NULL, *and_bits; HICON16 handle = 0; if (!pCreateIcon16 && !(pCreateIcon16 = (void *)GetProcAddress( GetModuleHandleA("user.exe16"), "CreateIcon16" ))) return 0; if (!(GetIconInfo( icon, &info ))) return 0; GetObjectW( info.hbmMask, sizeof(bm), &bm ); and_size = bm.bmHeight * bm.bmWidthBytes; if (!(and_bits = HeapAlloc( GetProcessHeap(), 0, and_size ))) goto done; GetBitmapBits( info.hbmMask, and_size, and_bits ); if (info.hbmColor) { GetObjectW( info.hbmColor, sizeof(bm), &bm ); xor_size = bm.bmHeight * bm.bmWidthBytes; if (!(xor_bits = HeapAlloc( GetProcessHeap(), 0, xor_size ))) goto done; GetBitmapBits( info.hbmColor, xor_size, xor_bits ); } else { bm.bmHeight /= 2; xor_bits = (char *)and_bits + and_size / 2; } handle = pCreateIcon16( inst, bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel, and_bits, xor_bits ); done: HeapFree( GetProcessHeap(), 0, and_bits ); if (info.hbmColor) { HeapFree( GetProcessHeap(), 0, xor_bits ); DeleteObject( info.hbmColor ); } DeleteObject( info.hbmMask ); DestroyIcon( icon ); return handle; }
/*! Returns a QPixmap that is equivalent to the given \a bitmap. The conversion is based on the specified \a format. \warning This function is only available on Windows. \sa toWinHBITMAP(), {QPixmap#Pixmap Conversion}{Pixmap Conversion} */ QPixmap QPixmap::fromWinHBITMAP(HBITMAP bitmap, HBitmapFormat format) { // Verify size BITMAP bitmap_info; memset(&bitmap_info, 0, sizeof(BITMAP)); int res; QT_WA({ res = GetObjectW(bitmap, sizeof(BITMAP), &bitmap_info); } , {
void Test_Region(void) { HRGN hRgn; hRgn = CreateRectRgn(0,0,5,5); SetLastError(ERROR_SUCCESS); ok(GetObjectW(hRgn, 0, NULL) == 0, "\n"); ok(GetLastError() == ERROR_INVALID_HANDLE, "\n"); DeleteObject(hRgn); }
/*********************************************************************** * WinGGetDIBPointer (WING32.@) */ void * WINAPI WinGGetDIBPointer( HBITMAP hbmp, BITMAPINFO *bmi ) { DIBSECTION ds; if (GetObjectW( hbmp, sizeof(ds), &ds ) == sizeof(ds)) { memcpy( &bmi->bmiHeader, &ds.dsBmih, sizeof(*bmi) ); return ds.dsBm.bmBits; } return NULL; }
static void HH_CreateFont(HHInfo *pHHInfo) { LOGFONTW lf; GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf); lf.lfWeight = FW_NORMAL; lf.lfItalic = FALSE; lf.lfUnderline = FALSE; pHHInfo->hFont = CreateFontIndirectW(&lf); }
/* nulldrv fallback implementation using StretchDIBits */ BOOL CDECL nulldrv_StretchBlt( PHYSDEV dst_dev, INT xDst, INT yDst, INT widthDst, INT heightDst, PHYSDEV src_dev, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, DWORD rop ) { DC *dc = get_nulldrv_dc( dst_dev ); BITMAP bm; BITMAPINFOHEADER info_hdr; HBITMAP hbm; LPVOID bits; INT lines; POINT pts[2]; /* make sure we have a real implementation for StretchDIBits */ if (GET_DC_PHYSDEV( dc, pStretchDIBits ) == dst_dev) return 0; pts[0].x = xSrc; pts[0].y = ySrc; pts[1].x = xSrc + widthSrc; pts[1].y = ySrc + heightSrc; LPtoDP( src_dev->hdc, pts, 2 ); xSrc = pts[0].x; ySrc = pts[0].y; widthSrc = pts[1].x - pts[0].x; heightSrc = pts[1].y - pts[0].y; if (GetObjectType( src_dev->hdc ) != OBJ_MEMDC) return FALSE; if (!GetObjectW( GetCurrentObject( src_dev->hdc, OBJ_BITMAP ), sizeof(bm), &bm )) return FALSE; info_hdr.biSize = sizeof(info_hdr); info_hdr.biWidth = bm.bmWidth; info_hdr.biHeight = bm.bmHeight; info_hdr.biPlanes = 1; info_hdr.biBitCount = 32; info_hdr.biCompression = BI_RGB; info_hdr.biSizeImage = 0; info_hdr.biXPelsPerMeter = 0; info_hdr.biYPelsPerMeter = 0; info_hdr.biClrUsed = 0; info_hdr.biClrImportant = 0; if (!(bits = HeapAlloc(GetProcessHeap(), 0, bm.bmHeight * bm.bmWidth * 4))) return FALSE; /* Select out the src bitmap before calling GetDIBits */ hbm = SelectObject( src_dev->hdc, GetStockObject(DEFAULT_BITMAP) ); lines = GetDIBits( src_dev->hdc, hbm, 0, bm.bmHeight, bits, (BITMAPINFO*)&info_hdr, DIB_RGB_COLORS ); SelectObject( src_dev->hdc, hbm ); if (lines) lines = StretchDIBits( dst_dev->hdc, xDst, yDst, widthDst, heightDst, xSrc, bm.bmHeight - heightSrc - ySrc, widthSrc, heightSrc, bits, (BITMAPINFO*)&info_hdr, DIB_RGB_COLORS, rop ); HeapFree( GetProcessHeap(), 0, bits ); return (lines == heightSrc); }
void Test_Bitmap(void) { HBITMAP hBitmap; BITMAP bitmap; DIBSECTION dibsection; BYTE bData[100] = {0}; BYTE Buffer[100] = {48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,0}; FillMemory(&bitmap, sizeof(BITMAP), 0x77); hBitmap = CreateBitmap(10,10,1,8,bData); ok(hBitmap != 0, "CreateBitmap failed, skipping tests.\n"); if (!hBitmap) return; SetLastError(ERROR_SUCCESS); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_BITMAP, 0, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_BITMAP, 0, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_BITMAP, sizeof(BITMAP), NULL) == sizeof(BITMAP), "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); ok(GetObjectA(hBitmap, sizeof(DIBSECTION), NULL) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, 0, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectA((HANDLE)((UINT_PTR)hBitmap & 0x0000ffff), 0, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectW((HANDLE)((UINT_PTR)hBitmap & 0x0000ffff), 0, NULL) == sizeof(BITMAP), "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); ok(GetObjectA(hBitmap, 5, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, -5, NULL) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, 0, Buffer) == 0, "\n"); ok(GetObjectA(hBitmap, 5, Buffer) == 0, "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); ok(GetObjectA(hBitmap, sizeof(BITMAP), &bitmap) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, sizeof(BITMAP)+2, &bitmap) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, sizeof(DIBSECTION), &dibsection) == sizeof(BITMAP), "\n"); ok(GetObjectA(hBitmap, -5, &bitmap) == sizeof(BITMAP), "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_BITMAP, sizeof(BITMAP), &bitmap) == 0, "\n"); ok(GetLastError() == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %ld\n", GetLastError()); // todo: test invalid handle + buffer DeleteObject(hBitmap); }
NTSTATUS WINAPI User32CallOBMFromKernel(PVOID Arguments, ULONG ArgumentLength) { BITMAP bmp; PSETOBM_CALLBACK_ARGUMENTS Common = Arguments; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE)), sizeof(bmp), &bmp); Common->oembmi[OBI_CLOSE].cx = bmp.bmWidth; Common->oembmi[OBI_CLOSE].cy = bmp.bmHeight; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW)), sizeof(bmp), &bmp); Common->oembmi[OBI_MNARROW].cx = bmp.bmWidth; Common->oembmi[OBI_MNARROW].cy = bmp.bmHeight; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROW)), sizeof(bmp), &bmp); Common->oembmi[OBI_DNARROW].cx = bmp.bmWidth; Common->oembmi[OBI_DNARROW].cy = bmp.bmHeight; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROWI)), sizeof(bmp), &bmp); Common->oembmi[OBI_DNARROWI].cx = bmp.bmWidth; Common->oembmi[OBI_DNARROWI].cy = bmp.bmHeight; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROW)), sizeof(bmp), &bmp); Common->oembmi[OBI_UPARROW].cx = bmp.bmWidth; Common->oembmi[OBI_UPARROW].cy = bmp.bmHeight; GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROWI)), sizeof(bmp), &bmp); Common->oembmi[OBI_UPARROWI].cx = bmp.bmWidth; Common->oembmi[OBI_UPARROWI].cy = bmp.bmHeight; return ZwCallbackReturn(Arguments, ArgumentLength, STATUS_SUCCESS); }
void DWriteContext::SetFont(HFONT hFont) { if (mLastHFont != hFont) { LOGFONTW lf; if (GetObjectW(hFont, sizeof(lf), &lf)) { SetFont(lf); mLastHFont = hFont; } } }
void Test_Palette(void) { LOGPALETTE logpal; HPALETTE hPalette; WORD wPalette; FillMemory(&wPalette, sizeof(WORD), 0x77); logpal.palVersion = 0x0300; logpal.palNumEntries = 1; logpal.palPalEntry[0].peRed = 0; logpal.palPalEntry[0].peGreen = 0; logpal.palPalEntry[0].peBlue = 0; logpal.palPalEntry[0].peFlags = PC_EXPLICIT; hPalette = CreatePalette(&logpal); ok(hPalette != 0, "CreatePalette failed, skipping tests.\n"); if (!hPalette) return; ok(GetObjectA((HANDLE)((UINT_PTR)hPalette & 0x0000ffff), 0, NULL) == sizeof(WORD), "\n"); ok(GetObjectW((HANDLE)((UINT_PTR)hPalette & 0x0000ffff), 0, NULL) == sizeof(WORD), "\n"); SetLastError(ERROR_SUCCESS); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_PALETTE, 0, NULL) == sizeof(WORD), "\n"); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_PALETTE, 0, NULL) == sizeof(WORD), "\n"); ok(GetObject(hPalette, sizeof(WORD), NULL) == sizeof(WORD), "\n"); ok(GetObject(hPalette, 0, NULL) == sizeof(WORD), "\n"); ok(GetObject(hPalette, 5, NULL) == sizeof(WORD), "\n"); ok(GetObject(hPalette, -5, NULL) == sizeof(WORD), "\n"); ok(GetObject(hPalette, sizeof(WORD), &wPalette) == sizeof(WORD), "\n"); ok(GetObject(hPalette, sizeof(WORD)+2, &wPalette) == sizeof(WORD), "\n"); ok(GetObject(hPalette, 0, &wPalette) == 0, "\n"); ok(GetObject(hPalette, 1, &wPalette) == 0, "\n"); ok(GetObject(hPalette, -1, &wPalette) == sizeof(WORD), "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); DeleteObject(hPalette); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_PALETTE, sizeof(WORD), &wPalette) == 0, "\n"); ok(GetLastError() == ERROR_SUCCESS, "\n"); }
void Test_Brush(void) { LOGBRUSH logbrush; HBRUSH hBrush; FillMemory(&logbrush, sizeof(LOGBRUSH), 0x77); hBrush = CreateSolidBrush(RGB(1,2,3)); ok(hBrush != 0, "CreateSolidBrush failed, skipping tests.\n"); if (!hBrush) return; SetLastError(ERROR_SUCCESS); ok(GetObjectA((HANDLE)GDI_OBJECT_TYPE_BRUSH, 0, NULL) == sizeof(LOGBRUSH), "\n"); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_BRUSH, 0, NULL) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, sizeof(WORD), NULL) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, 0, NULL) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, 5, NULL) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, -5, NULL) == sizeof(LOGBRUSH), "\n"); //ok(GetObject(hBrush, 0, &logbrush) == 0, "\n"); fails on win7 ok(logbrush.lbStyle == 0x77777777, "\n"); ok(GetObject(hBrush, 5, &logbrush) == sizeof(LOGBRUSH), "\n"); ok(logbrush.lbStyle == 0, "\n"); ok(logbrush.lbColor == 0x77777701, "\n"); ok(GetObject(hBrush, sizeof(LOGBRUSH), &logbrush) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, sizeof(LOGBRUSH) - 1, &logbrush) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, 1, &logbrush) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, sizeof(LOGBRUSH)+2, &logbrush) == sizeof(LOGBRUSH), "\n"); ok(GetObject(hBrush, -1, &logbrush) == sizeof(LOGBRUSH), "\n"); // TODO: test all members ok(GetLastError() == ERROR_SUCCESS, "\n"); DeleteObject(hBrush); ok(GetObjectW((HANDLE)GDI_OBJECT_TYPE_BRUSH, sizeof(LOGBRUSH), &logbrush) == 0, "\n"); ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError()); }
static VOID GRPFILE_CalculateSizes(PROGRAM *program, INT *Progs, INT *Icons, UINT *sizeAnd, UINT *sizeXor) { ICONINFO info; BITMAP bmp; GetIconInfo( program->hIcon, &info ); GetObjectW( info.hbmMask, sizeof(bmp), &bmp ); *sizeAnd = bmp.bmHeight * ((bmp.bmWidth + 15) / 16 * 2); GetObjectW( info.hbmColor, sizeof(bmp), &bmp ); *sizeXor = bmp.bmHeight * bmp.bmWidthBytes; DeleteObject( info.hbmMask ); DeleteObject( info.hbmColor ); *Progs += 24; *Progs += lstrlen(LocalLock(program->hName)) + 1; *Progs += lstrlen(LocalLock(program->hCmdLine)) + 1; *Progs += lstrlen(LocalLock(program->hIconFile)) + 1; *Icons += 12; /* IconInfo */ *Icons += *sizeAnd; *Icons += *sizeXor; }
/*********************************************************************** * SYSLINK_SetFont * Set new Font for the SysLink control. */ static HFONT SYSLINK_SetFont (SYSLINK_INFO *infoPtr, HFONT hFont, BOOL bRedraw) { HDC hdc; LOGFONTW lf; TEXTMETRICW tm; RECT rcClient; HFONT hOldFont = infoPtr->Font; infoPtr->Font = hFont; /* free the underline font */ if(infoPtr->LinkFont != NULL) { DeleteObject(infoPtr->LinkFont); infoPtr->LinkFont = NULL; } /* Render text position and word wrapping in memory */ if (GetClientRect(infoPtr->Self, &rcClient)) { hdc = GetDC(infoPtr->Self); if(hdc != NULL) { /* create a new underline font */ if(GetTextMetricsW(hdc, &tm) && GetObjectW(infoPtr->Font, sizeof(LOGFONTW), &lf)) { lf.lfUnderline = TRUE; infoPtr->LinkFont = CreateFontIndirectW(&lf); infoPtr->BreakChar = tm.tmBreakChar; } else { ERR("Failed to create link font!\n"); } SYSLINK_Render(infoPtr, hdc, &rcClient); ReleaseDC(infoPtr->Self, hdc); } } if(bRedraw) { RedrawWindow(infoPtr->Self, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW); } return hOldFont; }
/*********************************************************************** * MFDRV_SelectFont */ HFONT MFDRV_SelectFont( PHYSDEV dev, HFONT hfont ) { LOGFONTW font; INT16 index; index = MFDRV_FindObject(dev, hfont); if( index < 0 ) { if (!GetObjectW( hfont, sizeof(font), &font )) return 0; index = MFDRV_CreateFontIndirect(dev, hfont, &font); if( index < 0 ) return 0; GDI_hdc_using_object(hfont, dev->hdc); } return MFDRV_SelectObject( dev, index ) ? hfont : 0; }
/********************************************************************** * BITMAP_CopyBitmap * */ HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap) { HBITMAP res = 0; BITMAP bm; if (!GetObjectW( hbitmap, sizeof(bm), &bm )) return 0; res = CreateBitmapIndirect(&bm); if(res) { char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight ); GetBitmapBits (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf); SetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf); HeapFree( GetProcessHeap(), 0, buf ); } return res; }