DWORD APIENTRY NtUserCallHwnd( HWND hWnd, DWORD Routine) { switch (Routine) { case HWND_ROUTINE_GETWNDCONTEXTHLPID: { PWND Window; PPROPERTY HelpId; USER_REFERENCE_ENTRY Ref; UserEnterExclusive(); if (!(Window = UserGetWindowObject(hWnd))) { UserLeave(); return 0; } UserRefObjectCo(Window, &Ref); HelpId = IntGetProp(Window, gpsi->atomContextHelpIdProp); UserDerefObjectCo(Window); UserLeave(); return (DWORD)HelpId->Data; } case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW: if (IntIsWindow(hWnd)) return IntRegisterShellHookWindow(hWnd); return FALSE; break; case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW: if (IntIsWindow(hWnd)) return IntDeRegisterShellHookWindow(hWnd); return FALSE; case HWND_ROUTINE_SETMSGBOX: { PWND Window; UserEnterExclusive(); if ((Window = UserGetWindowObject(hWnd))) { Window->state |= WNDS_MSGBOX; } UserLeave(); return FALSE; } } STUB; return 0; }
DWORD APIENTRY NtUserShowScrollBar(HWND hWnd, int nBar, DWORD bShow) { PWND Window; DECLARE_RETURN(DWORD); DWORD ret; USER_REFERENCE_ENTRY Ref; TRACE("Enter NtUserShowScrollBar\n"); UserEnterExclusive(); if (!(Window = UserGetWindowObject(hWnd))) { RETURN(0); } UserRefObjectCo(Window, &Ref); ret = co_UserShowScrollBar(Window, nBar, (nBar == SB_VERT) ? 0 : bShow, (nBar == SB_HORZ) ? 0 : bShow); UserDerefObjectCo(Window); RETURN(ret); CLEANUP: TRACE("Leave NtUserShowScrollBar, ret%lu\n", _ret_); UserLeave(); END_CLEANUP; }
HANDLE APIENTRY NtUserSetClipboardData(UINT fmt, HANDLE hData, PSETCLIPBDATA pUnsafeScd) { SETCLIPBDATA scd; HANDLE hRet; TRACE("NtUserSetClipboardData(%x %p %p)\n", fmt, hData, pUnsafeScd); _SEH2_TRY { ProbeForRead(pUnsafeScd, sizeof(*pUnsafeScd), 1); RtlCopyMemory(&scd, pUnsafeScd, sizeof(scd)); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { SetLastNtError(_SEH2_GetExceptionCode()); _SEH2_YIELD(return NULL;) } _SEH2_END UserEnterExclusive(); /* Call internal function */ hRet = UserSetClipboardData(fmt, hData, &scd); UserLeave(); return hRet; }
BOOL APIENTRY NtUserHideCaret(HWND hWnd OPTIONAL) { PWND Window = NULL; USER_REFERENCE_ENTRY Ref; DECLARE_RETURN(BOOL); BOOL ret; TRACE("Enter NtUserHideCaret\n"); UserEnterExclusive(); if(hWnd && !(Window = UserGetWindowObject(hWnd))) { RETURN(FALSE); } if (Window) UserRefObjectCo(Window, &Ref); ret = co_UserHideCaret(Window); if (Window) UserDerefObjectCo(Window); RETURN(ret); CLEANUP: TRACE("Leave NtUserHideCaret, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
BOOL APIENTRY NtUserCloseClipboard(VOID) { BOOL ret = FALSE; UserEnterExclusive(); if (intIsClipboardOpenByMe()) { ClipboardWindow = NULL; ClipboardThread = NULL; ret = TRUE; } else { EngSetLastError(ERROR_CLIPBOARD_NOT_OPEN); } recentlySetClipboard = FALSE; UserLeave(); if (sendDrawClipboardMsg && WindowsChain) { /* only send message to the first window in the chain, then they'll do the chain */ /* commented because it makes a crash in co_MsqSendMessage ASSERT(WindowsChain->window); ASSERT(WindowsChain->window->hSelf); ERR("Clipboard: sending WM_DRAWCLIPBOARD to %p\n", WindowsChain->window->hSelf); co_IntSendMessage(WindowsChain->window->hSelf, WM_DRAWCLIPBOARD, 0, 0); */ } return ret; }
/* * @unimplemented */ DWORD_PTR APIENTRY NtUserCallNoParam(DWORD Routine) { DWORD_PTR Result = 0; DECLARE_RETURN(DWORD_PTR); TRACE("Enter NtUserCallNoParam\n"); UserEnterExclusive(); switch(Routine) { case NOPARAM_ROUTINE_CREATEMENU: Result = (DWORD_PTR)UserCreateMenu(FALSE); break; case NOPARAM_ROUTINE_CREATEMENUPOPUP: Result = (DWORD_PTR)UserCreateMenu(TRUE); break; case NOPARAM_ROUTINE_DESTROY_CARET: Result = (DWORD_PTR)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread); break; case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP: Result = (DWORD_PTR)IntInitMessagePumpHook(); break; case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP: Result = (DWORD_PTR)IntUninitMessagePumpHook(); break; case NOPARAM_ROUTINE_GETMESSAGEEXTRAINFO: Result = (DWORD_PTR)MsqGetMessageExtraInfo(); break; case NOPARAM_ROUTINE_MSQCLEARWAKEMASK: RETURN( (DWORD_PTR)IntMsqClearWakeMask()); case NOPARAM_ROUTINE_GETMSESSAGEPOS: { PTHREADINFO pti = PsGetCurrentThreadWin32Thread(); RETURN( (DWORD_PTR)MAKELONG(pti->ptLast.x, pti->ptLast.y)); } case NOPARAM_ROUTINE_RELEASECAPTURE: RETURN( (DWORD_PTR)IntReleaseCapture()); default: ERR("Calling invalid routine number 0x%x in NtUserCallNoParam\n", Routine); EngSetLastError(ERROR_INVALID_PARAMETER); break; } RETURN(Result); CLEANUP: TRACE("Leave NtUserCallNoParam, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
VOID APIENTRY NtUserNotifyWinEvent( DWORD Event, HWND hWnd, LONG idObject, LONG idChild) { PWND Window = NULL; USER_REFERENCE_ENTRY Ref; UserEnterExclusive(); /* Validate input */ if (hWnd && (hWnd != INVALID_HANDLE_VALUE)) { Window = UserGetWindowObject(hWnd); if (!Window) { UserLeave(); return; } } if (gpsi->dwInstalledEventHooks & GetMaskFromEvent(Event)) { if (Window) UserRefObjectCo(Window, &Ref); IntNotifyWinEvent( Event, Window, idObject, idChild, WEF_SETBYWNDPTI); if (Window) UserDerefObjectCo(Window); } UserLeave(); }
UINT_PTR APIENTRY NtUserSetTimer ( HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc ) { PWND Window; DECLARE_RETURN(UINT_PTR); TRACE("Enter NtUserSetTimer\n"); UserEnterExclusive(); Window = UserGetWindowObject(hWnd); UserLeave(); RETURN(IntSetTimer(Window, nIDEvent, uElapse, lpTimerFunc, TMRF_TIFROMWND)); CLEANUP: TRACE("Leave NtUserSetTimer, ret=%i\n", _ret_); END_CLEANUP; }
/* * @implemented */ BOOL APIENTRY NtUserClipCursor( RECTL *prcl) { RECTL rclLocal; BOOL bResult; if (prcl) { _SEH2_TRY { /* Probe and copy rect */ ProbeForRead(prcl, sizeof(RECTL), 1); rclLocal = *prcl; } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { EngSetLastError(ERROR_INVALID_PARAMETER); _SEH2_YIELD(return FALSE;) } _SEH2_END prcl = &rclLocal; } UserEnterExclusive(); /* Call the internal function */ bResult = UserClipCursor(prcl); UserLeave(); return bResult; }
/* * @implemented */ BOOL APIENTRY NtUserDestroyCursor( _In_ HANDLE hCurIcon, _In_ BOOL bForce) { PCURICON_OBJECT CurIcon; BOOL ret; DECLARE_RETURN(BOOL); TRACE("Enter NtUserDestroyCursorIcon\n"); UserEnterExclusive(); if (!(CurIcon = UserGetCurIconObject(hCurIcon))) { RETURN(FALSE); } ret = IntDestroyCurIconObject(CurIcon, bForce); /* Note: IntDestroyCurIconObject will remove our reference for us! */ RETURN(ret); CLEANUP: TRACE("Leave NtUserDestroyCursorIcon, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
/* * @implemented */ HWND APIENTRY NtUserSetFocus(HWND hWnd) { PWND Window; USER_REFERENCE_ENTRY Ref; DECLARE_RETURN(HWND); HWND ret; TRACE("Enter NtUserSetFocus(%p)\n", hWnd); UserEnterExclusive(); if (hWnd) { if (!(Window = UserGetWindowObject(hWnd))) { ERR("NtUserSetFocus: Invalid handle 0x%p!\n",hWnd); RETURN(NULL); } UserRefObjectCo(Window, &Ref); ret = co_UserSetFocus(Window); UserDerefObjectCo(Window); RETURN(ret); } else { RETURN( co_UserSetFocus(0)); } CLEANUP: TRACE("Leave NtUserSetFocus, ret=%p\n",_ret_); UserLeave(); END_CLEANUP; }
HANDLE APIENTRY NtUserRemoveProp(HWND hWnd, ATOM Atom) { PWND Window; PPROPERTY Prop; HANDLE Data; DECLARE_RETURN(HANDLE); TRACE("Enter NtUserRemoveProp\n"); UserEnterExclusive(); if (!(Window = UserGetWindowObject(hWnd))) { RETURN( NULL); } Prop = IntGetProp(Window, Atom); if (Prop == NULL) { RETURN(NULL); } Data = Prop->Data; RemoveEntryList(&Prop->PropListEntry); UserHeapFree(Prop); Window->PropListItems--; RETURN(Data); CLEANUP: TRACE("Leave NtUserRemoveProp, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
NTSTATUS APIENTRY Win32kThreadCallback(struct _ETHREAD *Thread, PSW32THREADCALLOUTTYPE Type) { NTSTATUS Status; UserEnterExclusive(); ASSERT(NtCurrentTeb()); if (Type == PsW32ThreadCalloutInitialize) { ASSERT(PsGetThreadWin32Thread(Thread) == NULL); Status = UserCreateThreadInfo(Thread); } else { ASSERT(PsGetThreadWin32Thread(Thread) != NULL); Status = UserDestroyThreadInfo(Thread); } UserLeave(); return Status; }
BOOL APIENTRY NtUserChangeClipboardChain(HWND hWndRemove, HWND hWndNewNext) { BOOL bRet = FALSE; PWND pWindowRemove; PWINSTATION_OBJECT pWinStaObj; TRACE("NtUserChangeClipboardChain(%p, %p)\n", hWndRemove, hWndNewNext); UserEnterExclusive(); pWinStaObj = IntGetWinStaForCbAccess(); if (!pWinStaObj) goto cleanup; pWindowRemove = UserGetWindowObject(hWndRemove); if (pWindowRemove && pWinStaObj->spwndClipViewer) { if(pWindowRemove == pWinStaObj->spwndClipViewer) pWinStaObj->spwndClipViewer = UserGetWindowObject(hWndNewNext); if(pWinStaObj->spwndClipViewer) bRet = (BOOL)co_IntSendMessage(pWinStaObj->spwndClipViewer->head.h, WM_CHANGECBCHAIN, (WPARAM)hWndRemove, (LPARAM)hWndNewNext); } ObDereferenceObject(pWinStaObj); cleanup: UserLeave(); return bRet; }
DWORD APIENTRY NtUserSetThreadState( DWORD Set, DWORD Flags) { PTHREADINFO pti; DWORD Ret = 0; // Test the only flags user can change. if (Set & ~(QF_FF10STATUS|QF_DIALOGACTIVE|QF_TABSWITCHING|QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) return 0; if (Flags & ~(QF_FF10STATUS|QF_DIALOGACTIVE|QF_TABSWITCHING|QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) return 0; UserEnterExclusive(); pti = PsGetCurrentThreadWin32Thread(); if (pti->MessageQueue) { Ret = pti->MessageQueue->QF_flags; // Get the queue flags. if (Set) pti->MessageQueue->QF_flags |= (Set&Flags); // Set the queue flags. else { if (Flags) pti->MessageQueue->QF_flags &= ~Flags; // Clr the queue flags. } } UserLeave(); return Ret; }
/* * NtUserActivateKeyboardLayout * * Activates specified layout for thread or process */ HKL APIENTRY NtUserActivateKeyboardLayout( HKL hKl, ULONG Flags) { PKL pKl = NULL; HKL hkl = NULL; PTHREADINFO pti; UserEnterExclusive(); pti = PsGetCurrentThreadWin32Thread(); /* hKl can have special value HKL_NEXT or HKL_PREV */ if (hKl == (HKL)HKL_NEXT) { /* Get next keyboard layout starting with current */ if (pti->KeyboardLayout) pKl = pti->KeyboardLayout->pklNext; } else if (hKl == (HKL)HKL_PREV) { /* Get previous keyboard layout starting with current */ if (pti->KeyboardLayout) pKl = pti->KeyboardLayout->pklNext; } else pKl = UserHklToKbl(hKl); if (!pKl) { ERR("Invalid HKL %p!\n", hKl); goto cleanup; } hkl = pKl->hkl; /* FIXME: KLF_RESET KLF_SHIFTLOCK */ if (Flags & KLF_REORDER) gspklBaseLayout = pKl; if (pKl != pti->KeyboardLayout) { /* Activate layout for current thread */ pKl = co_UserActivateKbl(pti, pKl, Flags); /* Send shell message */ if (!(Flags & KLF_NOTELLSHELL)) co_IntShellHookNotify(HSHELL_LANGUAGE, 0, (LPARAM)hkl); } cleanup: UserLeave(); return hkl; }
BOOL APIENTRY NtUserSBGetParms( HWND hWnd, int fnBar, PSBDATA pSBData, LPSCROLLINFO lpsi) { NTSTATUS Status; PWND Window; SCROLLINFO psi; DWORD sz; BOOL Ret; DECLARE_RETURN(BOOL); USER_REFERENCE_ENTRY Ref; TRACE("Enter NtUserGetScrollInfo\n"); UserEnterExclusive(); Status = MmCopyFromCaller(&psi.cbSize, &(lpsi->cbSize), sizeof(UINT)); if(!NT_SUCCESS(Status) || !((psi.cbSize == sizeof(SCROLLINFO)) || (psi.cbSize == sizeof(SCROLLINFO) - sizeof(psi.nTrackPos)))) { SetLastNtError(Status); RETURN(FALSE); } sz = psi.cbSize; Status = MmCopyFromCaller(&psi, lpsi, sz); if (!NT_SUCCESS(Status)) { SetLastNtError(Status); RETURN(FALSE); } if(!(Window = UserGetWindowObject(hWnd))) { RETURN(FALSE); } UserRefObjectCo(Window, &Ref); Ret = co_IntGetScrollInfo(Window, fnBar, &psi); UserDerefObjectCo(Window); Status = MmCopyToCaller(lpsi, &psi, sz); if(!NT_SUCCESS(Status)) { SetLastNtError(Status); RETURN( FALSE); } RETURN( Ret); CLEANUP: TRACE("Leave NtUserGetScrollInfo, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
/* * @implemented */ BOOL APIENTRY NtUserGetIconSize( HANDLE hCurIcon, UINT istepIfAniCur, PLONG plcx, // &size.cx PLONG plcy) // &size.cy { PCURICON_OBJECT CurIcon; NTSTATUS Status = STATUS_SUCCESS; BOOL bRet = FALSE; TRACE("Enter NtUserGetIconSize\n"); UserEnterExclusive(); if (!(CurIcon = UserGetCurIconObject(hCurIcon))) { goto cleanup; } if(CurIcon->CURSORF_flags & CURSORF_ACON) { /* Use first frame for animated cursors */ PACON AniCurIcon = (PACON)CurIcon; CurIcon = AniCurIcon->aspcur[0]; UserDereferenceObject(AniCurIcon); UserReferenceObject(CurIcon); } _SEH2_TRY { ProbeForWrite(plcx, sizeof(LONG), 1); *plcx = CurIcon->cx; ProbeForWrite(plcy, sizeof(LONG), 1); *plcy = CurIcon->cy; } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = _SEH2_GetExceptionCode(); } _SEH2_END if (NT_SUCCESS(Status)) bRet = TRUE; else SetLastNtError(Status); // Maybe not, test this UserDereferenceObject(CurIcon); cleanup: TRACE("Leave NtUserGetIconSize, ret=%i\n", bRet); UserLeave(); return bRet; }
BOOL APIENTRY NtUserOpenClipboard(HWND hWnd, DWORD Unknown1) { BOOL bRet; UserEnterExclusive(); bRet = UserOpenClipboard(hWnd); UserLeave(); return bRet; }
BOOL APIENTRY NtUserCloseClipboard(VOID) { BOOL bRet; UserEnterExclusive(); bRet = UserCloseClipboard(); UserLeave(); return bRet; }
/* * @implemented */ BOOL APIENTRY NtUserGetCursorInfo( PCURSORINFO pci) { CURSORINFO SafeCi; PSYSTEM_CURSORINFO CurInfo; NTSTATUS Status = STATUS_SUCCESS; PCURICON_OBJECT CurIcon; BOOL Ret = FALSE; DECLARE_RETURN(BOOL); TRACE("Enter NtUserGetCursorInfo\n"); UserEnterExclusive(); CurInfo = IntGetSysCursorInfo(); CurIcon = (PCURICON_OBJECT)CurInfo->CurrentCursorObject; SafeCi.cbSize = sizeof(CURSORINFO); SafeCi.flags = ((CurIcon && CurInfo->ShowingCursor >= 0) ? CURSOR_SHOWING : 0); SafeCi.hCursor = (CurIcon ? CurIcon->head.h : NULL); SafeCi.ptScreenPos = gpsi->ptCursor; _SEH2_TRY { if (pci->cbSize == sizeof(CURSORINFO)) { ProbeForWrite(pci, sizeof(CURSORINFO), 1); RtlCopyMemory(pci, &SafeCi, sizeof(CURSORINFO)); Ret = TRUE; } else { EngSetLastError(ERROR_INVALID_PARAMETER); } } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { Status = _SEH2_GetExceptionCode(); } _SEH2_END; if (!NT_SUCCESS(Status)) { SetLastNtError(Status); } RETURN(Ret); CLEANUP: TRACE("Leave NtUserGetCursorInfo, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }
/*! * Select logical palette into device context. * \param hDC handle to the device context * \param hpal handle to the palette * \param ForceBackground If this value is FALSE the logical palette will be copied to the device palette only when the applicatioon * is in the foreground. If this value is TRUE then map the colors in the logical palette to the device * palette colors in the best way. * \return old palette * * \todo implement ForceBackground == TRUE */ HPALETTE APIENTRY NtUserSelectPalette(HDC hDC, HPALETTE hpal, BOOL ForceBackground) { HPALETTE oldPal; UserEnterExclusive(); // Implement window checks oldPal = GdiSelectPalette( hDC, hpal, ForceBackground); UserLeave(); return oldPal; }
BOOL APIENTRY NtUserSetProcessWindowStation(HWINSTA hWindowStation) { BOOL ret; UserEnterExclusive(); ret = UserSetProcessWindowStation(hWindowStation); UserLeave(); return ret; }
BOOL APIENTRY NtUserEmptyClipboard(VOID) { BOOL bRet; TRACE("NtUserEmptyClipboard()\n"); UserEnterExclusive(); bRet = UserEmptyClipboard(); UserLeave(); return bRet; }
DWORD APIENTRY NtUserCallHwnd( HWND hWnd, DWORD Routine) { switch (Routine) { case HWND_ROUTINE_GETWNDCONTEXTHLPID: { PWND Window; DWORD HelpId; UserEnterShared(); if (!(Window = UserGetWindowObject(hWnd))) { UserLeave(); return 0; } HelpId = (DWORD)(DWORD_PTR)UserGetProp(Window, gpsi->atomContextHelpIdProp, TRUE); UserLeave(); return HelpId; } case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW: if (IntIsWindow(hWnd)) return IntRegisterShellHookWindow(hWnd); return FALSE; break; case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW: if (IntIsWindow(hWnd)) return IntDeRegisterShellHookWindow(hWnd); return FALSE; case HWND_ROUTINE_SETMSGBOX: { PWND Window; UserEnterExclusive(); if ((Window = UserGetWindowObject(hWnd))) { Window->state |= WNDS_MSGBOX; } UserLeave(); return FALSE; } } STUB; return 0; }
/* * @implemented */ HWND APIENTRY NtUserSetCapture(HWND hWnd) { DECLARE_RETURN(HWND); TRACE("Enter NtUserSetCapture(%p)\n", hWnd); UserEnterExclusive(); RETURN( co_UserSetCapture(hWnd)); CLEANUP: TRACE("Leave NtUserSetCapture, ret=%p\n", _ret_); UserLeave(); END_CLEANUP; }
/* * @implemented */ HWND APIENTRY NtUserGetForegroundWindow(VOID) { DECLARE_RETURN(HWND); TRACE("Enter NtUserGetForegroundWindow\n"); UserEnterExclusive(); RETURN( UserGetForegroundWindow()); CLEANUP: TRACE("Leave NtUserGetForegroundWindow, ret=%p\n",_ret_); UserLeave(); END_CLEANUP; }
/* * @implemented */ HCURSOR APIENTRY NtUserSetCursor( HCURSOR hCursor) { PCURICON_OBJECT pcurOld, pcurNew; HCURSOR hOldCursor = NULL; TRACE("Enter NtUserSetCursor\n"); UserEnterExclusive(); if (hCursor) { pcurNew = UserGetCurIconObject(hCursor); if (!pcurNew) { EngSetLastError(ERROR_INVALID_CURSOR_HANDLE); goto leave; } pcurNew->CURSORF_flags |= CURSORF_CURRENT; } else { pcurNew = NULL; } pcurOld = UserSetCursor(pcurNew, FALSE); if (pcurOld) { hOldCursor = pcurOld->head.h; pcurOld->CURSORF_flags &= ~CURSORF_CURRENT; if(UserObjectInDestroy(hOldCursor)) { /* Destroy it once and for all */ IntDestroyCurIconObject(pcurOld, TRUE); hOldCursor = NULL; } else { UserDereferenceObject(pcurOld); } } leave: UserLeave(); return hOldCursor; }
/* * Called from usersrv. */ NTSTATUS APIENTRY NtUserInitialize( DWORD dwWinVersion, HANDLE hPowerRequestEvent, HANDLE hMediaRequestEvent) { NTSTATUS Status; TRACE("Enter NtUserInitialize(%lx, %p, %p)\n", dwWinVersion, hPowerRequestEvent, hMediaRequestEvent); /* Check if we are already initialized */ if (gpepCSRSS) return STATUS_UNSUCCESSFUL; /* Check Windows USER subsystem version */ if (dwWinVersion != USER_VERSION) { // FIXME: Should bugcheck! return STATUS_UNSUCCESSFUL; } /* Acquire exclusive lock */ UserEnterExclusive(); /* Save the EPROCESS of CSRSS */ InitCsrProcess(/*PsGetCurrentProcess()*/); // Initialize Power Request List (use hPowerRequestEvent). // Initialize Media Change (use hMediaRequestEvent). // InitializeGreCSRSS(); // { // Startup DxGraphics. // calls ** UserGetLanguageID() and sets it **. // Enables Fonts drivers, Initialize Font table & Stock Fonts. // } /* Initialize USER */ Status = UserInitialize(); /* Return */ UserLeave(); return Status; }
SHORT APIENTRY NtUserGetAsyncKeyState( INT key) { DECLARE_RETURN(SHORT); TRACE("Enter NtUserGetAsyncKeyState\n"); UserEnterExclusive(); RETURN((SHORT)UserGetAsyncKeyState(key)); CLEANUP: TRACE("Leave NtUserGetAsyncKeyState, ret=%i\n",_ret_); UserLeave(); END_CLEANUP; }