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