* Fix some print specifiers. Dedicated to the Island.
svn path=/trunk/; revision=59960
if (Error == FT_Err_Unknown_File_Format)
DPRINT("Unknown font file format\n");
else
- DPRINT("Error reading font file (error code: %u)\n", Error);
+ DPRINT("Error reading font file (error code: %d)\n", Error);
return 0;
}
FontGDI->face = Face;
DPRINT("Font loaded: %s (%s)\n", Face->family_name, Face->style_name);
- DPRINT("Num glyphs: %u\n", Face->num_glyphs);
+ DPRINT("Num glyphs: %d\n", Face->num_glyphs);
/* Add this font resource to the font table */
wcscpy(Info->EnumLogFontEx.elfScript, ElfScripts[i]);
else
{
- DPRINT1("Unknown elfscript for bit %d\n", i);
+ DPRINT1("Unknown elfscript for bit %u\n", i);
}
}
}
FT_CharMap found = 0, charmap;
XFORM xForm;
- DPRINT("%d, %08x, %p, %08lx, %p, %p\n", wch, iFormat, pgm,
+ DPRINT("%u, %08x, %p, %08lx, %p, %p\n", wch, iFormat, pgm,
cjBuf, pvBuf, pmat2);
pdcattr = dc->pdcattr;
gm.gmptGlyphOrigin.x = left >> 6;
gm.gmptGlyphOrigin.y = top >> 6;
- DPRINT("CX %d CY %d BBX %d BBY %d GOX %d GOY %d\n",
+ DPRINT("CX %d CY %d BBX %u BBY %u GOX %d GOY %d\n",
gm.gmCellIncX, gm.gmCellIncY,
gm.gmBlackBoxX, gm.gmBlackBoxY,
gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
}
default:
- DPRINT1("Unsupported format %d\n", iFormat);
+ DPRINT1("Unsupported format %u\n", iFormat);
return GDI_ERROR;
}
- DPRINT("ftGdiGetGlyphOutline END and needed %d\n", needed);
+ DPRINT("ftGdiGetGlyphOutline END and needed %lu\n", needed);
return needed;
}
dc->ppdev->devinfo.lfDefaultFont.lfHeight : abs(TextObj->logfont.elfEnumLogfontEx.elfLogFont.lfHeight)));
if (error)
{
- DPRINT1("Error in setting pixel sizes: %u\n", error);
+ DPRINT1("Error in setting pixel sizes: %d\n", error);
}
/* Get the DC's world-to-device transformation matrix */
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
if (error)
{
- DPRINT1("WARNING: Failed to load and render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("WARNING: Failed to load and render glyph! [index: %d]\n", glyph_index);
break;
}
RenderMode);
if (!realglyph)
{
- DPRINT1("Failed to render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
break;
}
}
}
}
Exit:
- DPRINT("CharSet %d CodePage %d\n",csi.ciCharset, csi.ciACP);
+ DPRINT("CharSet %u CodePage %u\n", csi.ciCharset, csi.ciACP);
return (MAKELONG(csi.ciACP, csi.ciCharset));
}
dc->ppdev->devinfo.lfDefaultFont.lfHeight : abs(TextObj->logfont.elfEnumLogfontEx.elfLogFont.lfHeight)));
if (error)
{
- DPRINT1("Error in setting pixel sizes: %u\n", error);
+ DPRINT1("Error in setting pixel sizes: %d\n", error);
IntUnLockFreeType;
goto fail;
}
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
if (error)
{
- DPRINT1("WARNING: Failed to load and render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("WARNING: Failed to load and render glyph! [index: %d]\n", glyph_index);
}
glyph = face->glyph;
RenderMode);
if (!realglyph)
{
- DPRINT1("Failed to render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
IntUnLockFreeType;
goto fail;
}
error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
if (error)
{
- DPRINT1("Failed to load and render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("Failed to load and render glyph! [index: %d]\n", glyph_index);
IntUnLockFreeType;
goto fail2;
}
RenderMode);
if (!realglyph)
{
- DPRINT1("Failed to render glyph! [index: %u]\n", glyph_index);
+ DPRINT1("Failed to render glyph! [index: %d]\n", glyph_index);
IntUnLockFreeType;
goto fail2;
}
FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
TextLeft += delta.x;
}
- DPRINT("TextLeft: %d\n", TextLeft);
- DPRINT("TextTop: %d\n", TextTop);
+ DPRINT("TextLeft: %I64d\n", TextLeft);
+ DPRINT("TextTop: %lu\n", TextTop);
DPRINT("Advance: %d\n", realglyph->root.advance.x);
if (fuOptions & ETO_OPAQUE)
if (NULL == Dx)
{
TextLeft += realglyph->root.advance.x >> 10;
- DPRINT("New TextLeft: %d\n", TextLeft);
+ DPRINT("New TextLeft: %I64d\n", TextLeft);
}
else
{
TextLeft += Dx[i<<DxShift] << 6;
- DPRINT("New TextLeft2: %d\n", TextLeft);
+ DPRINT("New TextLeft2: %I64d\n", TextLeft);
}
if (DxShift)
// If null instance use client.
if (!hInstance) hInstance = hModClient;
- TRACE("GetClassInfo(%wZ, 0x%x)\n", SafeClassName, hInstance);
+ TRACE("GetClassInfo(%wZ, %p)\n", SafeClassName, hInstance);
/* NOTE: Need exclusive lock because getting the wndproc might require the
creation of a call procedure handle */
if (versionInfo.dwMajorVersion <= 4)
len = swprintf(buffer,
- L"ReactOS Version %d.%d %s Build %d",
+ L"ReactOS Version %lu.%lu %s Build %lu",
versionInfo.dwMajorVersion, versionInfo.dwMinorVersion,
versionInfo.szCSDVersion, versionInfo.dwBuildNumber&0xFFFF);
else
len = swprintf(buffer,
- L"ReactOS %s (Build %d)",
+ L"ReactOS %s (Build %lu)",
versionInfo.szCSDVersion, versionInfo.dwBuildNumber&0xFFFF);
return len;
if (NT_SUCCESS(Status))
{
iVGACompatible = _wtoi(&awcDeviceName[13]);
- ERR("VGA adapter = %ld\n", iVGACompatible);
+ ERR("VGA adapter = %lu\n", iVGACompatible);
}
/* Get the maximum mumber of adapters */
ERR("Could not read MaxObjectNumber, defaulting to 0.\n");
}
- TRACE("Found %ld devices\n", ulMaxObjectNumber + 1);
+ TRACE("Found %lu devices\n", ulMaxObjectNumber + 1);
/* Loop through all adapters */
for (iDevNum = 0; iDevNum <= ulMaxObjectNumber; iDevNum++)
DISPLAY_DEVICEW dispdev;
NTSTATUS Status;
- TRACE("Enter NtUserEnumDisplayDevices(%wZ, %ld)\n",
- pustrDevice, iDevNum);
+ TRACE("Enter NtUserEnumDisplayDevices(%wZ, %lu)\n",
+ pustrDevice, iDevNum);
dispdev.cb = sizeof(dispdev);
PDEVMODEENTRY pdmentry;
ULONG i, iFoundMode;
- TRACE("Enter UserEnumDisplaySettings('%wZ', %ld)\n",
- pustrDevice, iModeNum);
+ TRACE("Enter UserEnumDisplaySettings('%wZ', %lu)\n",
+ pustrDevice, iModeNum);
/* Ask GDI for the GRAPHICS_DEVICE */
pGraphicsDevice = EngpFindGraphicsDevice(pustrDevice, 0, 0);
ULONG cbSize, cbExtra;
DEVMODEW dmReg, *pdm;
- TRACE("Enter NtUserEnumDisplaySettings(%wZ, %ld, %p, 0x%lx)\n",
- pustrDevice, iModeNum, lpDevMode, dwFlags);
+ TRACE("Enter NtUserEnumDisplaySettings(%wZ, %lu, %p, 0x%lx)\n",
+ pustrDevice, iModeNum, lpDevMode, dwFlags);
if (pustrDevice)
{
{
if (pEH)
{
- TRACE("IntRemoveEvent pEH 0x%x\n",pEH);
+ TRACE("IntRemoveEvent pEH %p\n", pEH);
KeEnterCriticalRegion();
RemoveEntryList(&pEH->Chain);
GlobalEvents->Counts--;
PLIST_ENTRY pLE;
PTHREADINFO pti, ptiCurrent;
- TRACE("IntNotifyWinEvent GlobalEvents = 0x%x pWnd 0x%x\n",GlobalEvents, pWnd);
+ TRACE("IntNotifyWinEvent GlobalEvents = %p pWnd %p\n", GlobalEvents, pWnd);
if (!GlobalEvents || !GlobalEvents->Counts) return;
HANDLE Handle;
PETHREAD Thread = NULL;
- TRACE("NtUserSetWinEventHook hmod 0x%x, pfn 0x%x\n",hmodWinEventProc, lpfnWinEventProc);
+ TRACE("NtUserSetWinEventHook hmod %p, pfn %p\n", hmodWinEventProc, lpfnWinEventProc);
UserEnterExclusive();
hWnd = UserHMGetHandle(Wnd);
- TRACE("SetForegroundAndFocusWindow(%x, %s)\n", hWnd, (MouseActivate ? "TRUE" : "FALSE"));
+ TRACE("SetForegroundAndFocusWindow(%p, %s)\n", hWnd, (MouseActivate ? "TRUE" : "FALSE"));
PrevForegroundQueue = IntGetFocusMessageQueue(); // Use this active desktop.
pti = PsGetCurrentThreadWin32Thread();
IntSendFocusMessages( pti, Window);
- TRACE("Focus: %d -> %d\n", hWndPrev, Window->head.h);
+ TRACE("Focus: %p -> %p\n", hWndPrev, Window->head.h);
}
else /* NULL hwnd passed in */
{
RETURN( ThreadQueue ? (ThreadQueue->spwndCapture ? UserHMGetHandle(ThreadQueue->spwndCapture) : 0) : 0);
CLEANUP:
- TRACE("Leave IntGetCapture, ret=%i\n",_ret_);
+ TRACE("Leave IntGetCapture, ret=%p\n", _ret_);
END_CLEANUP;
}
RETURN( UserGetForegroundWindow());
CLEANUP:
- TRACE("Leave NtUserGetForegroundWindow, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetForegroundWindow, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
PWND Window;
DECLARE_RETURN(HWND);
- TRACE("Enter NtUserSetActiveWindow(%x)\n", hWnd);
+ TRACE("Enter NtUserSetActiveWindow(%p)\n", hWnd);
UserEnterExclusive();
Window = NULL;
{
DECLARE_RETURN(HWND);
- TRACE("Enter NtUserSetCapture(%x)\n", hWnd);
+ TRACE("Enter NtUserSetCapture(%p)\n", hWnd);
UserEnterExclusive();
RETURN( co_UserSetCapture(hWnd));
CLEANUP:
- TRACE("Leave NtUserSetCapture, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetCapture, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
DECLARE_RETURN(HWND);
HWND ret;
- TRACE("Enter NtUserSetFocus(%x)\n", hWnd);
+ TRACE("Enter NtUserSetFocus(%p)\n", hWnd);
UserEnterExclusive();
if (hWnd)
ppi = PsGetCurrentProcessWin32Process();
- ERR("IntLoadHookModule. Client PID: %d\n", PsGetProcessId(ppi->peProcess));
+ ERR("IntLoadHookModule. Client PID: %p\n", PsGetProcessId(ppi->peProcess));
/* Check if this is the api hook */
if(iHookID == WH_APIHOOK)
{
if(ptiCurrent->ppi->W32PF_flags & W32PF_APIHOOKLOADED)
{
- TRACE("IntHookModuleUnloaded: sending message to PID %d, ppi=0x%x\n", PsGetProcessId(ptiCurrent->ppi->peProcess), ptiCurrent->ppi);
+ TRACE("IntHookModuleUnloaded: sending message to PID %p, ppi=%p\n", PsGetProcessId(ptiCurrent->ppi->peProcess), ptiCurrent->ppi);
co_MsqSendMessageAsync( ptiCurrent,
0,
iHookID,
return FALSE;
}
- ERR("UserRegisterUserApiHook. Server PID: %d\n", PsGetProcessId(pti->ppi->peProcess));
+ ERR("UserRegisterUserApiHook. Server PID: %p\n", PsGetProcessId(pti->ppi->peProcess));
/* Register the api hook */
gpsi->dwSRVIFlags |= SRVINFO_APIHOOK;
return FALSE;
}
- ERR("UserUnregisterUserApiHook. Server PID: %d\n", PsGetProcessId(pti->ppi->peProcess));
+ ERR("UserUnregisterUserApiHook. Server PID: %p\n", PsGetProcessId(pti->ppi->peProcess));
/* Unregister the api hook */
gpsi->dwSRVIFlags &= ~SRVINFO_APIHOOK;
if (!pti || !pdo)
{
- ERR("Kill Thread Hooks pti 0x%x pdo 0x%x\n",pti,pdo);
+ ERR("Kill Thread Hooks pti %p pdo %p\n", pti, pdo);
return;
}
if ( (pti->TIF_flags & TIF_DISABLEHOOKS) || (ptiHook->TIF_flags & TIF_INCLEANUP))
{
- TRACE("Next Hook 0x%x, 0x%x\n",ptiHook->rpdesk,pdo);
+ TRACE("Next Hook %p, %p\n", ptiHook->rpdesk, pdo);
continue;
}
Hook->Proc = HookProc;
Hook->Ansi = Ansi;
- TRACE("Set Hook Desk 0x%x DeskInfo 0x%x Handle Desk 0x%x\n",pti->rpdesk, pti->pDeskInfo,Hook->head.rpdesk);
+ TRACE("Set Hook Desk %p DeskInfo %p Handle Desk %p\n", pti->rpdesk, pti->pDeskInfo, Hook->head.rpdesk);
if (ThreadId) /* Thread-local hook */
{
RETURN( Handle);
CLEANUP:
- TRACE("Leave NtUserSetWindowsHookEx, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetWindowsHookEx, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
TO = 1000 * gspv.iScrSaverTimeout;
if (Test > TO)
{
- TRACE("Screensaver Message Start! Tick %d Timeout %d \n", Test, gspv.iScrSaverTimeout);
+ TRACE("Screensaver Message Start! Tick %lu Timeout %d \n", Test, gspv.iScrSaverTimeout);
if (ppiScrnSaver) // We are or we are not the screensaver, prevent reentry...
{
ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
ptiRawInput->pClientInfo->dwTIFlags = ptiRawInput->TIF_flags;
- TRACE("Raw Input Thread 0x%x\n", ptiRawInput);
+ TRACE("Raw Input Thread %p\n", ptiRawInput);
KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
LOW_REALTIME_PRIORITY + 3);
ptiFrom->MessageQueue = ptiTo->MessageQueue;
ptiFrom->MessageQueue->cThreads++;
- ERR("ptiTo S Share count %d\n", ptiFrom->MessageQueue->cThreads);
+ ERR("ptiTo S Share count %lu\n", ptiFrom->MessageQueue->cThreads);
// FIXME: conditions?
if (ptiFrom->pqAttach == gpqForeground)
if (pai->pti1 == ptiFrom)
{
ptiFrom->MessageQueue->cThreads--;
- ERR("ptiTo L Share count %d\n", ptiFrom->MessageQueue->cThreads);
+ ERR("ptiTo L Share count %lu\n", ptiFrom->MessageQueue->cThreads);
/* Use the message queue of the last attachment */
ptiFrom->MessageQueue = pai->pti2->MessageQueue;
ptiFrom->MessageQueue->CursorObject = NULL;
}
ptiFrom->MessageQueue->cThreads--;
- ERR("ptiTo E Share count %d\n", ptiFrom->MessageQueue->cThreads);
+ ERR("ptiTo E Share count %lu\n", ptiFrom->MessageQueue->cThreads);
ptiFrom->MessageQueue = ptiFrom->pqAttach;
// FIXME: conditions?
ptiFrom->MessageQueue->CursorObject = NULL;
}
cleanup:
- TRACE("Leave NtUserSendInput, ret=%i\n", uRet);
+ TRACE("Leave NtUserSendInput, ret=%u\n", uRet);
UserLeave();
return uRet;
}
pKl->iBaseCharset = cs.ciCharset;
pKl->dwFontSigs = cs.fs.fsCsb[0];
pKl->CodePage = (USHORT)cs.ciACP;
- TRACE("Charset %d Font Sig %d CodePage %d\n", pKl->iBaseCharset, pKl->dwFontSigs, pKl->CodePage);
+ TRACE("Charset %u Font Sig %lu CodePage %u\n", pKl->iBaseCharset, pKl->dwFontSigs, pKl->CodePage);
}
else
{
if (!pKl)
{
- ERR("Invalid HKL %x!\n", hKl);
+ ERR("Invalid HKL %p!\n", hKl);
goto cleanup;
}
if (pKl)
bRet = UserUnloadKbl(pKl);
else
- ERR("Invalid HKL %x!\n", hKl);
+ ERR("Invalid HKL %p!\n", hKl);
UserLeave();
return bRet;
*pbLigature = (wch == WCH_LGTR);
*pwcTranslatedChar = wch;
- TRACE("%d %04x: dwModNumber %08x Char %04x\n",
+ TRACE("%lu %04x: dwModNumber %08x Char %04x\n",
i, wVirtKey, dwModNumber, wch);
if (*pbDead)
UserLeave();
- TRACE("Leave NtUserGetAsyncKeyState, ret=%i\n", wRet);
+ TRACE("Leave NtUserGetAsyncKeyState, ret=%u\n", wRet);
return wRet;
}
ret = IntMapVirtualKeyEx(uCode, uType, pKbdTbl);
UserLeave();
- TRACE("Leave NtUserMapVirtualKeyEx, ret=%i\n", ret);
+ TRACE("Leave NtUserMapVirtualKeyEx, ret=%u\n", ret);
return ret;
}
pwszBuff = ExAllocatePoolWithTag(NonPagedPool, sizeof(WCHAR) * cchBuff, TAG_STRING);
if (!pwszBuff)
{
- ERR("ExAllocatePoolWithTag(%d) failed\n", sizeof(WCHAR) * cchBuff);
+ ERR("ExAllocatePoolWithTag(%u) failed\n", sizeof(WCHAR) * cchBuff);
return 0;
}
RtlZeroMemory(pwszBuff, sizeof(WCHAR) * cchBuff);
cleanup:
UserLeave();
- TRACE("Leave NtUserGetKeyNameText, ret=%i\n", dwRet);
+ TRACE("Leave NtUserGetKeyNameText, ret=%lu\n", dwRet);
return dwRet;
}
PKL pKl = NULL;
DWORD i, dwModBits = 0, dwModNumber = 0, Ret = (DWORD)-1;
- TRACE("NtUserVkKeyScanEx() wch %d, KbdLayout 0x%p\n", wch, dwhkl);
+ TRACE("NtUserVkKeyScanEx() wch %u, KbdLayout 0x%p\n", wch, dwhkl);
UserEnterShared();
if (bUsehKL)
if (pVkToWch->wch[dwModNumber] == wch)
{
dwModBits = pKbdTbl->pCharModifiers->ModNumber[dwModNumber];
- TRACE("i %d wC %04x: dwModBits %08x dwModNumber %08x MaxModBits %08x\n",
+ TRACE("i %lu wC %04x: dwModBits %08x dwModNumber %08x MaxModBits %08x\n",
i, wch, dwModBits, dwModNumber, pKbdTbl->pCharModifiers->wMaxModBits);
Ret = (dwModBits << 8) | (pVkToWch->VirtualKey & 0xFF);
goto Exit;
RETURN( IntCheckMenuItem(Menu, uIDCheckItem, uCheck));
CLEANUP:
- TRACE("Leave NtUserCheckMenuItem, ret=%i\n",_ret_);
+ TRACE("Leave NtUserCheckMenuItem, ret=%lu\n",_ret_);
UserLeave();
END_CLEANUP;
}
if (!NT_SUCCESS(Status))
{
- ERR("Validation of window station handle (0x%X) failed\n",
- CurrentProcess->Win32WindowStation);
+ ERR("Validation of window station handle (%p) failed\n",
+ CurrentProcess->Win32WindowStation);
SetLastNtError(Status);
return (HMENU)0;
}
RETURN( retValue );
CLEANUP:
- TRACE("Leave NtUserGetTitleBarInfo, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetTitleBarInfo, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN( IntEnableMenuItem(Menu, uIDEnableItem, uEnable));
CLEANUP:
- TRACE("Leave NtUserEnableMenuItem, ret=%i\n",_ret_);
+ TRACE("Leave NtUserEnableMenuItem, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN(0xFFFFFFFF);
CLEANUP:
- TRACE("Leave NtUserGetMenuIndex, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetMenuIndex, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN(FALSE);
CLEANUP:
- TRACE("Leave NtUserHiliteMenuItem, ret=%i\n",_ret_);
+ TRACE("Leave NtUserHiliteMenuItem, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN( res);
CLEANUP:
- TRACE("Leave NtUserBuildMenuItemList, ret=%i\n",_ret_);
+ TRACE("Leave NtUserBuildMenuItemList, ret=%lu\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN( IntGetMenuDefaultItem(Menu, fByPos, gmdiFlags, &gismc));
CLEANUP:
- TRACE("Leave NtUserGetMenuDefaultItem, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetMenuDefaultItem, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
}
}
- TRACE("IdlePing ppi 0x%x\n",ppi);
+ TRACE("IdlePing ppi %p\n", ppi);
if ( ppi && ppi->InputIdleEvent )
{
TRACE("InputIdleEvent\n");
{
PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
- TRACE("IdlePong ppi 0x%x\n",ppi);
+ TRACE("IdlePong ppi %p\n", ppi);
if ( ppi && ppi->InputIdleEvent )
{
KeClearEvent(ppi->InputIdleEvent);
pWnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
return 0;
- TRACE("Internal Event Msg %p hWnd 0x%x\n",msg,pWnd->head.h);
+ TRACE("Internal Event Msg %u hWnd %p\n", msg, pWnd->head.h);
switch(msg)
{
pti = Window->head.pti;
if ( pti->TIF_flags & TIF_INCLEANUP )
{
- ERR("Attempted to post message to window 0x%x when the thread is in cleanup!\n", Wnd);
+ ERR("Attempted to post message to window %p when the thread is in cleanup!\n", Wnd);
return FALSE;
}
if ( Window->state & WNDS_DESTROYED )
{
- ERR("Attempted to post message to window 0x%x that is being destroyed!\n", Wnd);
+ ERR("Attempted to post message to window %p that is being destroyed!\n", Wnd);
/* FIXME: Last error code? */
return FALSE;
}
if (Window->state & WNDS_DESTROYED)
{
/* FIXME: Last error? */
- ERR("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
+ ERR("Attempted to send message to window %p that is being destroyed!\n", hWnd);
RETURN( FALSE);
}
if (Window->state & WNDS_DESTROYED)
{
/* FIXME: last error? */
- ERR("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
+ ERR("Attempted to send message to window %p that is being destroyed!\n", hWnd);
RETURN(FALSE);
}
ULONG wDragWidth, wDragHeight;
DECLARE_RETURN(BOOL);
- TRACE("Enter NtUserDragDetect(%x)\n", hWnd);
+ TRACE("Enter NtUserDragDetect(%p)\n", hWnd);
UserEnterExclusive();
wDragWidth = UserGetSystemMetrics(SM_CXDRAG);
}
else
{
- TRACE("No Window for Translate. hwnd 0x%p Msg %d\n",SafeMsg.hwnd,SafeMsg.message);
+ TRACE("No Window for Translate. hwnd 0x%p Msg %u\n", SafeMsg.hwnd, SafeMsg.message);
Ret = FALSE;
}
UserLeave();
CWP.message = Msg;
CWP.wParam = wParam;
CWP.lParam = lParam;
- TRACE("WH_CALLWNDPROC: Hook %x NextHook %x\n", Hook, NextObj );
+ TRACE("WH_CALLWNDPROC: Hook %p NextHook %p\n", Hook, NextObj);
lResult = co_IntCallHookProc( Hook->HookId,
HC_ACTION,
pti->pClientInfo->dwTIFlags = pti->TIF_flags;
}
- TRACE("WFII: ppi 0x%x\n",W32Process);
+ TRACE("WFII: ppi %p\n", W32Process);
TRACE("WFII: waiting for %p\n", Handles[1] );
do
{
{
ASSERT(gpsi);
ASSERT(Setup);
- TRACE("UserGetSystemMetrics(%d)\n", Index);
+ TRACE("UserGetSystemMetrics(%lu)\n", Index);
/* Get metrics from array */
if (Index < SM_CMETRICS)
return 0; // FIXME
}
- ERR("UserGetSystemMetrics() called with invalid index %d\n", Index);
+ ERR("UserGetSystemMetrics() called with invalid index %lu\n", Index);
return 0;
}
break;
}
- TRACE("Leave NtUserGetThreadState, ret=%i\n", ret);
+ TRACE("Leave NtUserGetThreadState, ret=%lu\n", ret);
UserLeave();
return ret;
// FIXME: Check if this works on non-interactive winsta
Result = gspv.iDblClickTime;
- TRACE("Leave NtUserGetDoubleClickTime, ret=%i\n", Result);
+ TRACE("Leave NtUserGetDoubleClickTime, ret=%u\n", Result);
UserLeave();
return Result;
}
RETURN( TRUE);
CLEANUP:
- TRACE("Leave NtUserGetGUIThreadInfo, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetGUIThreadInfo, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Ret);
CLEANUP:
- TRACE("Leave NtUserGetGuiResources, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetGuiResources, ret=%lu\n",_ret_);
UserLeave();
END_CLEANUP;
}
pMonitor = UserGetMonitorObject(hMonitor);
if (!pMonitor)
{
- TRACE("Couldnt find monitor 0x%lx\n", hMonitor);
+ TRACE("Couldnt find monitor %p\n", hMonitor);
goto cleanup;
}
lpEventTrack->dwFlags & TME_NONCLIENT ? WM_NCMOUSELEAVE : WM_MOUSELEAVE,
0, 0);
}
- TRACE("IntTrackMouseEvent spwndTrack 0x%x pwnd 0x%x\n", pDesk->spwndTrack, pWnd);
+ TRACE("IntTrackMouseEvent spwndTrack %p pwnd %p\n", pDesk->spwndTrack, pWnd);
return TRUE;
}
static VOID
UpdateKeyState(PUSER_MESSAGE_QUEUE MessageQueue, WORD wVk, BOOL bIsDown)
{
- TRACE("UpdateKeyState wVk: %d, bIsDown: %d\n", wVk, bIsDown);
+ TRACE("UpdateKeyState wVk: %u, bIsDown: %d\n", wVk, bIsDown);
if (bIsDown)
{
UCHAR key;
BOOL down = FALSE;
- TRACE("UpdateKeyStateFromMsg message:%d\n", msg->message);
+ TRACE("UpdateKeyStateFromMsg message:%u\n", msg->message);
switch (msg->message)
{
}
else
{
- TRACE("Posting mouse message to hwnd=0x%x!\n", UserHMGetHandle(pwnd));
+ TRACE("Posting mouse message to hwnd=%p!\n", UserHMGetHandle(pwnd));
MsqPostMessage(pti, Msg, TRUE, QS_MOUSEBUTTON, 0);
}
}
if (pti->TIF_flags & TIF_INCLEANUP || ptirec->TIF_flags & TIF_INCLEANUP)
{
if (uResult) *uResult = -1;
- ERR("MsqSM: Current pti %d or Rec pti %d\n",pti->TIF_flags & TIF_INCLEANUP, ptirec->TIF_flags & TIF_INCLEANUP);
+ ERR("MsqSM: Current pti %lu or Rec pti %lu\n", pti->TIF_flags & TIF_INCLEANUP, ptirec->TIF_flags & TIF_INCLEANUP);
return STATUS_UNSUCCESSFUL;
}
pwndMsg = co_WinPosWindowFromPoint(NULL, &msg->pt, &hittest);
}
- TRACE("Got mouse message for 0x%x, hittest: 0x%x\n", msg->hwnd, hittest );
+ TRACE("Got mouse message for %p, hittest: 0x%x\n", msg->hwnd, hittest);
if (pwndMsg == NULL || pwndMsg->head.pti != pti)
{
L"Accel", L"DDEaccess", L"DDEconv", L"DDExact", L"Monitor", L"KBDlayout", L"KBDfile",
L"Event", L"Timer", L"InputContext", L"HidData", L"DeviceInfo", L"TouchInput",L"GestureInfo"};
- ERR("Total handles count: %d\n", gpsi->cHandleEntries);
+ ERR("Total handles count: %lu\n", gpsi->cHandleEntries);
memset(HandleCounts, 0, sizeof(HandleCounts));
ppiList = gppiList;
while (ppiList)
{
- ERR("Process %s (%d) handles count: %d\n\t", ppiList->peProcess->ImageFileName, ppiList->peProcess->UniqueProcessId, ppiList->UserHandleCount);
+ ERR("Process %s (%p) handles count: %d\n\t", ppiList->peProcess->ImageFileName, ppiList->peProcess->UniqueProcessId, ppiList->UserHandleCount);
for (i = 1 ;i < TYPE_CTYPES; i++)
{
HandleCounts[i] += ppiList->DbgHandleCount[i];
- DbgPrint("%S: %d, ", TypeNames[i], ppiList->DbgHandleCount[i]);
+ DbgPrint("%S: %lu, ", TypeNames[i], ppiList->DbgHandleCount[i]);
if (i % 6 == 0)
DbgPrint("\n\t");
}
{
PUSER_HANDLE_ENTRY entry;
PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
- TRACE("handles used %i\n",gpsi->cHandleEntries);
+ TRACE("handles used %lu\n", gpsi->cHandleEntries);
if (ht->freelist)
{
if (ht->nb_handles >= ht->allocated_handles) /* Need to grow the array */
{
- ERR("Out of user handles! Used -> %i, NM_Handle -> %d\n", gpsi->cHandleEntries, ht->nb_handles);
+ ERR("Out of user handles! Used -> %lu, NM_Handle -> %d\n", gpsi->cHandleEntries, ht->nb_handles);
#if DBG
DbgUserDumpHandleTable();
if (!entry)
{
- ERR("Warning! Dereference Object without ENTRY! Obj -> 0x%x\n", object);
+ ERR("Warning! Dereference Object without ENTRY! Obj -> %p\n", object);
return FALSE;
}
- TRACE("Warning! Dereference to zero! Obj -> 0x%x\n", object);
+ TRACE("Warning! Dereference to zero! Obj -> %p\n", object);
((PHEAD)object)->cLockObj = 0;
if (Message->hwnd == NULL)
{
- ERR("PAINTING BUG: Thread marked as containing dirty windows, but no dirty windows found! Counts %d\n",Thread->cPaintsReady);
+ ERR("PAINTING BUG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
/* Hack to stop spamming the debuglog ! */
Thread->cPaintsReady = 0;
return FALSE;
RETURN(TRUE);
CLEANUP:
- TRACE("Leave NtUserScrollDC, ret=%i\n",_ret_);
+ TRACE("Leave NtUserScrollDC, ret=%lu\n",_ret_);
UserLeave();
END_CLEANUP;
}
if (Window)
UserDerefObjectCo(Window);
- TRACE("Leave NtUserScrollWindowEx, ret=%i\n",_ret_);
+ TRACE("Leave NtUserScrollWindowEx, ret=%lu\n",_ret_);
UserLeave();
END_CLEANUP;
}
RETURN(Data);
CLEANUP:
- TRACE("Leave NtUserRemoveProp, ret=%i\n",_ret_);
+ TRACE("Leave NtUserRemoveProp, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
Size = 3 * (sizeof(SBINFOEX));
if(!(Window->pSBInfoex = ExAllocatePoolWithTag(PagedPool, Size, TAG_SBARINFO)))
{
- ERR("Unable to allocate memory for scrollbar information for window 0x%x\n", Window->head.h);
+ ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
return FALSE;
}
if(!(Window->pSBInfo = DesktopHeapAlloc( Window->head.rpdesk, sizeof(SBINFO))))
{
- ERR("Unable to allocate memory for scrollbar information for window 0x%x\n", Window->head.h);
+ ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
return FALSE;
}
if(wSBflags != SB_BOTH && !SBID_IS_VALID(wSBflags))
{
EngSetLastError(ERROR_INVALID_PARAMETER);
- ERR("Trying to set scrollinfo for unknown scrollbar type %d", wSBflags);
+ ERR("Trying to set scrollinfo for unknown scrollbar type %u", wSBflags);
RETURN(FALSE);
}
if(InfoH)
Chg = (IntEnableScrollBar(TRUE, InfoH, wArrows) || Chg);
- ERR("FIXME: EnableScrollBar wSBflags %d wArrows %d Chg %d\n",wSBflags,wArrows, Chg);
+ ERR("FIXME: EnableScrollBar wSBflags %u wArrows %u Chg %d\n", wSBflags, wArrows, Chg);
// Done in user32:
// SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
if (Window)
UserDerefObjectCo(Window);
- TRACE("Leave NtUserSetScrollInfo, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetScrollInfo, ret=%lu\n", _ret_);
UserLeave();
END_CLEANUP;
RETURN(ret);
CLEANUP:
- TRACE("Leave NtUserShowScrollBar, ret%i\n",_ret_);
+ TRACE("Leave NtUserShowScrollBar, ret%lu\n", _ret_);
UserLeave();
END_CLEANUP;
/* Yes, Windows really loads the current setting from the registry. */
ulTile = SpiLoadInt(KEY_DESKTOP, L"TileWallpaper", 0);
ulStyle = SpiLoadInt(KEY_DESKTOP, L"WallpaperStyle", 0);
- TRACE("SpiSetWallpaper: ulTile=%ld, ulStyle=%d\n", ulTile, ulStyle);
+ TRACE("SpiSetWallpaper: ulTile=%lu, ulStyle=%lu\n", ulTile, ulStyle);
/* Check the values we found in the registry */
if(ulTile && !ulStyle)
break;
default:
- ERR("Invalid SPI value: %d\n", uiAction);
+ ERR("Invalid SPI value: %u\n", uiAction);
EngSetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
{
BOOL bResult;
- TRACE("Enter NtUserSystemParametersInfo(%d)\n", uiAction);
+ TRACE("Enter NtUserSystemParametersInfo(%u)\n", uiAction);
UserEnterExclusive();
// FIXME: Get rid of the flags and only use this from um. kernel can access data directly.
CALLBACK
SystemTimerProc(HWND hwnd,
UINT uMsg,
- UINT_PTR idEvent,
- DWORD dwTime)
+ UINT_PTR idEvent,
+ DWORD dwTime)
{
PDESKTOP pDesk;
PWND pWnd = NULL;
pWnd = UserGetWindowObject(hwnd);
if (!pWnd)
{
- ERR( "System Timer Proc has invalid window handle! 0x%x Id: %d\n", hwnd, idEvent);
+ ERR("System Timer Proc has invalid window handle! %p Id: %u\n", hwnd, idEvent);
return;
}
}
return; // Not this window so just return.
default:
- ERR( "System Timer Proc invalid id %d!\n", idEvent );
+ ERR("System Timer Proc invalid id %u!\n", idEvent);
break;
}
IntKillTimer(pWnd, idEvent, TRUE);
IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
{
PTIMER pTmr = NULL;
- TRACE("IntKillTimer Window %x id %p systemtimer %s\n",
- Window, IDEvent, SystemTimer ? "TRUE" : "FALSE");
+ TRACE("IntKillTimer Window %p id %p systemtimer %s\n",
+ Window, IDEvent, SystemTimer ? "TRUE" : "FALSE");
TimerEnterExclusive();
pTmr = FindTimer(Window, IDEvent, SystemTimer ? TMRF_SYSTEM : 0);
RETURN(IntSetTimer(Window, nIDEvent, uElapse, lpTimerFunc, TMRF_TIFROMWND));
CLEANUP:
- TRACE("Leave NtUserSetTimer, ret=%i\n", _ret_);
+ TRACE("Leave NtUserSetTimer, ret=%u\n", _ret_);
END_CLEANUP;
}
RETURN(IntSetTimer(UserGetWindowObject(hWnd), nIDEvent, uElapse, NULL, TMRF_SYSTEM));
CLEANUP:
- TRACE("Leave NtUserSetSystemTimer, ret=%i\n", _ret_);
+ TRACE("Leave NtUserSetSystemTimer, ret=%u\n", _ret_);
END_CLEANUP;
}
}
else
{
- TRACE("FREE DCATTR!!!! NOT DCE_WINDOW_DC!!!!! hDC-> %x\n", pDce->hDC);
+ TRACE("FREE DCATTR!!!! NOT DCE_WINDOW_DC!!!!! hDC-> %p\n", pDce->hDC);
GreSetDCOwner(pDce->hDC, GDI_OBJ_HMGR_NONE);
pDce->ptiOwner = NULL;
}
}
}
dce->DCXFlags &= ~DCX_DCEBUSY;
- TRACE("Exit!!!!! DCX_CACHE!!!!!! hDC-> %x \n", dce->hDC);
+ TRACE("Exit!!!!! DCX_CACHE!!!!!! hDC-> %p \n", dce->hDC);
if (!GreSetDCOwner(dce->hDC, GDI_OBJ_HMGR_NONE))
return 0;
dce->ptiOwner = NULL; // Reset ownership.
if (!GreIsHandleValid(Dce->hDC))
{
- ERR("FIXME: Got DCE with invalid hDC! 0x%x\n", Dce->hDC);
+ ERR("FIXME: Got DCE with invalid hDC! %p\n", Dce->hDC);
Dce->hDC = DceCreateDisplayDC();
/* FIXME: Handle error */
}
if (Dce->DCXFlags & DCX_CACHE)
{
- TRACE("ENTER!!!!!! DCX_CACHE!!!!!! hDC-> %x\n", Dce->hDC);
+ TRACE("ENTER!!!!!! DCX_CACHE!!!!!! hDC-> %p\n", Dce->hDC);
// Need to set ownership so Sync dcattr will work.
GreSetDCOwner(Dce->hDC, GDI_OBJ_HMGR_POWNED);
Dce->ptiOwner = GetW32ThreadInfo(); // Set the temp owning
if (Force &&
GreGetObjectOwner(pdce->hDC) != GDI_OBJ_HMGR_POWNED)
{
- TRACE("Change ownership for DCE! -> %x\n" , pdce);
+ TRACE("Change ownership for DCE! -> %p\n" , pdce);
// NOTE: Windows sets W32PF_OWNDCCLEANUP and moves on.
if (GreIsHandleValid(pdce->hDC))
{
}
else
{
- ERR("Attempted to change ownership of an DCEhDC 0x%x currently being destroyed!!!\n",pdce->hDC);
+ ERR("Attempted to change ownership of an DCEhDC %p currently being destroyed!!!\n",
+ pdce->hDC);
Hit = TRUE;
}
}
if (IsListEmpty(&pdce->List))
{
- ERR("List is Empty! DCE! -> %x\n" , pdce);
+ ERR("List is Empty! DCE! -> %p\n" , pdce);
return NULL;
}
pDCE->hwndCurrent = 0;
pDCE->pwndOrg = pDCE->pwndClip = NULL;
- TRACE("POWNED DCE going Cheap!! DCX_CACHE!! hDC-> %x \n", pDCE->hDC);
+ TRACE("POWNED DCE going Cheap!! DCX_CACHE!! hDC-> %p \n",
+ pDCE->hDC);
if (!GreSetDCOwner( pDCE->hDC, GDI_OBJ_HMGR_NONE))
{
- ERR("Fail Owner Switch hDC-> %x \n", pDCE->hDC);
+ ERR("Fail Owner Switch hDC-> %p \n", pDCE->hDC);
break;
}
/* Do not change owner so thread can clean up! */
}
else
{
- ERR("Not POWNED or CLASSDC hwndCurrent -> %x \n", pDCE->hwndCurrent);
+ ERR("Not POWNED or CLASSDC hwndCurrent -> %p \n",
+ pDCE->hwndCurrent);
// ASSERT(FALSE); /* bug 5320 */
}
}
RETURN( UserGetDCEx(Wnd, ClipRegion, Flags));
CLEANUP:
- TRACE("Leave NtUserGetDCEx, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetDCEx, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
HDC APIENTRY
NtUserGetDC(HWND hWnd)
{
- TRACE("NtUGetDC -> %x:%x\n", hWnd, !hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE );
+ TRACE("NtUGetDC -> %p:%x\n", hWnd, !hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE);
return NtUserGetDCEx(hWnd, NULL, NULL == hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE);
}
Current = WThread->WindowListHead.Flink;
Wnd = CONTAINING_RECORD(Current, WND, ThreadListEntry);
- TRACE("thread cleanup: while destroy wnds, wnd=0x%x\n",Wnd);
+ TRACE("thread cleanup: while destroy wnds, wnd=%p\n", Wnd);
/* Window removes itself from the list */
UserRefObjectCo(Wnd, &Ref); // FIXME: Temp HACK??
if (!co_UserDestroyWindow(Wnd))
{
- ERR("Unable to destroy window 0x%x at thread cleanup... This is _VERY_ bad!\n", Wnd);
+ ERR("Unable to destroy window %p at thread cleanup... This is _VERY_ bad!\n", Wnd);
}
UserDerefObjectCo(Wnd); // FIXME: Temp HACK??
}
goto AllocError;
}
- TRACE("Created window object with handle %X\n", hWnd);
+ TRACE("Created window object with handle %p\n", hWnd);
if (pdeskCreated && pdeskCreated->DesktopWindow == NULL )
{ /* HACK: Helper for win32csr/desktopbg.c */
if (!CallProc)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
- ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %x\n",hWnd);
+ ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %p\n", hWnd);
}
else
{
}
}
- TRACE("co_UserCreateWindowEx(): Created window %X\n", hWnd);
+ TRACE("co_UserCreateWindowEx(): Created window %p\n", hWnd);
ret = Window;
cleanup:
RETURN(ret);
CLEANUP:
- TRACE("Leave NtUserDestroyWindow, ret=%i\n",_ret_);
+ TRACE("Leave NtUserDestroyWindow, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Ret);
CLEANUP:
- TRACE("Leave NtUserFindWindowEx, ret %i\n",_ret_);
+ TRACE("Leave NtUserFindWindowEx, ret %p\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN(Ancestor ? Ancestor->head.h : NULL);
CLEANUP:
- TRACE("Leave NtUserGetAncestor, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetAncestor, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( (DWORD) co_IntSendMessage( Wnd->head.h, LB_GETLISTBOXINFO, 0, 0 ));
CLEANUP:
- TRACE("Leave NtUserGetListBoxInfo, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetListBoxInfo, ret=%lu\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( co_UserSetParent(hWndChild, hWndNewParent));
CLEANUP:
- TRACE("Leave NtUserSetParent, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetParent, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN(Menu->MenuInfo.Self);
CLEANUP:
- TRACE("Leave NtUserGetSystemMenu, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetSystemMenu, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
break;
default:
- ERR("NtUserSetWindowLong(): Unsupported index %d\n", Index);
+ ERR("NtUserSetWindowLong(): Unsupported index %lu\n", Index);
EngSetLastError(ERROR_INVALID_INDEX);
OldValue = 0;
break;
RETURN( OldValue);
CLEANUP:
- TRACE("Leave NtUserSetWindowWord, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetWindowWord, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Result);
CLEANUP:
- TRACE("Leave NtUserQueryWindow, ret=%i\n",_ret_);
+ TRACE("Leave NtUserQueryWindow, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Ret);
CLEANUP:
- TRACE("Leave NtUserRegisterWindowMessage, ret=%i\n",_ret_);
+ TRACE("Leave NtUserRegisterWindowMessage, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect);
- TRACE("co_WinPosDoNCCALCSize returned %d\n", WvrFlags);
+ TRACE("co_WinPosDoNCCALCSize returned %lu\n", WvrFlags);
/* Validate link windows. (also take into account shell window in hwndShellWindow) */
if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
Ret = IntDeferWindowPos(WinPosInfo, Wnd, WndInsertAfter, x, y, cx, cy, Flags);
Exit:
- TRACE("Leave NtUserDeferWindowPos, ret=%i\n", Ret);
+ TRACE("Leave NtUserDeferWindowPos, ret=%p\n", Ret);
UserLeave();
return Ret;
}
if (Window) UserDereferenceObject(Window);
if (DesktopWindow) UserDerefObjectCo(DesktopWindow);
- TRACE("Leave NtUserWindowFromPoint, ret=%i\n",_ret_);
+ TRACE("Leave NtUserWindowFromPoint, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
else
{
swprintf(wstrWindowStationsDir,
- L"%ws\\%ld%ws",
+ L"%ws\\%lu%ws",
SESSION_DIR,
Peb->SessionId,
WINSTA_OBJ_DIR);
return Status;
}
- TRACE("Created directory %wZ for session %d\n", &gustrWindowStationsDir, Peb->SessionId);
+ TRACE("Created directory %wZ for session %lu\n", &gustrWindowStationsDir, Peb->SessionId);
return Status;
}
{
PWINSTATION_OBJECT WinSta = (PWINSTATION_OBJECT)Parameters->Object;
- TRACE("Deleting window station (0x%X)\n", WinSta);
+ TRACE("Deleting window station (0x%p)\n", WinSta);
UserEmptyClipboardData(WinSta);
InitCursorImpl();
}
- TRACE("NtUserCreateWindowStation created object 0x%x with name %wZ handle 0x%x\n",
+ TRACE("NtUserCreateWindowStation created object %p with name %wZ handle %p\n",
WindowStation, &WindowStationObject->Name, WindowStation);
return WindowStation;
}
return 0;
}
- TRACE("Opened window station %wZ with handle 0x%x\n", ObjectAttributes->ObjectName, hwinsta);
+ TRACE("Opened window station %wZ with handle %p\n", ObjectAttributes->ObjectName, hwinsta);
return hwinsta;
}
PWINSTATION_OBJECT Object;
NTSTATUS Status;
- TRACE("NtUserCloseWindowStation called (0x%x)\n", hWinSta);
+ TRACE("NtUserCloseWindowStation called (%p)\n", hWinSta);
if (hWinSta == UserGetProcessWindowStation())
{
if (!NT_SUCCESS(Status))
{
- ERR("Validation of window station handle (0x%x) failed\n", hWinSta);
+ ERR("Validation of window station handle (%p) failed\n", hWinSta);
return FALSE;
}
ObDereferenceObject(Object);
- TRACE("Closing window station handle (0x%x)\n", hWinSta);
+ TRACE("Closing window station handle (%p)\n", hWinSta);
Status = ObCloseHandle(hWinSta, UserMode);
if (!NT_SUCCESS(Status))
DWORD nDataSize = 0;
/* try windowstation */
- TRACE("Trying to open window station 0x%x\n", hObject);
+ TRACE("Trying to open window station %p\n", hObject);
Status = ObReferenceObjectByHandle(
hObject,
0,
if (Status == STATUS_OBJECT_TYPE_MISMATCH)
{
/* try desktop */
- TRACE("Trying to open desktop 0x%x\n", hObject);
+ TRACE("Trying to open desktop %p\n", hObject);
Status = IntValidateDesktopHandle(
hObject,
UserMode,
/* try to copy data to caller */
if (Status == STATUS_SUCCESS)
{
- TRACE("Trying to copy data to caller (len = %d, len needed = %d)\n", nLength, nDataSize);
+ TRACE("Trying to copy data to caller (len = %lu, len needed = %lu)\n", nLength, nDataSize);
*nLengthNeeded = nDataSize;
if (nLength >= nDataSize)
Status = MmCopyToCaller(pvInformation, pvData, nDataSize);
&NewWinSta);
if (!NT_SUCCESS(Status))
{
- TRACE("Validation of window station handle (0x%X) failed\n",
- hWindowStation);
+ TRACE("Validation of window station handle (%p) failed\n",
+ hWindowStation);
SetLastNtError(Status);
return FALSE;
}
PWINSTATION_OBJECT Object;
NTSTATUS Status;
- TRACE("About to set process window station with handle (0x%X)\n",
- hWindowStation);
+ TRACE("About to set process window station with handle (%p)\n",
+ hWindowStation);
if(PsGetCurrentProcessWin32Process() != LogonProcess)
{
&Object);
if (!NT_SUCCESS(Status))
{
- TRACE("Validation of window station handle (0x%X) failed\n",
- hWindowStation);
+ TRACE("Validation of window station handle (%p) failed\n",
+ hWindowStation);
SetLastNtError(Status);
return FALSE;
}
NTSTATUS Status;
BOOL Ret;
- TRACE("About to set process window station with handle (0x%X)\n",
- hWindowStation);
+ TRACE("About to set process window station with handle (%p)\n",
+ hWindowStation);
if(PsGetCurrentProcessWin32Process() != LogonProcess)
{
&Object);
if (!NT_SUCCESS(Status))
{
- TRACE("Validation of window station handle (0x%X) failed\n",
- hWindowStation);
+ TRACE("Validation of window station handle (%p) failed\n",
+ hWindowStation);
SetLastNtError(Status);
return FALSE;
}
ReturnLength += DirEntry->Name.Length + sizeof(WCHAR);
EntryCount++;
}
- TRACE("Required size: %d Entry count: %d\n", ReturnLength, EntryCount);
+ TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
if (NULL != pRequiredSize)
{
Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
if (DesktopName) ReturnLength += DesktopName->Length + sizeof(WCHAR);
EntryCount++;
}
- TRACE("Required size: %d Entry count: %d\n", ReturnLength, EntryCount);
+ TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
if (NULL != pRequiredSize)
{
Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));