NTSTATUS
NTAPI
UserInitialize(VOID)
{
static const DWORD wPattern55AA[] = /* 32 bit aligned */
{ 0x55555555, 0xaaaaaaaa, 0x55555555, 0xaaaaaaaa,
0x55555555, 0xaaaaaaaa, 0x55555555, 0xaaaaaaaa };
HBITMAP hPattern55AABitmap = NULL;
NTSTATUS Status;
// Set W32PF_Flags |= (W32PF_READSCREENACCESSGRANTED | W32PF_IOWINSTA)
// Create Event for Diconnect Desktop.
Status = UserCreateWinstaDirectory();
if (!NT_SUCCESS(Status)) return Status;
/* Initialize Video */
Status = InitVideo();
if (!NT_SUCCESS(Status)) return Status;
// {
// DrvInitConsole.
// DrvChangeDisplaySettings.
// Update Shared Device Caps.
// Initialize User Screen.
// }
// Create ThreadInfo for this Thread!
// {
/* Initialize the current thread */
Status = InitThreadCallback(PsGetCurrentThread());
if (!NT_SUCCESS(Status)) return Status;
// }
// Set Global SERVERINFO Error flags.
// Load Resources.
NtUserUpdatePerUserSystemParameters(0, TRUE);
if (gpsi->hbrGray == NULL)
{
hPattern55AABitmap = GreCreateBitmap(8, 8, 1, 1, (LPBYTE)wPattern55AA);
gpsi->hbrGray = IntGdiCreatePatternBrush(hPattern55AABitmap);
GreDeleteObject(hPattern55AABitmap);
GreSetBrushOwner(gpsi->hbrGray, GDI_OBJ_HMGR_PUBLIC);
}
return STATUS_SUCCESS;
}
/*!
* Creates a bunch of stock objects: brushes, pens, fonts.
*/
VOID FASTCALL
CreateStockObjects(void)
{
UINT Object;
DPRINT("Beginning creation of stock objects\n");
/* Create GDI Stock Objects from the logical structures we've defined */
StockObjects[WHITE_BRUSH] = IntGdiCreateSolidBrush(RGB(255,255,255));
StockObjects[DC_BRUSH] = IntGdiCreateSolidBrush(RGB(255,255,255));
StockObjects[LTGRAY_BRUSH] = IntGdiCreateSolidBrush(RGB(192,192,192));
StockObjects[GRAY_BRUSH] = IntGdiCreateSolidBrush(RGB(128,128,128));
StockObjects[DKGRAY_BRUSH] = IntGdiCreateSolidBrush(RGB(64,64,64));
StockObjects[BLACK_BRUSH] = IntGdiCreateSolidBrush(RGB(0,0,0));
StockObjects[NULL_BRUSH] = IntGdiCreateNullBrush();
StockObjects[WHITE_PEN] = IntCreateStockPen(WhitePen.lopnStyle, WhitePen.lopnWidth.x, BS_SOLID, WhitePen.lopnColor);
StockObjects[BLACK_PEN] = IntCreateStockPen(BlackPen.lopnStyle, BlackPen.lopnWidth.x, BS_SOLID, BlackPen.lopnColor);
StockObjects[DC_PEN] = IntCreateStockPen(BlackPen.lopnStyle, BlackPen.lopnWidth.x, BS_SOLID, BlackPen.lopnColor);
StockObjects[NULL_PEN] = IntCreateStockPen(NullPen.lopnStyle, NullPen.lopnWidth.x, BS_SOLID, NullPen.lopnColor);
StockObjects[20] = NULL; /* TODO: Unknown internal stock object */
StockObjects[DEFAULT_BITMAP] = GreCreateBitmap(1, 1, 1, 1, NULL);
(void) TextIntCreateFontIndirect(&OEMFixedFont, (HFONT*)&StockObjects[OEM_FIXED_FONT]);
(void) TextIntCreateFontIndirect(&AnsiFixedFont, (HFONT*)&StockObjects[ANSI_FIXED_FONT]);
(void) TextIntCreateFontIndirect(&AnsiVarFont, (HFONT*)&StockObjects[ANSI_VAR_FONT]);
(void) TextIntCreateFontIndirect(&SystemFont, (HFONT*)&StockObjects[SYSTEM_FONT]);
(void) TextIntCreateFontIndirect(&DeviceDefaultFont, (HFONT*)&StockObjects[DEVICE_DEFAULT_FONT]);
(void) TextIntCreateFontIndirect(&SystemFixedFont, (HFONT*)&StockObjects[SYSTEM_FIXED_FONT]);
(void) TextIntCreateFontIndirect(&DefaultGuiFont, (HFONT*)&StockObjects[DEFAULT_GUI_FONT]);
StockObjects[DEFAULT_PALETTE] = (HGDIOBJ)gppalDefault->BaseObject.hHmgr;
for (Object = 0; Object < NB_STOCK_OBJECTS; Object++)
{
if (NULL != StockObjects[Object])
{
GDIOBJ_ConvertToStockObj(&StockObjects[Object]);
}
}
DPRINT("Completed creation of stock objects\n");
}
BOOL _InternalGetIconInfo(
IN PCURSOR pcur,
OUT PICONINFO piconinfo,
OUT OPTIONAL PUNICODE_STRING pstrInstanceName,
OUT OPTIONAL PUNICODE_STRING pstrResName,
OUT OPTIONAL LPDWORD pbpp,
IN BOOL fInternalCursor)
{
HBITMAP hbmBitsT;
HBITMAP hbmDstT;
HBITMAP hbmMask;
HBITMAP hbmColor;
/*
* If this is an animated cursor, just grab the first frame and return
* the info for it.
*/
if (pcur->CURSORF_flags & CURSORF_ACON)
pcur = ((PACON)pcur)->aspcur[0];
/*
* Make copies of the bitmaps
*
* If the color bitmap is around, then there is no XOR mask in the
* hbmMask bitmap.
*/
hbmMask = GreCreateBitmap(
pcur->cx,
(pcur->hbmColor && !fInternalCursor) ? pcur->cy / 2 : pcur->cy,
1,
1,
NULL);
if (hbmMask == NULL)
return FALSE;
hbmColor = NULL;
if (pcur->hbmColor != NULL) {
hbmColor = GreCreateCompatibleBitmap(gpDispInfo->hdcBits,
pcur->cx,
pcur->cy / 2);
if (hbmColor == NULL) {
GreDeleteObject(hbmMask);
return FALSE;
}
}
hbmBitsT = GreSelectBitmap(ghdcMem2, pcur->hbmMask);
hbmDstT = GreSelectBitmap(ghdcMem, hbmMask);
GreBitBlt(ghdcMem,
0,
0,
pcur->cx,
(pcur->hbmColor && !fInternalCursor) ? pcur->cy / 2 : pcur->cy,
ghdcMem2,
0,
0,
SRCCOPY,
0x00ffffff);
if (hbmColor != NULL) {
GreSelectBitmap(ghdcMem2, pcur->hbmColor);
GreSelectBitmap(ghdcMem, hbmColor);
GreBitBlt(ghdcMem,
0,
0,
pcur->cx,
pcur->cy / 2,
ghdcMem2,
0,
0,
SRCCOPY,
0);
}
GreSelectBitmap(ghdcMem2, hbmBitsT);
GreSelectBitmap(ghdcMem, hbmDstT);
/*
* Fill in the iconinfo structure. make copies of the bitmaps.
*/
try {
piconinfo->fIcon = (pcur->rt == LOWORD(RT_ICON));
piconinfo->xHotspot = pcur->xHotspot;
piconinfo->yHotspot = pcur->yHotspot;
piconinfo->hbmMask = hbmMask;
piconinfo->hbmColor = hbmColor;
if (pstrInstanceName != NULL) {
if (pcur->atomModName) {
pstrInstanceName->Length =
UserGetAtomName(pcur->atomModName,
pstrInstanceName->Buffer,
pstrInstanceName->MaximumLength / sizeof(WCHAR))
* sizeof(WCHAR);
} else {
pstrInstanceName->Length = 0;
}
}
if (pstrResName != NULL) {
if (HIWORD(pcur->strName.Buffer)) {
RtlCopyUnicodeString(pstrResName, &pcur->strName);
} else {
*pstrResName = pcur->strName;
}
}
if (pbpp)
*pbpp = pcur->bpp;
} except (EXCEPTION_EXECUTE_HANDLER) {
GreDeleteObject(hbmMask);
GreDeleteObject(hbmColor);
return FALSE;
}
return TRUE;
}
HPEN
APIENTRY
IntGdiExtCreatePen(
DWORD dwPenStyle,
DWORD dwWidth,
IN ULONG ulBrushStyle,
IN ULONG ulColor,
IN ULONG_PTR ulClientHatch,
IN ULONG_PTR ulHatch,
DWORD dwStyleCount,
PULONG pStyle,
IN ULONG cjDIB,
IN BOOL bOldStylePen,
IN OPTIONAL HBRUSH hbrush)
{
HPEN hPen;
PBRUSH pbrushPen;
static const BYTE PatternAlternate[] = {0x55, 0x55, 0x55, 0};
static const BYTE PatternDash[] = {0xFF, 0xFF, 0xC0, 0};
static const BYTE PatternDot[] = {0xE3, 0x8E, 0x38, 0};
static const BYTE PatternDashDot[] = {0xFF, 0x81, 0xC0, 0};
static const BYTE PatternDashDotDot[] = {0xFF, 0x8E, 0x38, 0};
dwWidth = abs(dwWidth);
if ( (dwPenStyle & PS_STYLE_MASK) == PS_NULL)
{
return StockObjects[NULL_PEN];
}
if (bOldStylePen)
{
pbrushPen = PEN_AllocPenWithHandle();
}
else
{
pbrushPen = PEN_AllocExtPenWithHandle();
}
if (!pbrushPen)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
DPRINT("Can't allocate pen\n");
return 0;
}
hPen = pbrushPen->BaseObject.hHmgr;
// If nWidth is zero, the pen is a single pixel wide, regardless of the current transformation.
if ((bOldStylePen) && (!dwWidth) && ((dwPenStyle & PS_STYLE_MASK) != PS_SOLID))
dwWidth = 1;
pbrushPen->lWidth = dwWidth;
pbrushPen->eWidth = (FLOAT)pbrushPen->lWidth;
pbrushPen->ulPenStyle = dwPenStyle;
pbrushPen->BrushAttr.lbColor = ulColor;
pbrushPen->iBrushStyle = ulBrushStyle;
// FIXME: Copy the bitmap first ?
pbrushPen->hbmClient = (HANDLE)ulClientHatch;
pbrushPen->dwStyleCount = dwStyleCount;
pbrushPen->pStyle = pStyle;
pbrushPen->flAttrs = bOldStylePen ? BR_IS_OLDSTYLEPEN : BR_IS_PEN;
// If dwPenStyle is PS_COSMETIC, the width must be set to 1.
if ( !(bOldStylePen) && ((dwPenStyle & PS_TYPE_MASK) == PS_COSMETIC) && ( dwWidth != 1) )
goto ExitCleanup;
switch (dwPenStyle & PS_STYLE_MASK)
{
case PS_NULL:
pbrushPen->flAttrs |= BR_IS_NULL;
break;
case PS_SOLID:
pbrushPen->flAttrs |= BR_IS_SOLID;
break;
case PS_ALTERNATE:
pbrushPen->flAttrs |= BR_IS_BITMAP;
pbrushPen->hbmPattern = GreCreateBitmap(24, 1, 1, 1, (LPBYTE)PatternAlternate);
break;
case PS_DOT:
pbrushPen->flAttrs |= BR_IS_BITMAP;
pbrushPen->hbmPattern = GreCreateBitmap(24, 1, 1, 1, (LPBYTE)PatternDot);
break;
case PS_DASH:
pbrushPen->flAttrs |= BR_IS_BITMAP;
pbrushPen->hbmPattern = GreCreateBitmap(24, 1, 1, 1, (LPBYTE)PatternDash);
break;
case PS_DASHDOT:
pbrushPen->flAttrs |= BR_IS_BITMAP;
pbrushPen->hbmPattern = GreCreateBitmap(24, 1, 1, 1, (LPBYTE)PatternDashDot);
break;
case PS_DASHDOTDOT:
pbrushPen->flAttrs |= BR_IS_BITMAP;
pbrushPen->hbmPattern = GreCreateBitmap(24, 1, 1, 1, (LPBYTE)PatternDashDotDot);
break;
case PS_INSIDEFRAME:
pbrushPen->flAttrs |= (BR_IS_SOLID | BR_IS_INSIDEFRAME);
break;
case PS_USERSTYLE:
if ((dwPenStyle & PS_TYPE_MASK) == PS_COSMETIC)
{
/* FIXME: PS_USERSTYLE workaround */
DPRINT1("PS_COSMETIC | PS_USERSTYLE not handled\n");
pbrushPen->flAttrs |= BR_IS_SOLID;
break;
}
else
{
UINT i;
BOOL has_neg = FALSE, all_zero = TRUE;
for(i = 0; (i < dwStyleCount) && !has_neg; i++)
{
has_neg = has_neg || (((INT)(pStyle[i])) < 0);
all_zero = all_zero && (pStyle[i] == 0);
}
if(all_zero || has_neg)
{
goto ExitCleanup;
}
}
/* FIXME: What style here? */
pbrushPen->flAttrs |= 0;
break;
default:
DPRINT1("IntGdiExtCreatePen unknown penstyle %x\n", dwPenStyle);
}
PEN_UnlockPen(pbrushPen);
return hPen;
ExitCleanup:
EngSetLastError(ERROR_INVALID_PARAMETER);
pbrushPen->pStyle = NULL;
GDIOBJ_vDeleteObject(&pbrushPen->BaseObject);
return NULL;
}
BOOL xxxSnapWindow(
PWND pwnd)
{
PTHREADINFO ptiCurrent;
RECT rc;
HDC hdcScr = NULL;
HDC hdcMem = NULL;
BOOL fRet;
HBITMAP hbmOld;
HBITMAP hbm;
HANDLE hPal;
LPLOGPALETTE lppal;
int palsize;
int iFixedPaletteEntries;
BOOL fSuccess;
PWND pwndT;
TL tlpwndT;
PWINDOWSTATION pwinsta;
TL tlpwinsta;
CheckLock(pwnd);
UserAssert(pwnd);
ptiCurrent = PtiCurrent();
/*
* If this is a thread of winlogon, don't do the snapshot.
*/
if (GetCurrentProcessId() == gpidLogon)
return FALSE;
/*
* Get the affected windowstation
*/
if (!NT_SUCCESS(ReferenceWindowStation(
PsGetCurrentThread(),
NULL,
WINSTA_READSCREEN,
&pwinsta,
TRUE)) ||
pwinsta->dwWSF_Flags & WSF_NOIO) {
return FALSE;
}
/*
* If the window is on another windowstation, do nothing
*/
if (pwnd->head.rpdesk->rpwinstaParent != pwinsta)
return FALSE;
/*
* Get the parent of any child windows.
*/
while ((pwnd != NULL) && TestWF(pwnd, WFCHILD)) {
pwnd = pwnd->spwndParent;
}
/*
* Lock the windowstation before we leave the critical section
*/
ThreadLockWinSta(ptiCurrent, pwinsta, &tlpwinsta);
/*
* Open the clipboard and empty it.
*
* pwndDesktop is made the owner of the clipboard, instead of the
* currently active window; -- SANKAR -- 20th July, 1989 --
*/
pwndT = ptiCurrent->rpdesk->pDeskInfo->spwnd;
ThreadLockWithPti(ptiCurrent, pwndT, &tlpwndT);
fSuccess = xxxOpenClipboard(pwndT, NULL);
ThreadUnlock(&tlpwndT);
if (!fSuccess) {
ThreadUnlockWinSta(ptiCurrent, &tlpwinsta);
return FALSE;
}
xxxEmptyClipboard(pwinsta);
/*
* Use the whole window.
*/
CopyRect(&rc, &pwnd->rcWindow);
/*
* Only snap what is on the screen.
*/
if (!IntersectRect(&rc, &rc, &gpDispInfo->rcScreen)) {
fRet = FALSE;
goto SnapExit;
}
rc.right -= rc.left;
rc.bottom -= rc.top;
/*
* Figure out how far offset from window origin visible part is
*/
if (pwnd != PWNDDESKTOP(pwnd)) {
rc.left -= pwnd->rcWindow.left;
rc.top -= pwnd->rcWindow.top;
}
/*
* Get the entire window's DC.
*/
hdcScr = _GetWindowDC(pwnd);
if (!hdcScr)
goto MemoryError;
/*
* Create the memory DC.
*/
hdcMem = GreCreateCompatibleDC(hdcScr);
if (!hdcMem)
goto MemoryError;
/*
* Create the destination bitmap. If it fails, then attempt
* to create a monochrome bitmap.
* Did we have enough memory?
*/
if (SYSMET(SAMEDISPLAYFORMAT)) {
hbm = GreCreateCompatibleBitmap(hdcScr, rc.right, rc.bottom);
} else {
hbm = GreCreateBitmap(rc.right, rc.bottom, 1, gpDispInfo->BitCountMax, NULL);
}
if (!hbm) {
hbm = GreCreateBitmap(rc.right, rc.bottom, 1, 1, NULL);
if (!hbm)
goto MemoryError;
}
/*
* Select the bitmap into the memory DC.
*/
hbmOld = GreSelectBitmap(hdcMem, hbm);
/*
* Snap!!!
* Check the return value because the process taking the snapshot
* may not have access to read the screen.
*/
fRet = GreBitBlt(hdcMem, 0, 0, rc.right, rc.bottom, hdcScr, rc.left, rc.top, SRCCOPY | CAPTUREBLT, 0);
/*
* Restore the old bitmap into the memory DC.
*/
GreSelectBitmap(hdcMem, hbmOld);
/*
* If the blt failed, leave now.
*/
if (!fRet)
goto SnapExit;
_SetClipboardData(CF_BITMAP, hbm, FALSE, TRUE);
/*
* If this is a palette device, let's throw the current system palette
* into the clipboard also. Useful if the user just snapped a window
* containing palette colors...
*/
if (TEST_PUSIF(PUSIF_PALETTEDISPLAY)) {
int i;
int iPalSize;
palsize = GreGetDeviceCaps(hdcScr, SIZEPALETTE);
/*
* Determine the number of system colors.
*/
if (GreGetSystemPaletteUse(hdcScr) == SYSPAL_STATIC)
iFixedPaletteEntries = GreGetDeviceCaps(hdcScr, NUMRESERVED);
else
iFixedPaletteEntries = 2;
lppal = (LPLOGPALETTE)UserAllocPoolWithQuota(
(LONG)(sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * palsize),
TAG_CLIPBOARD);
if (lppal != NULL) {
lppal->palVersion = 0x300;
lppal->palNumEntries = (WORD)palsize;
if (GreGetSystemPaletteEntries(hdcScr,
0,
palsize,
lppal->palPalEntry)) {
iPalSize = palsize - iFixedPaletteEntries / 2;
for (i = iFixedPaletteEntries / 2; i < iPalSize; i++) {
/*
* Any non system palette enteries need to have the NOCOLLAPSE
* flag set otherwise bitmaps containing different palette
* indices but same colors get messed up.
*/
lppal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
}
if (hPal = GreCreatePalette(lppal))
_SetClipboardData(CF_PALETTE, hPal, FALSE, TRUE);
}
UserFreePool(lppal);
}
}
PlayEventSound(USER_SOUND_SNAPSHOT);
fRet = TRUE;
SnapExit:
/*
* Release the window/client DC.
*/
if (hdcScr) {
_ReleaseDC(hdcScr);
}
xxxCloseClipboard(pwinsta);
Unlock(&pwinsta->spwndClipOwner);
/*
* Delete the memory DC.
*/
if (hdcMem) {
GreDeleteDC(hdcMem);
}
ThreadUnlockWinSta(ptiCurrent, &tlpwinsta);
return fRet;
MemoryError:
/*
* Display an error message box.
*/
ClientNoMemoryPopup();
fRet = FALSE;
goto SnapExit;
}
