userfuncs.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ASSERT_REFS_CO(_obj_)
#define	DUMP_REFS(obj)   TRACE_CH(UserObj,"obj 0x%x, refs %i\n",obj, ((PHEAD)obj)->cLockObj)

Functions
FORCEINLINE PMENU	UserGetMenuObject (HMENU hMenu)
PWND FASTCALL	IntGetWindowObject (HWND hWnd)
BOOL FASTCALL	IntDdeSendMessageHook (PWND, UINT, WPARAM, LPARAM)
BOOL APIENTRY	IntDdePostMessageHook (IN PWND, IN UINT, IN WPARAM, IN OUT LPARAM *, IN OUT LONG_PTR *)
BOOL APIENTRY	IntDdeGetMessageHook (PMSG, LONG_PTR)
NTSTATUS NTAPI	InitThreadCallback (PETHREAD Thread)
HWINSTA FASTCALL	UserGetProcessWindowStation (VOID)
HWND FASTCALL	UserGetActiveWindow (VOID)
HWND FASTCALL	UserGetForegroundWindow (VOID)
HWND FASTCALL	co_UserSetFocus (PWND Window)
INT FASTCALL	UserReleaseDC (PWND Window, HDC hDc, BOOL EndPaint)
HDC FASTCALL	UserGetDCEx (PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
HDC FASTCALL	UserGetWindowDC (PWND Wnd)
NTSTATUS FASTCALL	InitSessionImpl (VOID)
BOOL NTAPI	InitMetrics (VOID)
LONG NTAPI	UserGetSystemMetrics (ULONG Index)
BOOL FASTCALL	UserIsDBCSEnabled (VOID)
BOOL FASTCALL	UserIsIMMEnabled (VOID)
BOOL FASTCALL	UserIsCTFIMEEnabled (VOID)
DWORD FASTCALL	UserGetKeyState (DWORD key)
DWORD FASTCALL	UserGetKeyboardType (DWORD TypeFlag)
HKL FASTCALL	UserGetKeyboardLayout (DWORD dwThreadId)
int __cdecl	_scwprintf (const wchar_t *format,...)
BOOL FASTCALL	UserSystemParametersInfo (UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
VOID FASTCALL	IntSetWindowState (PWND, UINT)
VOID FASTCALL	IntClearWindowState (PWND, UINT)
PTHREADINFO FASTCALL	IntTID2PTI (HANDLE)
HBRUSH FASTCALL	GetControlBrush (PWND, HDC, UINT)
HBRUSH FASTCALL	GetControlColor (PWND, PWND, HDC, UINT)
NTSTATUS	GetProcessLuid (IN PETHREAD Thread OPTIONAL, IN PEPROCESS Process OPTIONAL, OUT PLUID Luid)
BOOL FASTCALL	UserPostMessage (HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
PWND FASTCALL	UserGetWindowObject (HWND hWnd)
VOID FASTCALL	co_DestroyThreadWindows (struct _ETHREAD *Thread)
HWND FASTCALL	UserGetShellWindow (VOID)
BOOLEAN	co_UserDestroyWindow (PVOID Object)
PWND FASTCALL	UserGetAncestor (PWND Wnd, UINT Type)
BOOL APIENTRY	DefSetText (PWND Wnd, PCWSTR WindowText)
DWORD FASTCALL	IntGetWindowContextHelpId (PWND pWnd)
HMENU FASTCALL	UserCreateMenu (PDESKTOP Desktop, BOOL PopupMenu)
BOOL FASTCALL	UserSetMenuDefaultItem (PMENU Menu, UINT uItem, UINT fByPos)
BOOL FASTCALL	UserDestroyMenu (HMENU hMenu)
VOID FASTCALL	DefWndDoSizeMove (PWND pwnd, WORD wParam)
LRESULT	NC_DoNCPaint (PWND, HDC, INT)
void FASTCALL	NC_GetSysPopupPos (PWND, RECT *)
LRESULT	NC_HandleNCActivate (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCCalcSize (PWND wnd, WPARAM wparam, RECTL *winRect, BOOL Suspended)
VOID	NC_DrawFrame (HDC hDC, RECT *CurrentRect, BOOL Active, DWORD Style, DWORD ExStyle)
VOID	UserDrawCaptionBar (PWND pWnd, HDC hDC, INT Flags)
void FASTCALL	NC_GetInsideRect (PWND Wnd, RECT *rect)
LRESULT	NC_HandleNCLButtonDown (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCLButtonDblClk (PWND Wnd, WPARAM wParam, LPARAM lParam)
LRESULT	NC_HandleNCRButtonDown (PWND wnd, WPARAM wParam, LPARAM lParam)
HBRUSH FASTCALL	DefWndControlColor (HDC hDC, UINT ctlType)
BOOL	UserDrawSysMenuButton (PWND pWnd, HDC hDC, LPRECT Rect, BOOL Down)
BOOL	UserPaintCaption (PWND pWnd, INT Flags)
PWND FASTCALL	DWP_GetEnabledPopup (PWND pWnd)
BOOL FASTCALL	SetLayeredStatus (PWND pWnd, BYTE set)
BOOL FASTCALL	GetLayeredStatus (PWND pWnd)
PIMC FASTCALL	UserCreateInputContext (_In_ ULONG_PTR dwClientImcData)
VOID	UserFreeInputContext (_In_opt_ PVOID Object)
BOOLEAN	UserDestroyInputContext (_In_opt_ PVOID Object)
PVOID	AllocInputContextObject (_In_ PDESKTOP pDesk, _In_ PTHREADINFO pti, _In_ SIZE_T Size, _Out_ PVOID *HandleOwner)

Variables
PRTL_ATOM_TABLE	gAtomTable

Macro Definition Documentation

ASSERT_REFS_CO

#define ASSERT_REFS_CO

(

_obj_

)

Value:

{ \
   LONG ref = ((PHEAD)_obj_)->cLockObj;\
   if (!(ref >= 1)){ \
      ERR_CH(UserObj, "ASSERT: obj 0x%p, refs %ld\n", _obj_, ref); \
      ASSERT(FALSE); \
   } \
}

Definition at line 14 of file userfuncs.h.

DUMP_REFS

#define DUMP_REFS

(

obj

)

TRACE_CH(UserObj,"obj 0x%x, refs %i\n",obj, ((PHEAD)obj)->cLockObj)

Definition at line 45 of file userfuncs.h.

Function Documentation

_scwprintf()

int __cdecl _scwprintf	(	const wchar_t *	format,
			...
	)

Definition at line 13 of file _scwprintf.c.

{
    int len;
    va_list args;
 
    va_start(args, format);
    len = _vscwprintf(format, args);
    va_end(args);
 
    return len;
}

Referenced by UserpFormatMessages().

AllocInputContextObject()

PVOID AllocInputContextObject	(	_In_ PDESKTOP	pDesk,
		_In_ PTHREADINFO	pti,
		_In_ SIZE_T	Size,
		_Out_ PVOID *	HandleOwner
	)

Definition at line 1501 of file ime.c.

{
    PTHRDESKHEAD ObjHead;
 
    ASSERT(Size > sizeof(*ObjHead));
    ASSERT(pti != NULL);
 
    if (!pDesk)
        pDesk = pti->rpdesk;
 
    ObjHead = DesktopHeapAlloc(pDesk, Size);
    if (!ObjHead)
        return NULL;
 
    RtlZeroMemory(ObjHead, Size);
 
    ObjHead->pSelf = ObjHead;
    ObjHead->rpdesk = pDesk;
    ObjHead->pti = pti;
    IntReferenceThreadInfo(pti);
    *HandleOwner = pti;
    pti->ppi->UserHandleCount++;
 
    return ObjHead;
}

co_DestroyThreadWindows()

VOID FASTCALL co_DestroyThreadWindows

(

struct _ETHREAD *

Thread

)

co_UserDestroyWindow()

BOOLEAN co_UserDestroyWindow

(

PVOID

Object

)

Definition at line 2870 of file window.c.

{
   HWND hWnd;
   PWND pwndTemp;
   PTHREADINFO ti;
   MSG msg;
   PWND Window = Object;
 
   ASSERT_REFS_CO(Window); // FIXME: Temp HACK?
 
   /* NtUserDestroyWindow does check if the window has already been destroyed
      but co_UserDestroyWindow can be called from more paths which means
      that it can also be called for a window that has already been destroyed. */
   if (!IntIsWindow(UserHMGetHandle(Window)))
   {
      TRACE("Tried to destroy a window twice\n");
      return TRUE;
   }
 
   hWnd = UserHMGetHandle(Window);
   ti = PsGetCurrentThreadWin32Thread();
 
   TRACE("co_UserDestroyWindow(Window = 0x%p, hWnd = 0x%p)\n", Window, hWnd);
 
   /* Check for owner thread */
   if (Window->head.pti != ti)
   {
       /* Check if we are destroying the desktop window */
       if (! ((Window->head.rpdesk->dwDTFlags & DF_DESTROYED) && Window == Window->head.rpdesk->pDeskInfo->spwnd))
       {
           EngSetLastError(ERROR_ACCESS_DENIED);
           return FALSE;
       }
   }
 
   /* If window was created successfully and it is hooked */
   if ((Window->state2 & WNDS2_WMCREATEMSGPROCESSED))
   {
      if (co_HOOK_CallHooks(WH_CBT, HCBT_DESTROYWND, (WPARAM) hWnd, 0))
      {
         ERR("Destroy Window WH_CBT Call Hook return!\n");
         return FALSE;
      }
   }
 
   if (Window->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME])
   {
      if ((Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
      {
         if (Window->spwndOwner)
         {
            //ERR("DestroyWindow Owner out.\n");
            UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE);
         }
      }
   }
 
   /* Inform the parent */
   if (Window->style & WS_CHILD)
   {
      IntSendParentNotify(Window, WM_DESTROY);
   }
 
   if (!Window->spwndOwner && !IntGetParent(Window))
   {
      co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (WPARAM) hWnd, 0);
   }
 
   /* Hide the window */
   if (Window->style & WS_VISIBLE)
   {
      if (Window->style & WS_CHILD)
      {
         /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
         co_WinPosShowWindow(Window, SW_HIDE);
      }
      else
      {
         co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_HIDEWINDOW );
      }
   }
 
   /* Adjust last active */
   if ((pwndTemp = Window->spwndOwner))
   {
      while (pwndTemp->spwndOwner)
         pwndTemp = pwndTemp->spwndOwner;
 
      if (pwndTemp->spwndLastActive == Window)
         WndSetLastActive(pwndTemp, Window->spwndOwner);
   }
 
   if (Window->spwndParent && IntIsWindow(UserHMGetHandle(Window)))
   {
      if ((Window->style & (WS_POPUP | WS_CHILD)) == WS_CHILD)
      {
         if (!IntIsTopLevelWindow(Window))
         {
            //ERR("DestroyWindow Parent out.\n");
            UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE);
         }
      }
   }
 
   if (Window->head.pti->MessageQueue->spwndActive == Window)
      Window->head.pti->MessageQueue->spwndActive = NULL;
   if (Window->head.pti->MessageQueue->spwndFocus == Window)
      Window->head.pti->MessageQueue->spwndFocus = NULL;
   if (Window->head.pti->MessageQueue->spwndActivePrev == Window)
      Window->head.pti->MessageQueue->spwndActivePrev = NULL;
   if (Window->head.pti->MessageQueue->spwndCapture == Window)
      Window->head.pti->MessageQueue->spwndCapture = NULL;
 
   /*
    * Check if this window is the Shell's Desktop Window. If so set hShellWindow to NULL
    */
 
   if (ti->pDeskInfo != NULL)
   {
      if (ti->pDeskInfo->hShellWindow == hWnd)
      {
         ERR("Destroying the ShellWindow!\n");
         ti->pDeskInfo->hShellWindow = NULL;
      }
   }
 
   IntEngWindowChanged(Window, WOC_DELETE);
 
   if (!IntIsWindow(UserHMGetHandle(Window)))
   {
      return TRUE;
   }
 
    /* Recursively destroy owned windows */
    if (!(Window->style & WS_CHILD))
    {
        IntDestroyOwnedWindows(Window);
    }
 
    /* Generate mouse move message for the next window */
    msg.message = WM_MOUSEMOVE;
    msg.wParam = UserGetMouseButtonsState();
    msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
    msg.pt = gpsi->ptCursor;
    co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
 
   IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Window, OBJID_WINDOW, CHILDID_SELF, 0);
 
   /* Send destroy messages */
   IntSendDestroyMsg(UserHMGetHandle(Window));
 
   /* Destroy the default IME window if necessary */
   if (IS_IMM_MODE() && !(ti->TIF_flags & TIF_INCLEANUP) &&
       ti->spwndDefaultIme && (ti->spwndDefaultIme != Window) &&
       !(Window->state & WNDS_DESTROYED) && !IS_WND_IMELIKE(Window))
   {
       if (IS_WND_CHILD(Window))
       {
           if (IntImeCanDestroyDefIMEforChild(ti->spwndDefaultIme, Window))
               co_UserDestroyWindow(ti->spwndDefaultIme);
       }
       else
       {
           if (IntImeCanDestroyDefIME(ti->spwndDefaultIme, Window))
               co_UserDestroyWindow(ti->spwndDefaultIme);
       }
   }
 
   if (!IntIsWindow(UserHMGetHandle(Window)))
   {
      return TRUE;
   }
 
   /* Destroy the window storage */
   co_UserFreeWindow(Window, PsGetCurrentProcessWin32Process(), PsGetCurrentThreadWin32Thread(), TRUE);
 
   return TRUE;
}

Referenced by co_UserCreateWindowEx(), co_UserDestroyWindow(), handle_internal_message(), IntDefWindowProc(), IntDesktopObjectDelete(), IntDestroyOwnedWindows(), IntTrackPopupMenuEx(), MENU_HideSubPopups(), MENU_TrackMenu(), NtUserDestroyWindow(), and NtUserDisableThreadIme().

co_UserSetFocus()

HWND FASTCALL co_UserSetFocus

(

PWND

Window

)

Definition at line 1317 of file focus.c.

{
   HWND hWndPrev = 0;
   PWND pwndTop;
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE ThreadQueue;
 
   if (Window)
      ASSERT_REFS_CO(Window);
 
   pti = PsGetCurrentThreadWin32Thread();
   ThreadQueue = pti->MessageQueue;
   ASSERT(ThreadQueue != 0);
 
   TRACE("Enter SetFocus hWnd 0x%p pti 0x%p\n",Window ? UserHMGetHandle(Window) : 0, pti );
 
   hWndPrev = ThreadQueue->spwndFocus ? UserHMGetHandle(ThreadQueue->spwndFocus) : 0;
 
   if (Window != 0)
   {
      if (hWndPrev == UserHMGetHandle(Window))
      {
         return hWndPrev ? (IntIsWindow(hWndPrev) ? hWndPrev : 0) : 0; /* Nothing to do */
      }
 
      if (Window->head.pti->MessageQueue != ThreadQueue)
      {
         ERR("SetFocus Must have the same Q!\n");
         return 0;
      }
 
      /* Check if we can set the focus to this window */
      for (pwndTop = Window; pwndTop; pwndTop = pwndTop->spwndParent)
      {
         if (pwndTop->style & (WS_MINIMIZED|WS_DISABLED)) return 0;
         if ((pwndTop->style & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
         if (pwndTop->spwndParent == NULL) break;
      }
      if (co_HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)UserHMGetHandle(Window), (LPARAM)hWndPrev))
      {
         ERR("SetFocus 1 WH_CBT Call Hook return!\n");
         return 0;
      }
 
      /* Activate pwndTop if needed. */
      if (pwndTop != ThreadQueue->spwndActive)
      {
         PUSER_MESSAGE_QUEUE ForegroundQueue = IntGetFocusMessageQueue(); // Keep it based on desktop.
         if (ThreadQueue != ForegroundQueue && IsAllowedFGActive(pti, pwndTop)) // Rule 2 & 3.
         {
            //ERR("SetFocus: Set Foreground!\n");
            if (!(pwndTop->style & WS_VISIBLE))
            {
                pti->ppi->W32PF_flags |= W32PF_ALLOWFOREGROUNDACTIVATE;
            }
            if (!co_IntSetForegroundAndFocusWindow(pwndTop, FALSE, TRUE))
            {
               ERR("SetFocus: Set Foreground and Focus Failed!\n");
               return 0;
            }
         }
 
         /* Set Active when it is needed. */
         if (pwndTop != ThreadQueue->spwndActive)
         {
            //ERR("SetFocus: Set Active! %p\n",pwndTop?UserHMGetHandle(pwndTop):0);
            if (!co_IntSetActiveWindow(pwndTop, FALSE, FALSE, FALSE))
            {
               ERR("SetFocus: Set Active Failed!\n");
               return 0;
            }
         }
 
         /* Abort if window destroyed */
         if (Window->state2 & WNDS2_INDESTROY) return 0;
         /* Do not change focus if the window is no longer active */
         if (pwndTop != ThreadQueue->spwndActive)
         {
            ERR("SetFocus: Top window did not go active!\n");
            return 0;
         }
      }
 
      // Check again! SetActiveWindow could have set the focus via WM_ACTIVATE.
      hWndPrev = ThreadQueue->spwndFocus ? UserHMGetHandle(ThreadQueue->spwndFocus) : 0;
 
      IntSendFocusMessages( pti, Window);
 
      TRACE("Focus: %p -> %p\n", hWndPrev, UserHMGetHandle(Window));
   }
   else /* NULL hwnd passed in */
   {
      if (co_HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)0, (LPARAM)hWndPrev))
      {
         ERR("SetFocus: 2 WH_CBT Call Hook return!\n");
         return 0;
      }
      //ERR("SetFocus: Set Focus NULL\n");
      /* set the current thread focus window null */
      IntSendFocusMessages( pti, NULL);
   }
   return hWndPrev ? (IntIsWindow(hWndPrev) ? hWndPrev : 0) : 0;
}

Referenced by co_WinPosShowWindow(), IntDefWindowProc(), IntEnableWindow(), IntSendDestroyMsg(), and NtUserSetFocus().

DefSetText()

BOOL APIENTRY DefSetText	(	PWND	Wnd,
		PCWSTR	WindowText
	)

Definition at line 4390 of file window.c.

{
   UNICODE_STRING UnicodeString;
   BOOL Ret = FALSE;
 
   RtlInitUnicodeString(&UnicodeString, WindowText);
 
   if (UnicodeString.Length != 0)
   {
      if (Wnd->strName.MaximumLength > 0 &&
          UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL))
      {
         ASSERT(Wnd->strName.Buffer != NULL);
 
         Wnd->strName.Length = UnicodeString.Length;
         Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
         RtlCopyMemory(Wnd->strName.Buffer,
                              UnicodeString.Buffer,
                              UnicodeString.Length);
      }
      else
      {
         PWCHAR buf;
         Wnd->strName.MaximumLength = Wnd->strName.Length = 0;
         buf = Wnd->strName.Buffer;
         Wnd->strName.Buffer = NULL;
         if (buf != NULL)
         {
            DesktopHeapFree(Wnd->head.rpdesk, buf);
         }
 
         Wnd->strName.Buffer = DesktopHeapAlloc(Wnd->head.rpdesk,
                                                   UnicodeString.Length + sizeof(UNICODE_NULL));
         if (Wnd->strName.Buffer != NULL)
         {
            Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
            RtlCopyMemory(Wnd->strName.Buffer,
                                 UnicodeString.Buffer,
                                 UnicodeString.Length);
            Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL);
            Wnd->strName.Length = UnicodeString.Length;
         }
         else
         {
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto Exit;
         }
      }
   }
   else
   {
      Wnd->strName.Length = 0;
      if (Wnd->strName.Buffer != NULL)
          Wnd->strName.Buffer[0] = L'\0';
   }
 
   // FIXME: HAX! Windows does not do this in here!
   // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than
   // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc.
   /* Send shell notifications */
   if (!Wnd->spwndOwner && !IntGetParent(Wnd))
   {
      co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM) UserHMGetHandle(Wnd), FALSE); // FIXME Flashing?
   }
 
   Ret = TRUE;
Exit:
   if (UnicodeString.Buffer) RtlFreeUnicodeString(&UnicodeString);
   return Ret;
}

Referenced by IntDefWindowProc(), RealDefWindowProcA(), and RealDefWindowProcW().

DefWndControlColor()

HBRUSH FASTCALL DefWndControlColor	(	HDC	hDC,
		UINT	ctlType
	)

Definition at line 32 of file defwnd.c.

{
  if (ctlType == CTLCOLOR_SCROLLBAR)
  {
      HBRUSH hb = IntGetSysColorBrush(COLOR_SCROLLBAR);
      COLORREF bk = IntGetSysColor(COLOR_3DHILIGHT);
      IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_3DFACE));
      IntGdiSetBkColor(hDC, bk);
 
      /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
       * we better use 0x55aa bitmap brush to make scrollbar's background
       * look different from the window background.
       */
      if ( bk == IntGetSysColor(COLOR_WINDOW))
          return gpsi->hbrGray;
 
      NtGdiUnrealizeObject( hb );
      return hb;
  }
 
  IntGdiSetTextColor(hDC, IntGetSysColor(COLOR_WINDOWTEXT));
 
  if ((ctlType == CTLCOLOR_EDIT) || (ctlType == CTLCOLOR_LISTBOX))
  {
      IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_WINDOW));
  }
  else
  {
      IntGdiSetBkColor(hDC, IntGetSysColor(COLOR_3DFACE));
      return IntGetSysColorBrush(COLOR_3DFACE);
  }
 
  return IntGetSysColorBrush(COLOR_WINDOW);
}

DefWndDoSizeMove()

VOID FASTCALL DefWndDoSizeMove	(	PWND	pwnd,
		WORD	wParam
	)

Definition at line 254 of file nonclient.c.

{
   MSG msg;
   RECT sizingRect, mouseRect, origRect, unmodRect, snapPreviewRect;
   PRECT pFrameRect = &sizingRect;
   HDC hdc;
   LONG hittest = (LONG)(wParam & 0x0f);
   PCURICON_OBJECT DragCursor = NULL, OldCursor = NULL;
   POINT minTrack, maxTrack;
   POINT capturePoint, pt;
   ULONG Style, ExStyle;
   UINT orgSnap = IntGetWindowSnapEdge(pwnd), snap = orgSnap;
   BOOL thickframe;
   BOOL iconic;
   BOOL moved = FALSE;
   BOOL DragFullWindows = FALSE;
   PWND pWndParent = NULL;
   WPARAM syscommand = (wParam & 0xfff0);
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
   //PMONITOR mon = 0; Don't port sync from wine!!! This breaks explorer task bar sizing!!
   //                  The task bar can grow in size and can not reduce due to the change
   //                  in the work area.
 
   Style = pwnd->style;
   ExStyle = pwnd->ExStyle;
   iconic = (Style & WS_MINIMIZE) != 0;
 
   if (((Style & WS_MAXIMIZE) && syscommand != SC_MOVE) || !IntIsWindowVisible(pwnd)) return;
   if ((Style & (WS_MAXIMIZE | WS_CHILD)) == WS_MAXIMIZE)
       orgSnap = snap = HTTOP;
 
   thickframe = UserHasThickFrameStyle(Style, ExStyle) && !iconic;
 
   //
   // Show window contents while dragging the window, get flag from registry data.
   //
   UserSystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &DragFullWindows, 0);
 
   pt.x = pti->ptLast.x;
   pt.y = pti->ptLast.y;
   capturePoint = pt;
   UserClipCursor( NULL );
 
   TRACE("pwnd %p command %04lx, hittest %d, pos %d,%d\n",
          pwnd, syscommand, hittest, pt.x, pt.y);
 
   if (syscommand == SC_MOVE)
   {
      if (!hittest) hittest = DefWndStartSizeMove(pwnd, wParam, &capturePoint);
      if (!hittest) return;
   }
   else  /* SC_SIZE */
   {
      if (!thickframe) return;
      if (hittest && (syscommand != SC_MOUSEMENU))
      {
          hittest += (HTLEFT - WMSZ_LEFT);
      }
      else
      {
          co_UserSetCapture(UserHMGetHandle(pwnd));
          hittest = DefWndStartSizeMove(pwnd, wParam, &capturePoint);
          if (!hittest)
          {
              IntReleaseCapture();
              return;
          }
      }
   }
 
   /* Get min/max info */
 
   co_WinPosGetMinMaxInfo(pwnd, NULL, NULL, &minTrack, &maxTrack);
   sizingRect = pwnd->rcWindow;
   origRect = sizingRect;
   if (Style & WS_CHILD)
   {
      pWndParent = IntGetParent(pwnd);
      IntGetClientRect( pWndParent, &mouseRect );
      IntMapWindowPoints( pWndParent, 0, (LPPOINT)&mouseRect, 2 );
      IntMapWindowPoints( 0, pWndParent, (LPPOINT)&sizingRect, 2 );
      unmodRect = sizingRect;
   }
   else
   {
      if (!(ExStyle & WS_EX_TOPMOST))
      {
        UserSystemParametersInfo(SPI_GETWORKAREA, 0, &mouseRect, 0);
      }
      else
      {
        RECTL_vSetRect(&mouseRect, 0, 0, UserGetSystemMetrics(SM_CXSCREEN), UserGetSystemMetrics(SM_CYSCREEN));
      }
      unmodRect = sizingRect;
   }
 
   if (ON_LEFT_BORDER(hittest))
   {
      mouseRect.left  = max( mouseRect.left, sizingRect.right-maxTrack.x+capturePoint.x-sizingRect.left );
      mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x+capturePoint.x-sizingRect.left );
   }
   else if (ON_RIGHT_BORDER(hittest))
   {
      mouseRect.left  = max( mouseRect.left, sizingRect.left+minTrack.x+capturePoint.x-sizingRect.right );
      mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x+capturePoint.x-sizingRect.right );
   }
   if (ON_TOP_BORDER(hittest))
   {
      mouseRect.top    = max( mouseRect.top, sizingRect.bottom-maxTrack.y+capturePoint.y-sizingRect.top );
      mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y+capturePoint.y-sizingRect.top);
   }
   else if (ON_BOTTOM_BORDER(hittest))
   {
      mouseRect.top    = max( mouseRect.top, sizingRect.top+minTrack.y+capturePoint.y-sizingRect.bottom );
      mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y+capturePoint.y-sizingRect.bottom );
   }
 
   hdc = UserGetDCEx( pWndParent, 0, DCX_CACHE );
   if (iconic)
   {
       DragCursor = pwnd->pcls->spicn;
       if (DragCursor)
       {
           UserReferenceObject(DragCursor);
       }
       else
       {
           HCURSOR CursorHandle = (HCURSOR)co_IntSendMessage( UserHMGetHandle(pwnd), WM_QUERYDRAGICON, 0, 0 );
           if (CursorHandle)
           {
               DragCursor = UserGetCurIconObject(CursorHandle);
           }
           else
           {
               iconic = FALSE;
           }
       }
   }
 
   /* repaint the window before moving it around */
   co_UserRedrawWindow( pwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
 
   IntNotifyWinEvent( EVENT_SYSTEM_MOVESIZESTART, pwnd, OBJID_WINDOW, CHILDID_SELF, 0);
 
   co_IntSendMessage( UserHMGetHandle(pwnd), WM_ENTERSIZEMOVE, 0, 0 );
 
   MsqSetStateWindow(pti, MSQ_STATE_MOVESIZE, UserHMGetHandle(pwnd));
 
   if (IntGetCapture() != UserHMGetHandle(pwnd)) co_UserSetCapture( UserHMGetHandle(pwnd) );
 
   pwnd->head.pti->TIF_flags |= TIF_MOVESIZETRACKING;
 
   for(;;)
   {
      int dx = 0, dy = 0;
 
      if (!co_IntGetPeekMessage(&msg, 0, 0, 0, PM_REMOVE, TRUE)) break;
      if (IntCallMsgFilter( &msg, MSGF_SIZE )) continue;
 
      if (msg.message == WM_KEYDOWN && (msg.wParam == VK_RETURN || msg.wParam == VK_ESCAPE))
         break; // Exit on Return or Esc
 
      if (!g_bWindowSnapEnabled && (msg.message == WM_LBUTTONUP ||
         (msg.message == WM_MOUSEMOVE && (msg.wParam & MK_LBUTTON) == 0)))
      { // If no WindowSnapEnabled: Exit on button-up immediately
         break;
      }
      else if (g_bWindowSnapEnabled && (msg.message == WM_LBUTTONUP ||
              (msg.message == WM_MOUSEMOVE && (msg.wParam & MK_LBUTTON) == 0)))
      { // If WindowSnapEnabled: Decide whether to snap before exiting
         if (hittest == HTCAPTION && thickframe && /* Check for snapping if was moved by caption */
             IntIsSnapAllowedForWindow(pwnd) && (ExStyle & WS_EX_MDICHILD) == 0)
         {
            BOOLEAN wasSnap = IntIsWindowSnapped(pwnd); /* Need the live snap state, not orgSnap nor maximized state */
            UINT snapTo = iconic ? HTNOWHERE : GetSnapActivationPoint(pwnd, pt);
            if (snapTo)
            {
                if (DragFullWindows)
                {
                    co_IntSnapWindow(pwnd, snapTo);
                    if (!wasSnap)
                        pwnd->InternalPos.NormalRect = origRect;
                }
                snap = snapTo;
            }
         }
         break;
      }
 
      if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
      {
         IntTranslateKbdMessage( &msg , 0 );
         IntDispatchMessage( &msg );
         continue;  /* We are not interested in other messages */
      }
 
      pt = msg.pt;
 
      if (msg.message == WM_KEYDOWN) switch(msg.wParam)
      {
      case VK_UP:    pt.y -= 8; break;
      case VK_DOWN:  pt.y += 8; break;
      case VK_LEFT:  pt.x -= 8; break;
      case VK_RIGHT: pt.x += 8; break;
      }
 
      pt.x = max( pt.x, mouseRect.left );
      pt.x = min( pt.x, mouseRect.right - 1 );
      pt.y = max( pt.y, mouseRect.top );
      pt.y = min( pt.y, mouseRect.bottom - 1 );
 
      dx = pt.x - capturePoint.x;
      dy = pt.y - capturePoint.y;
 
      if (dx || dy)
      {
      if (!moved)
      {
          moved = TRUE;
          if (iconic) /* ok, no system popup tracking */
          {
              OldCursor = UserSetCursor(DragCursor, FALSE);
              UserShowCursor(TRUE);
          }
          else if (!DragFullWindows)
             UserDrawMovingFrame(hdc, &sizingRect, thickframe);
      }
 
      if (msg.message == WM_KEYDOWN)
      {
          UserSetCursorPos(pt.x, pt.y, 0, 0, FALSE);
      }
      else
      {
          RECT newRect = unmodRect;
 
          if (!iconic && !DragFullWindows)
          {
              UserDrawMovingFrame(hdc, pFrameRect, thickframe);
              pFrameRect = &sizingRect;
          }
          if (hittest == HTCAPTION)
          {
              /* Restore window size if it is snapped */
              PRECT pr = &newRect;
              LONG width, height, capcy, snapTo;
              if (snap && syscommand == SC_MOVE && !iconic &&
                  !RECTL_bIsEmptyRect(&pwnd->InternalPos.NormalRect))
              {
                  *pr = pwnd->InternalPos.NormalRect;
                  origRect = *pr; /* Save normal size - is required when window unsnapped from one side and snapped to another holding mouse down */
 
                  /* Try to position the center of the caption where the mouse is horizontally */
                  capcy = UserGetSystemMetrics((ExStyle & WS_EX_TOPMOST) ? SM_CYSMCAPTION : SM_CYCAPTION); /* No border, close enough */
                  width = pr->right - pr->left;
                  height = pr->bottom - pr->top;
                  pr->left = pt.x - width / 2;
                  pr->right = pr->left + width;
                  pr->top = mouseRect.top;
                  pr->bottom = pr->top + height;
                  if (pr->left < mouseRect.left)
                  {
                      pr->left = mouseRect.left;
                      pr->right = pr->left + width;
                  }
                  if ((pwnd->ExStyle & WS_EX_LAYOUTRTL) && pr->right > mouseRect.right)
                  {
                      pr->left = mouseRect.right - width;
                      pr->right = pr->left + width;
                  }
                  UserSetCursorPos(pt.x, pr->top + capcy / 2, 0, 0, FALSE);
                  snap = FALSE;
                  dx = dy = 0; /* Don't offset this move */
                  if (DragFullWindows)
                  {
                      IntSetStyle(pwnd, 0, WS_MAXIMIZE);
                      IntSetSnapEdge(pwnd, HTNOWHERE);
 
                      /* Have to move and size it now because we don't want SWP_NOSIZE */
                      co_WinPosSetWindowPos(pwnd, HWND_TOP, pr->left, pr->top, width, height, SWP_NOACTIVATE);
                  }
              }
              else if (!snap && syscommand == SC_MOVE && !iconic)
              {
                  if ((snapTo = GetSnapActivationPoint(pwnd, pt)) != 0)
                  {
                      co_IntCalculateSnapPosition(pwnd, snapTo, &snapPreviewRect);
                      if (DragFullWindows)
                      {
                          /* TODO: Show preview of snap */
                      }
                      else
                      {
                          pFrameRect = &snapPreviewRect;
                          UserDrawMovingFrame(hdc, pFrameRect, thickframe);
                          continue;
                      }
                  }
              }
 
              /* regular window moving */
              RECTL_vOffsetRect(&newRect, dx, dy);
          }
          if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
          else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
          if (ON_TOP_BORDER(hittest)) newRect.top += dy;
          else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
 
          capturePoint = pt;
 
              //
              //  Save the new position to the unmodified rectangle. This allows explorer task bar
              //  sizing. Explorer will forces back the position unless a certain amount of sizing
              //  has occurred.
              //
              unmodRect = newRect;
 
              /* Determine the hit location */
              if (syscommand == SC_SIZE)
              {
                  WPARAM wpSizingHit = 0;
 
                  if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
                      wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
                  co_IntSendMessage( UserHMGetHandle(pwnd), WM_SIZING, wpSizingHit, (LPARAM)&newRect );
              }
              else
                  co_IntSendMessage( UserHMGetHandle(pwnd), WM_MOVING, 0, (LPARAM)&newRect );
 
              if (!iconic)
              {
                 if (!DragFullWindows)
                     UserDrawMovingFrame( hdc, &newRect, thickframe );
                 else
                 {  // Moving the whole window now!
                    HRGN hrgnNew;
                    HRGN hrgnOrig = GreCreateRectRgnIndirect(&pwnd->rcWindow);
 
                    if (pwnd->hrgnClip != NULL)
                       NtGdiCombineRgn(hrgnOrig, hrgnOrig, pwnd->hrgnClip, RGN_AND);
 
                    //IntMapWindowPoints( 0, pWndParent, (POINT *)&rect, 2 );
                    co_WinPosSetWindowPos(pwnd,
                                          NULL,
                                          newRect.left,
                                          newRect.top,
                                          newRect.right - newRect.left,
                                          newRect.bottom - newRect.top,
                                          SWP_NOACTIVATE | ((hittest == HTCAPTION) ? SWP_NOSIZE : 0));
 
                    hrgnNew = GreCreateRectRgnIndirect(&pwnd->rcWindow);
                    if (pwnd->hrgnClip != NULL)
                       NtGdiCombineRgn(hrgnNew, hrgnNew, pwnd->hrgnClip, RGN_AND);
 
                    if (hrgnNew)
                    {
                       if (hrgnOrig)
                          NtGdiCombineRgn(hrgnOrig, hrgnOrig, hrgnNew, RGN_DIFF);
                    }
                    else
                    {
                       if (hrgnOrig)
                       {
                          GreDeleteObject(hrgnOrig);
                          hrgnOrig = 0;
                       }
                    }
 
                    // Update all the windows after the move or size, including this window.
                    UpdateThreadWindows(UserGetDesktopWindow()->spwndChild, pti, hrgnOrig);
 
                    if (hrgnOrig) GreDeleteObject(hrgnOrig);
                    if (hrgnNew) GreDeleteObject(hrgnNew);
                 }
              }
              sizingRect = newRect;
        }
      }
   }
 
   pwnd->head.pti->TIF_flags &= ~TIF_MOVESIZETRACKING;
 
   IntReleaseCapture();
 
   if ( iconic )
   {
      if ( moved ) /* restore cursors, show icon title later on */
      {
          UserShowCursor( FALSE );
          OldCursor = UserSetCursor(OldCursor, FALSE);
      }
 
      /* It could be that the cursor was already changed while we were proceeding,
       * so we must unreference whatever cursor was current at the time we restored the old one.
       * Maybe it is DragCursor, but maybe it is another one and DragCursor got already freed.
       */
      if (OldCursor) UserDereferenceObject(OldCursor);
   }
   else
   {
      UINT eraseFinalFrame = moved && !DragFullWindows;
      if (eraseFinalFrame)
         UserDrawMovingFrame(hdc, pFrameRect, thickframe); // Undo the XOR drawing
   }
 
   UserReleaseDC(NULL, hdc, FALSE);
 
   //if (pWndParent) IntMapWindowPoints( 0, pWndParent, (POINT *)&sizingRect, 2 );
 
   if (co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)UserHMGetHandle(pwnd), (LPARAM)&sizingRect))
   {
      ERR("DoSizeMove : WH_CBT Call Hook return!\n");
      moved = FALSE;
   }
 
   IntNotifyWinEvent( EVENT_SYSTEM_MOVESIZEEND, pwnd, OBJID_WINDOW, CHILDID_SELF, 0);
 
   MsqSetStateWindow(pti, MSQ_STATE_MOVESIZE, NULL);
 
   co_IntSendMessage( UserHMGetHandle(pwnd), WM_EXITSIZEMOVE, 0, 0 );
   co_IntSendMessage( UserHMGetHandle(pwnd), WM_SETVISIBLE, !!(pwnd->style & WS_MINIMIZE), 0L);
   /* window moved or resized */
   if (moved)
   {
      BOOL forceSizing = !iconic && hittest == HTCAPTION && (!!orgSnap != !!snap);
      UINT swp = (!forceSizing && hittest == HTCAPTION) ? SWP_NOSIZE : 0;
 
      /* if the moving/resizing isn't canceled call SetWindowPos
       * with the new position or the new size of the window
       */
      if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
      {
         /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
         if (!DragFullWindows || iconic)
         {
            if (snap)
            {
               co_IntSnapWindow(pwnd, snap);
            }
            else
            {
               if (orgSnap && !snap)
               {
                  IntSetStyle(pwnd, 0, WS_MAXIMIZE);
                  IntSetSnapInfo(pwnd, HTNOWHERE, NULL);
               }
               co_WinPosSetWindowPos(pwnd, HWND_TOP, sizingRect.left, sizingRect.top,
                                     sizingRect.right - sizingRect.left,
                                     sizingRect.bottom - sizingRect.top, swp);
            }
         }
      }
      else
      {
         /* restore previous size/position */
         if (orgSnap)
         {
            co_IntSnapWindow(pwnd, orgSnap);
         }
         else if (DragFullWindows)
         {
            co_WinPosSetWindowPos(pwnd, HWND_TOP, origRect.left, origRect.top,
                                  origRect.right - origRect.left,
                                  origRect.bottom - origRect.top, swp);
         }
      }
   }
 
   if (IntIsWindow(UserHMGetHandle(pwnd)))
   {
      /* Single click brings up the system menu when iconized */
      if (iconic && !moved && (Style & WS_SYSMENU))
      {
         co_IntSendMessage(UserHMGetHandle(pwnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, MAKELONG(pt.x, pt.y));
      }
   }
}

Referenced by DefWndHandleSysCommand().

DWP_GetEnabledPopup()

PWND FASTCALL DWP_GetEnabledPopup

(

PWND

pWnd

)

Definition at line 499 of file defwnd.c.

{
    PWND pwndNode1;
    PTHREADINFO pti = pWnd->head.pti, ptiNode;
    BOOL bFoundNullNode = FALSE;
 
    for (pwndNode1 = pWnd->spwndNext; pwndNode1 != pWnd; )
    {
        if (!pwndNode1) /* NULL detected? */
        {
            if (bFoundNullNode)
                return NULL;
            bFoundNullNode = TRUE;
            /* Retry with parent's first child (once only) */
            pwndNode1 = pWnd->spwndParent->spwndChild;
            continue;
        }
 
        /*
         * 1. We want to detect the window that owns the same input target of pWnd.
         * 2. For non-16-bit apps, we need to check the two threads' input queues to
         *    see whether they are the same, while for 16-bit apps it's sufficient to
         *    only check the thread info pointers themselves (ptiNode and pti).
         * See also:
         *    https://devblogs.microsoft.com/oldnewthing/20060221-09/?p=32203
         *    https://github.com/reactos/reactos/pull/7700#discussion_r1939435931
         */
        ptiNode = pwndNode1->head.pti;
        if ((!(pti->TIF_flags & TIF_16BIT) && ptiNode->MessageQueue == pti->MessageQueue) ||
            ((pti->TIF_flags & TIF_16BIT) && ptiNode == pti))
        {
            DWORD style = pwndNode1->style;
            if ((style & WS_VISIBLE) && !(style & WS_DISABLED)) /* Visible and enabled? */
            {
                /* Does pwndNode1 have a pWnd as an ancestor? */
                PWND pwndNode2;
                for (pwndNode2 = pwndNode1->spwndOwner; pwndNode2;
                     pwndNode2 = pwndNode2->spwndOwner)
                {
                    if (pwndNode2 == pWnd)
                        return pwndNode1;
                }
            }
        }
 
        pwndNode1 = pwndNode1->spwndNext;
    }
 
    return NULL;
}

Referenced by NtUserCallHwnd().

GetControlBrush()

HBRUSH FASTCALL GetControlBrush	(	PWND	pwnd,
		HDC	hdc,
		UINT	ctlType
	)

Definition at line 180 of file misc.c.

{
    PWND pwndParent = IntGetParent(pwnd);
    return GetControlColor( pwndParent, pwnd, hdc, ctlType);
}

Referenced by EDIT_NotifyCtlColor(), IntDrawScrollInterior(), NtUserGetControlBrush(), and STATIC_SendWmCtlColorStatic().

GetControlColor()

HBRUSH FASTCALL GetControlColor	(	PWND	pwndParent,
		PWND	pwnd,
		HDC	hdc,
		UINT	CtlMsg
	)

Definition at line 154 of file misc.c.

{
    HBRUSH hBrush;
 
    if (!pwndParent) pwndParent = pwnd;
 
    if ( pwndParent->head.pti->ppi != PsGetCurrentProcessWin32Process())
    {
       return (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
    }
 
    hBrush = (HBRUSH)co_IntSendMessage( UserHMGetHandle(pwndParent), CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd));
 
    if (!hBrush || !GreIsHandleValid(hBrush))
    {
       hBrush = (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
    }
    return hBrush;
}

Referenced by ButtonWndProc_common(), CB_Paint(), COMBO_PrepareColors(), DEFDLG_Proc(), GB_Paint(), GetControlBrush(), IntFillWindow(), LISTBOX_Paint(), LISTBOX_RepaintItem(), ListBoxWndProc_common(), NtUserGetControlColor(), OB_Paint(), PB_Paint(), and UB_Paint().

GetLayeredStatus()

BOOL FASTCALL GetLayeredStatus

(

PWND

pWnd

)

Definition at line 23 of file layered.c.

{
   PLRD_PROP pLrdProp = UserGetProp(pWnd, AtomLayer, TRUE);
   if (pLrdProp)
   {
      return pLrdProp->is_Layered;
   }
   return FALSE;
}

Referenced by NtUserUpdateLayeredWindow().

GetProcessLuid()

NTSTATUS GetProcessLuid	(	IN PETHREAD Thread	OPTIONAL,
		IN PEPROCESS Process	OPTIONAL,
		OUT PLUID	Luid
	)

Definition at line 815 of file misc.c.

{
    NTSTATUS Status;
    PACCESS_TOKEN Token = NULL;
    SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
    BOOLEAN CopyOnOpen, EffectiveOnly;
 
    if (Thread && Process)
        return STATUS_INVALID_PARAMETER;
 
    /* If nothing has been specified, use the current thread */
    if (!Thread && !Process)
        Thread = PsGetCurrentThread();
 
    if (Thread)
    {
        /* Use a thread token */
        ASSERT(!Process);
        Token = PsReferenceImpersonationToken(Thread,
                                              &CopyOnOpen,
                                              &EffectiveOnly,
                                              &ImpersonationLevel);
 
        /* If we don't have a thread token, use a process token */
        if (!Token)
            Process = PsGetThreadProcess(Thread);
    }
    if (!Token && Process)
    {
        /* Use a process token */
        Token = PsReferencePrimaryToken(Process);
 
        /* If we don't have a token, fail */
        if (!Token)
            return STATUS_NO_TOKEN;
    }
    ASSERT(Token);
 
    /* Query the LUID */
    Status = SeQueryAuthenticationIdToken(Token, Luid);
 
    /* Get rid of the token and return */
    ObDereferenceObject(Token);
    return Status;
}

Referenced by BuildUserModeWindowStationName(), IntResolveDesktop(), UserEndShutdown(), and UserInitiateShutdown().

InitMetrics()

BOOL NTAPI InitMetrics

(

VOID

)

Definition at line 41 of file metric.c.

{
    INT *piSysMet = gpsi->aiSysMet;
    ULONG Width, Height;
 
    /* Note: used for the SM_CLEANBOOT metric */
    DWORD dwValue = 0;
    HKEY hKey = 0;
 
    /* Clean boot */
    piSysMet[SM_CLEANBOOT] = 0; // Fallback value of 0 (normal mode)
    if(NT_SUCCESS(RegOpenKey(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\Option", &hKey)))
    {
        if(RegReadDWORD(hKey, L"OptionValue", &dwValue)) piSysMet[SM_CLEANBOOT] = (INT)dwValue;
        ZwClose(hKey);
    }
 
    /* FIXME: HACK, due to missing MDEV on first init */
    if (!gpmdev)
    {
        Width = 640;
        Height = 480;
    }
    else
    {
        Width = gpmdev->ppdevGlobal->gdiinfo.ulHorzRes;
        Height = gpmdev->ppdevGlobal->gdiinfo.ulVertRes;
    }
 
    /* Screen sizes */
    piSysMet[SM_CXSCREEN] = Width;
    piSysMet[SM_CYSCREEN] = Height;
    piSysMet[SM_XVIRTUALSCREEN] = 0;
    piSysMet[SM_YVIRTUALSCREEN] = 0;
    piSysMet[SM_CXVIRTUALSCREEN] = Width;
    piSysMet[SM_CYVIRTUALSCREEN] = Height;
 
    /* NC area sizes */
    piSysMet[SM_CYCAPTION] = gspv.ncm.iCaptionHeight + 1;       // 19
    piSysMet[SM_CYSMCAPTION] = gspv.ncm.iSmCaptionHeight + 1;   // 15;
    piSysMet[SM_CXSIZE] = gspv.ncm.iCaptionHeight;              // 18;
    piSysMet[SM_CYSIZE] = gspv.ncm.iCaptionHeight;              // 18;
    piSysMet[SM_CXSMSIZE] = gspv.ncm.iSmCaptionWidth;   // 12; XP: piSysMet(SM_CYSMCAPTION) - 1
    piSysMet[SM_CYSMSIZE] = gspv.ncm.iSmCaptionHeight;  // 14;
    piSysMet[SM_CXBORDER] = 1; // Seems to be hardcoded
    piSysMet[SM_CYBORDER] = 1; // Seems to be hardcoded
    piSysMet[SM_CXFOCUSBORDER] = 1;
    piSysMet[SM_CYFOCUSBORDER] = 1;
    piSysMet[SM_CXDLGFRAME] = 3;
    piSysMet[SM_CYDLGFRAME] = 3;
    piSysMet[SM_CXEDGE] = 2;
    piSysMet[SM_CYEDGE] = 2;
    piSysMet[SM_CXFRAME] = piSysMet[SM_CXDLGFRAME] + gspv.ncm.iBorderWidth; // 4
    piSysMet[SM_CYFRAME] = piSysMet[SM_CYDLGFRAME] + gspv.ncm.iBorderWidth; // 4
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[SM_CXPADDEDBORDER] = 0;
#endif
 
    /* Window sizes */
    TRACE("ncm.iCaptionWidth=%d,GetSystemMetrics(SM_CYSIZE)=%d,GetSystemMetrics(SM_CXFRAME)=%d,avcwCaption=%d \n",
           gspv.ncm.iCaptionWidth, piSysMet[SM_CYSIZE],piSysMet[SM_CXFRAME], gspv.tmCaptionFont.tmAveCharWidth);
 
    piSysMet[SM_CXMIN] = 3 * max(gspv.ncm.iCaptionWidth, 8) // 112
                         + piSysMet[SM_CYSIZE] + 4
                         + 4 * gspv.tmCaptionFont.tmAveCharWidth
                         + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMIN] = piSysMet[SM_CYCAPTION] + 2 * piSysMet[SM_CYFRAME]; // 27
    piSysMet[SM_CXMAXIMIZED] = piSysMet[SM_CXSCREEN] + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMAXIMIZED] = piSysMet[SM_CYSCREEN] - 20;
    piSysMet[SM_CXFULLSCREEN] = piSysMet[SM_CXSCREEN];
    piSysMet[SM_CYFULLSCREEN] = piSysMet[SM_CYMAXIMIZED] - piSysMet[SM_CYMIN];
    piSysMet[SM_CYKANJIWINDOW] = 0;
    piSysMet[SM_CXMINIMIZED] = gspv.mm.iWidth + 6;
    piSysMet[SM_CYMINIMIZED] = piSysMet[SM_CYCAPTION] + 5;
    piSysMet[SM_CXMINSPACING] = piSysMet[SM_CXMINIMIZED] + gspv.mm.iHorzGap;
    piSysMet[SM_CYMINSPACING] = piSysMet[SM_CYMINIMIZED] + gspv.mm.iVertGap;
    piSysMet[SM_CXMAXTRACK] = piSysMet[SM_CXVIRTUALSCREEN] + 4
                              + 2 * piSysMet[SM_CXFRAME];
    piSysMet[SM_CYMAXTRACK] = piSysMet[SM_CYVIRTUALSCREEN] + 4
                              + 2 * piSysMet[SM_CYFRAME];
 
    /* Icon */
    piSysMet[SM_CXVSCROLL] = gspv.ncm.iScrollWidth;     // 16;
    piSysMet[SM_CYVTHUMB] = gspv.ncm.iScrollHeight;     // 16;
    piSysMet[SM_CYHSCROLL] = gspv.ncm.iScrollWidth;     // 16;
    piSysMet[SM_CXHTHUMB] = gspv.ncm.iScrollHeight;     // 16;
    piSysMet[SM_CYVSCROLL] = gspv.ncm.iScrollHeight;    // 16
    piSysMet[SM_CXHSCROLL] = gspv.ncm.iScrollHeight;    // 16;
    piSysMet[SM_CXICON] = 32;
    piSysMet[SM_CYICON] = 32;
    piSysMet[SM_CXSMICON] = 16;
    piSysMet[SM_CYSMICON] = 16;
    piSysMet[SM_CXICONSPACING] = gspv.im.iHorzSpacing;  // 64;
    piSysMet[SM_CYICONSPACING] = gspv.im.iVertSpacing;  // 64;
    piSysMet[SM_CXCURSOR] = 32;
    piSysMet[SM_CYCURSOR] = 32;
    piSysMet[SM_CXMINTRACK] = piSysMet[SM_CXMIN];       // 117
    piSysMet[SM_CYMINTRACK] = piSysMet[SM_CYMIN];       // 27
    piSysMet[SM_CXDRAG] = 4;
    piSysMet[SM_CYDRAG] = 4;
    piSysMet[SM_ARRANGE] = gspv.mm.iArrange;            // 8;
 
    /* Menu */
    piSysMet[SM_CYMENU] = gspv.ncm.iMenuHeight + 1;     // 19;
    piSysMet[SM_MENUDROPALIGNMENT] = gspv.bMenuDropAlign;
    piSysMet[SM_CXMENUCHECK] = ((1 + gspv.tmMenuFont.tmHeight +
                                 gspv.tmMenuFont.tmExternalLeading) & ~1) - 1; // 13;
    piSysMet[SM_CYMENUCHECK] = piSysMet[SM_CXMENUCHECK];
    piSysMet[SM_CXMENUSIZE] = gspv.ncm.iMenuWidth;      // 18;
    piSysMet[SM_CYMENUSIZE] = gspv.ncm.iMenuHeight;     // 18;
 
    /* Mouse */
    piSysMet[SM_MOUSEPRESENT] = 1;
    piSysMet[SM_MOUSEWHEELPRESENT] = 1;
    piSysMet[SM_CMOUSEBUTTONS] = 2;
    piSysMet[SM_SWAPBUTTON] = gspv.bMouseBtnSwap ? 1 : 0;
    piSysMet[SM_CXDOUBLECLK] = gspv.iDblClickWidth;
    piSysMet[SM_CYDOUBLECLK] = gspv.iDblClickHeight;
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[SM_MOUSEHORIZONTALWHEELPRESENT] = 0;
#endif
 
    /* Version info */
    piSysMet[SM_TABLETPC] = 0;
    piSysMet[SM_MEDIACENTER] = 0;
    piSysMet[SM_STARTER] = 0;
    piSysMet[SM_SERVERR2] = 0;
    piSysMet[SM_PENWINDOWS] = 0;
 
    /* Other */
    piSysMet[SM_DEBUG] = 0;
    piSysMet[SM_NETWORK] = 3;
    piSysMet[SM_SLOWMACHINE] = 0;
    piSysMet[SM_SECURE] = 0;
    piSysMet[SM_DBCSENABLED] = NLS_MB_CODE_PAGE_TAG;
    piSysMet[SM_SHOWSOUNDS] = gspv.bShowSounds;
    piSysMet[SM_MIDEASTENABLED] = 0;
    piSysMet[SM_CMONITORS] = 1;
    piSysMet[SM_SAMEDISPLAYFORMAT] = 1;
    piSysMet[SM_IMMENABLED] = NLS_MB_CODE_PAGE_TAG;
 
    /* Reserved */
    piSysMet[SM_RESERVED1] = 0;
    piSysMet[SM_RESERVED2] = 0;
    piSysMet[SM_RESERVED3] = 0;
    piSysMet[SM_RESERVED4] = 0;
    piSysMet[64] = 0;
    piSysMet[65] = 0;
    piSysMet[66] = 0;
#if (_WIN32_WINNT >= 0x0600)
    piSysMet[90] = 0;
#endif
 
    if (UserIsDBCSEnabled())
        gpsi->dwSRVIFlags |= SRVINFO_DBCSENABLED; /* DBCS Support */
 
    if (UserIsIMMEnabled())
        gpsi->dwSRVIFlags |= SRVINFO_IMM32; /* IME Support */
 
    if (UserIsCTFIMEEnabled())
        gpsi->dwSRVIFlags |= SRVINFO_CTFIME_ENABLED; /* CTF IME support */
 
    Setup = TRUE;
 
    return TRUE;
}

Referenced by co_IntInitializeDesktopGraphics(), SpiUpdatePerUserSystemParameters(), UserChangeDisplaySettings(), UserRefreshDisplay(), and UserSystemParametersInfo().

InitSessionImpl()

NTSTATUS FASTCALL InitSessionImpl

(

VOID

)

Definition at line 18 of file session.c.

{
   return RtlCreateAtomTable(37, &gAtomTable);
}

Referenced by InitUserImpl().

InitThreadCallback()

NTSTATUS NTAPI InitThreadCallback

(

PETHREAD

Thread

)

Definition at line 456 of file main.c.

{
    PEPROCESS Process;
    PCLIENTINFO pci;
    PTHREADINFO ptiCurrent;
    int i;
    NTSTATUS Status = STATUS_SUCCESS;
    PTEB pTeb;
    PRTL_USER_PROCESS_PARAMETERS ProcessParams;
    PKL pDefKL;
    BOOLEAN bFirstThread;
 
    Process = Thread->ThreadsProcess;
 
    pTeb = NtCurrentTeb();
    ASSERT(pTeb);
 
    ProcessParams = pTeb->ProcessEnvironmentBlock->ProcessParameters;
 
    /* Allocate a new Win32 thread info */
    Status = AllocW32Thread(Thread, &ptiCurrent);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Failed to allocate pti for TID:0x%lx\n",
               HandleToUlong(Thread->Cid.UniqueThread));
        return Status;
    }
 
    /* Initialize the THREADINFO */
    ptiCurrent->pEThread = Thread;
    ptiCurrent->ppi = PsGetProcessWin32Process(Process);
    IntReferenceProcessInfo(ptiCurrent->ppi);
    pTeb->Win32ThreadInfo = ptiCurrent;
    ptiCurrent->pClientInfo = (PCLIENTINFO)pTeb->Win32ClientInfo;
    ptiCurrent->pcti = &ptiCurrent->cti;
    bFirstThread = !(ptiCurrent->ppi->W32PF_flags & W32PF_THREADCONNECTED);
 
    /* Mark the process as having threads */
    ptiCurrent->ppi->W32PF_flags |= W32PF_THREADCONNECTED;
 
    InitializeListHead(&ptiCurrent->WindowListHead);
    InitializeListHead(&ptiCurrent->W32CallbackListHead);
    InitializeListHead(&ptiCurrent->PostedMessagesListHead);
    InitializeListHead(&ptiCurrent->SentMessagesListHead);
    InitializeListHead(&ptiCurrent->PtiLink);
    for (i = 0; i < NB_HOOKS; i++)
    {
        InitializeListHead(&ptiCurrent->aphkStart[i]);
    }
    ptiCurrent->ptiSibling = ptiCurrent->ppi->ptiList;
    ptiCurrent->ppi->ptiList = ptiCurrent;
    ptiCurrent->ppi->cThreads++;
 
    ptiCurrent->hEventQueueClient = NULL;
    Status = ZwCreateEvent(&ptiCurrent->hEventQueueClient, EVENT_ALL_ACCESS,
                            NULL, SynchronizationEvent, FALSE);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Event creation failed, Status 0x%08x.\n", Status);
        goto error;
    }
    Status = ObReferenceObjectByHandle(ptiCurrent->hEventQueueClient, 0,
                                       *ExEventObjectType, UserMode,
                                       (PVOID*)&ptiCurrent->pEventQueueServer, NULL);
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserThread, "Failed referencing the event object, Status 0x%08x.\n", Status);
        ObCloseHandle(ptiCurrent->hEventQueueClient, UserMode);
        ptiCurrent->hEventQueueClient = NULL;
        goto error;
    }
 
    ptiCurrent->pcti->timeLastRead = EngGetTickCount32();
 
    ptiCurrent->MessageQueue = MsqCreateMessageQueue(ptiCurrent);
    if (ptiCurrent->MessageQueue == NULL)
    {
        ERR_CH(UserThread, "Failed to allocate message loop\n");
        Status = STATUS_NO_MEMORY;
        goto error;
    }
 
    pDefKL = W32kGetDefaultKeyLayout();
    UserAssignmentLock((PVOID*)&(ptiCurrent->KeyboardLayout), pDefKL);
 
    ptiCurrent->TIF_flags &= ~TIF_INCLEANUP;
 
    // FIXME: Flag SYSTEM threads with... TIF_SYSTEMTHREAD !!
 
    /* CSRSS threads have some special features */
    if (Process == gpepCSRSS || !gpepCSRSS)
        ptiCurrent->TIF_flags = TIF_CSRSSTHREAD | TIF_DONTATTACHQUEUE;
 
    /* Initialize the CLIENTINFO */
    pci = (PCLIENTINFO)pTeb->Win32ClientInfo;
    RtlZeroMemory(pci, sizeof(*pci));
    pci->ppi = ptiCurrent->ppi;
    pci->fsHooks = ptiCurrent->fsHooks;
    pci->dwTIFlags = ptiCurrent->TIF_flags;
    if (pDefKL)
    {
        pci->hKL = pDefKL->hkl;
        pci->CodePage = pDefKL->CodePage;
    }
 
    /* Populate dwExpWinVer */
    if (Process->Peb)
        ptiCurrent->dwExpWinVer = RtlGetExpWinVer(Process->SectionBaseAddress);
    else
        ptiCurrent->dwExpWinVer = WINVER_WINNT4;
    pci->dwExpWinVer = ptiCurrent->dwExpWinVer;
 
    /* Need to pass the user Startup Information to the current process. */
    if ( ProcessParams )
    {
       if ( ptiCurrent->ppi->usi.cb == 0 )      // Not initialized yet.
       {
          if ( ProcessParams->WindowFlags != 0 ) // Need window flags set.
          {
             ptiCurrent->ppi->usi.cb          = sizeof(USERSTARTUPINFO);
             ptiCurrent->ppi->usi.dwX         = ProcessParams->StartingX;
             ptiCurrent->ppi->usi.dwY         = ProcessParams->StartingY;
             ptiCurrent->ppi->usi.dwXSize     = ProcessParams->CountX;
             ptiCurrent->ppi->usi.dwYSize     = ProcessParams->CountY;
             ptiCurrent->ppi->usi.dwFlags     = ProcessParams->WindowFlags;
             ptiCurrent->ppi->usi.wShowWindow = (WORD)ProcessParams->ShowWindowFlags;
          }
       }
 
        if (bFirstThread)
        {
            /* Note: Only initialize once so it can be set back to 0 after being used */
            if (ProcessParams->WindowFlags & STARTF_USEHOTKEY)
                ptiCurrent->ppi->dwHotkey = HandleToUlong(ProcessParams->StandardInput);
            /* TODO:
            else if (ProcessParams->ShellInfo.Buffer)
                ..->dwHotkey = ParseShellInfo(ProcessParams->ShellInfo.Buffer, L"hotkey.");
            */
 
            if (ProcessParams->WindowFlags & STARTF_SHELLPRIVATE)
            {
              /* We need to validate this handle because it can also be a HICON */
                HMONITOR hMonitor = (HMONITOR)ProcessParams->StandardOutput;
                if (hMonitor && UserGetMonitorObject(hMonitor))
                    ptiCurrent->ppi->hMonitor = hMonitor;
            }
        }
    }
 
    /*
     * Assign a default window station and desktop to the process.
     * Do not try to open a desktop or window station before the very first
     * (interactive) window station has been created by Winlogon.
     */
    if (!(ptiCurrent->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)) &&
        ptiCurrent->ppi->hdeskStartup == NULL &&
        InputWindowStation != NULL)
    {
        HWINSTA hWinSta = NULL;
        HDESK hDesk = NULL;
        UNICODE_STRING DesktopPath;
        PDESKTOP pdesk;
 
        /*
         * Inherit the thread desktop and process window station (if not yet inherited)
         * from the process startup info structure. See documentation of CreateProcess().
         */
        Status = STATUS_UNSUCCESSFUL;
        if (ProcessParams && ProcessParams->DesktopInfo.Length > 0)
        {
            Status = IntSafeCopyUnicodeStringTerminateNULL(&DesktopPath, &ProcessParams->DesktopInfo);
        }
        if (!NT_SUCCESS(Status))
        {
            RtlInitUnicodeString(&DesktopPath, NULL);
        }
 
        Status = IntResolveDesktop(Process,
                                   &DesktopPath,
                                   !!(ProcessParams->WindowFlags & STARTF_INHERITDESKTOP),
                                   &hWinSta,
                                   &hDesk);
 
        if (DesktopPath.Buffer)
            ExFreePoolWithTag(DesktopPath.Buffer, TAG_STRING);
 
        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "Failed to assign default desktop and winsta to process\n");
            goto error;
        }
 
        if (!UserSetProcessWindowStation(hWinSta))
        {
            Status = STATUS_UNSUCCESSFUL;
            ERR_CH(UserThread, "Failed to set initial process winsta\n");
            goto error;
        }
 
        /* Validate the new desktop */
        Status = IntValidateDesktopHandle(hDesk, UserMode, 0, &pdesk);
        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "Failed to validate initial desktop handle\n");
            goto error;
        }
 
        /* Store the parsed desktop as the initial desktop */
        ASSERT(ptiCurrent->ppi->hdeskStartup == NULL);
        ASSERT(Process->UniqueProcessId != gpidLogon);
        ptiCurrent->ppi->hdeskStartup = hDesk;
        ptiCurrent->ppi->rpdeskStartup = pdesk;
    }
 
    if (ptiCurrent->ppi->hdeskStartup != NULL)
    {
        if (!IntSetThreadDesktop(ptiCurrent->ppi->hdeskStartup, FALSE))
        {
            ERR_CH(UserThread, "Failed to set thread desktop\n");
            Status = STATUS_UNSUCCESSFUL;
            goto error;
        }
    }
 
    /* Mark the thread as fully initialized */
    ptiCurrent->TIF_flags |= TIF_GUITHREADINITIALIZED;
 
    if (!(ptiCurrent->ppi->W32PF_flags & (W32PF_ALLOWFOREGROUNDACTIVATE | W32PF_APPSTARTING)) &&
         (gptiForeground && gptiForeground->ppi == ptiCurrent->ppi ))
    {
        ptiCurrent->TIF_flags |= TIF_ALLOWFOREGROUNDACTIVATE;
    }
    ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;
 
    /* Create the default input context */
    if (IS_IMM_MODE())
    {
        (VOID)UserCreateInputContext(0);
    }
 
    /* Last things to do only if we are not a SYSTEM or CSRSS thread */
    if (!(ptiCurrent->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)))
    {
        /* Callback to User32 Client Thread Setup */
        TRACE_CH(UserThread, "Call co_IntClientThreadSetup...\n");
        Status = co_IntClientThreadSetup();
        if (!NT_SUCCESS(Status))
        {
            ERR_CH(UserThread, "ClientThreadSetup failed with Status 0x%08lx\n", Status);
            goto error;
        }
        TRACE_CH(UserThread, "co_IntClientThreadSetup succeeded!\n");
    }
    else
    {
        TRACE_CH(UserThread, "co_IntClientThreadSetup cannot be called...\n");
    }
 
    TRACE_CH(UserThread, "UserCreateW32Thread pti 0x%p\n", ptiCurrent);
    return STATUS_SUCCESS;
 
error:
    ERR_CH(UserThread, "InitThreadCallback failed! Freeing pti 0x%p for TID:0x%lx\n",
           ptiCurrent, HandleToUlong(Thread->Cid.UniqueThread));
    ExitThreadCallback(Thread);
    return Status;
}

Referenced by Win32kThreadCallback().

IntClearWindowState()

VOID FASTCALL IntClearWindowState	(	PWND	pWnd,
		UINT	Flag
	)

Definition at line 618 of file misc.c.

{
   UINT bit;
   if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
   bit = 1 << LOWORD(Flag);
   TRACE("CWS %x\n",bit);
   switch(HIWORD(Flag))
   {
      case 0:
          pWnd->state &= ~bit;
          break;
      case 1:
          pWnd->state2 &= ~bit;
          break;
      case 2:
          pWnd->ExStyle2 &= ~bit;
          break;
   }
}

Referenced by NtUserCallHwndParam().

IntDdeGetMessageHook()

BOOL APIENTRY IntDdeGetMessageHook	(	PMSG	pMsg,
		LONG_PTR	ExtraInfo
	)

Definition at line 326 of file dde.c.

{
   PWND pWnd, pWndClient;
   PDDE_DATA pddeData;
   PDDE_PROP pddeProp;
   BOOL Ret;
 
   pWnd = UserGetWindowObject(pMsg->hwnd);
   if (pWnd == NULL)
   {
      ERR("DDE Get Window is dead. %p\n", pMsg->hwnd);
      return TRUE;
   }
 
   if (pMsg->message == WM_DDE_TERMINATE)
   {
      pddeProp = (PDDE_PROP)UserGetProp(pWnd, AtomDDETrack, TRUE);
      if (pddeProp)
      {
         pWndClient = UserGetWindowObject((HWND)pMsg->wParam);
         if (pWndClient == NULL)
         {
            ERR("DDE Get Client WM_DDE_TERMINATE\n");
         }
 
         UserRemoveProp(pWnd, AtomDDETrack, TRUE);
         ExFreePoolWithTag(pddeProp, USERTAG_DDE1);
      }
      return TRUE;
   }
 
   TRACE("DDE Get Msg 0x%x\n",pMsg->message);
 
   pddeData = (PDDE_DATA)ExtraInfo;
 
   if ( pddeData )
   {
      TRACE("DDE Get size %d lParam c=%08lx lp c=%08lx\n",pddeData->cbSize, pMsg->lParam, pddeData->lParam);
 
      // Callback.
      Ret = IntDDEGetCallback( pWnd, pMsg, pddeData->pvBuffer, pddeData->cbSize);
      if (!Ret)
      {
         ERR("DDE Get CB failed\n");
      }
 
      if (pddeData->pvBuffer) ExFreePoolWithTag(pddeData->pvBuffer, USERTAG_DDE);
 
      ExFreePoolWithTag(pddeData, USERTAG_DDE5);
 
      return Ret;
   }
   TRACE("DDE Get No DDE Data found!\n");
   return TRUE;
}

Referenced by co_IntGetPeekMessage().

IntDdePostMessageHook()

BOOL APIENTRY IntDdePostMessageHook	(	IN	PWND,
		IN	UINT,
		IN	WPARAM,
		IN OUT LPARAM *	lParam,
		IN OUT LONG_PTR *	ExtraInfo
	)

Definition at line 172 of file dde.c.

{
   PWND pWndClient;
   PDDE_DATA pddeData;
   int size;
   HGDIOBJ Object = NULL;
   PVOID userBuf = NULL;
   PVOID Buffer = NULL;
   LPARAM lp = *lParam;
 
   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Posting long DDE 0x%x\n",Msg);
      // Initiate is sent only across borders.
      if (Msg == WM_DDE_INITIATE)
      {
         return FALSE;
      }
 
      pWndClient = UserGetWindowObject((HWND)wParam);
      if (pWndClient == NULL)
      {
         // This is terminating so post it.
         if ( Msg == WM_DDE_TERMINATE)
         {
            TRACE("DDE Posted WM_DDE_TERMINATE\n");
            return TRUE;
         }
         TRACE("Invalid DDE Client Window handle\n");
         return FALSE;
      }
 
      if ( Msg == WM_DDE_REQUEST || Msg == WM_DDE_UNADVISE )
      {
         // Do not bother to callback after validation.
         return TRUE;
      }
 
      if ( Msg == WM_DDE_TERMINATE )
      {
 
         // Do not bother to callback.
         return TRUE;
      }
 
      if ( Msg == WM_DDE_EXECUTE && *lParam == 0)
      {
         // Do not bother to do a callback.
         TRACE("DDE Post EXECUTE lParam 0\n");
         return FALSE;
      }
 
      // Callback.
      if ((size = IntDDEPostCallback(pWnd, Msg, wParam, &lp, &userBuf)) == 0)
      {
         ERR("DDE Post Callback return 0 0x%x\n", Msg);
         return FALSE;
      }
 
      // No error HACK.
      if (size == -1)
      {
         size = 0;
      }
      else
      {
         // Set buffer with users data size.
         Buffer = ExAllocatePoolWithTag(PagedPool, size, USERTAG_DDE);
         if (Buffer == NULL)
         {
             ERR("Failed to allocate %i bytes.\n", size);
             return FALSE;
         }
         // No SEH? Yes, the user memory is freed after the Acknowledgment or at Termination.
         RtlCopyMemory(Buffer, userBuf, size);
      }
 
      TRACE("DDE Post size %d 0x%x\n",size, Msg);
 
      switch(Msg)
      {
          case WM_DDE_POKE:
          {
              DDEPOKE *pddePoke = Buffer;
              NT_ASSERT(pddePoke != NULL);
              switch(pddePoke->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddePoke->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          case WM_DDE_DATA:
          {
              DDEDATA *pddeData2 = Buffer;
              NT_ASSERT(pddeData2 != NULL);
              switch(pddeData2->cfFormat)
              {
                 case CF_BITMAP:
                 case CF_DIB:
                 case CF_PALETTE:
                    RtlCopyMemory(&Object, pddeData2->Value, sizeof(HGDIOBJ));
                    break;
                 default:
                    break;
              }
              break;
          }
          default:
              break;
      }
 
      if (Object)
      {
         // Give gdi object to the other process.
         GreSetObjectOwner(Object, pWnd->head.pti->ppi->W32Pid);
      }
 
      pddeData = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_DATA), USERTAG_DDE5);
      if (pddeData == NULL)
      {
         ERR("Failed to allocate DDE_DATA\n");
         ExFreePoolWithTag(Buffer, USERTAG_DDE);
         return FALSE;
      }
 
      pddeData->cbSize       = size;
      pddeData->pvBuffer     = Buffer;
      pddeData->lParam       = lp;
 
      TRACE("DDE Post lParam c=%08lx\n",lp);
      *lParam = lp;
 
      // Attach this data packet to the user message.
      *ExtraInfo = (LONG_PTR)pddeData;
   }
   return TRUE;
}

Referenced by UserPostMessage().

IntDdeSendMessageHook()

BOOL FASTCALL IntDdeSendMessageHook	(	PWND	pWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 386 of file dde.c.

{
   PWND pWndServer;
   PDDE_PROP pddeProp;
 
   if (pWnd->head.pti->ppi != gptiCurrent->ppi)
   {
      TRACE("Sending long DDE 0x%x\n",Msg);
 
      // Allow only Acknowledge and Initiate to be sent across borders.
      if (Msg != WM_DDE_ACK )
      {
         if (Msg == WM_DDE_INITIATE) return TRUE;
         return FALSE;
      }
 
      TRACE("Sending long WM_DDE_ACK\n");
 
      pWndServer = UserGetWindowObject((HWND)wParam);
      if (pWndServer == NULL)
      {
         ERR("Invalid DDE Server Window handle\n");
         return FALSE;
      }
 
      // Setup property so this conversation can be tracked.
      pddeProp = ExAllocatePoolWithTag(PagedPool, sizeof(DDE_PROP), USERTAG_DDE1);
      if (pddeProp == NULL)
      {
         ERR("failed to allocate DDE_PROP\n");
         return FALSE;
      }
 
      pddeProp->spwnd        = pWndServer;
      pddeProp->spwndPartner = pWnd;
 
      UserSetProp(pWndServer, AtomDDETrack, (HANDLE)pddeProp, TRUE);
   }
   return TRUE;
}

Referenced by co_IntSendMessageTimeoutSingle().

IntGetWindowContextHelpId()

DWORD FASTCALL IntGetWindowContextHelpId

(

PWND

pWnd

)

Definition at line 440 of file window.c.

{
   DWORD HelpId;
 
   do
   {
      HelpId = HandleToUlong(UserGetProp(pWnd, gpsi->atomContextHelpIdProp, TRUE));
      if (!HelpId) break;
      pWnd = IntGetParent(pWnd);
   }
   while (pWnd && pWnd->fnid != FNID_DESKTOP);
   return HelpId;
}

Referenced by IntDefWindowProc().

IntGetWindowObject()

PWND FASTCALL IntGetWindowObject

(

HWND

hWnd

)

Definition at line 75 of file window.c.

{
   PWND Window;
 
   if (!hWnd) return NULL;
 
   Window = UserGetWindowObject(hWnd);
   if (Window)
      Window->head.cLockObj++;
 
   return Window;
}

Referenced by co_UserFreeWindow(), IntHideDesktop(), and IntSetOwner().

IntSetWindowState()

VOID FASTCALL IntSetWindowState	(	PWND	pWnd,
		UINT	Flag
	)

Definition at line 597 of file misc.c.

{
   UINT bit;
   if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
   bit = 1 << LOWORD(Flag);
   TRACE("SWS %x\n",bit);
   switch(HIWORD(Flag))
   {
      case 0:
          pWnd->state |= bit;
          break;
      case 1:
          pWnd->state2 |= bit;
          break;
      case 2:
          pWnd->ExStyle2 |= bit;
          break;
   }
}

Referenced by NtUserCallHwndParam().

IntTID2PTI()

PTHREADINFO FASTCALL IntTID2PTI

(

HANDLE

id

)

Definition at line 42 of file misc.c.

{
   NTSTATUS Status;
   PETHREAD Thread;
   PTHREADINFO pti;
   Status = PsLookupThreadByThreadId(id, &Thread);
   if (!NT_SUCCESS(Status))
   {
      return NULL;
   }
   if (PsIsThreadTerminating(Thread))
   {
      ObDereferenceObject(Thread);
      return NULL;
   }
   pti = PsGetThreadWin32Thread(Thread);
   if (!pti)
   {
      ObDereferenceObject(Thread);
      return NULL;
   }
   // Validate and verify!
   _SEH2_TRY
   {
      if (pti->TIF_flags & TIF_INCLEANUP) pti = NULL;
      if (pti && !(pti->TIF_flags & TIF_GUITHREADINITIALIZED)) pti = NULL;
      if (PsGetThreadId(Thread) != id) pti = NULL;
   }
   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
   {
      pti = NULL;
   }
   _SEH2_END
   ObDereferenceObject(Thread);
   return pti;
}

Referenced by NtUserAttachThreadInput(), NtUserBuildHimcList(), NtUserDisableThreadIme(), NtUserGetGUIThreadInfo(), NtUserGetThreadDesktop(), NtUserGetThreadState(), and NtUserSetWindowsHookEx().

NC_DoNCPaint()

LRESULT NC_DoNCPaint	(	PWND	pWnd,
		HDC	hDC,
		INT	Flags
	)

Definition at line 1097 of file nonclient.c.

{
   DWORD Style, ExStyle;
   PWND Parent;
   RECT WindowRect, CurrentRect, TempRect;
   BOOL Active = FALSE;
 
   if (!IntIsWindowVisible(pWnd) ||
       (pWnd->state & WNDS_NONCPAINT && !(pWnd->state & WNDS_FORCEMENUDRAW)) ||
        IntEqualRect(&pWnd->rcWindow, &pWnd->rcClient) )
      return 0;
 
   Style = pWnd->style;
 
   TRACE("DefWndNCPaint: pWnd %p, hDc %p, Active %s.\n", pWnd, hDC, Flags & DC_ACTIVE ? "TRUE" : "FALSE");
 
   Parent = IntGetParent(pWnd);
   ExStyle = pWnd->ExStyle;
 
   if (Flags == -1) // NC paint mode.
   {
      if (ExStyle & WS_EX_MDICHILD)
      {
         Active = IntIsChildWindow(gpqForeground->spwndActive, pWnd);
 
         if (Active)
            Active = (UserHMGetHandle(pWnd) == (HWND)co_IntSendMessage(UserHMGetHandle(Parent), WM_MDIGETACTIVE, 0, 0));
      }
      else
      {
         Active = (gpqForeground == pWnd->head.pti->MessageQueue);
      }
      Flags = DC_NC; // Redraw everything!
   }
   else
      Flags |= DC_NC;
 
 
   IntGetWindowRect(pWnd, &WindowRect);
 
   CurrentRect.top = CurrentRect.left = 0;
   CurrentRect.right = WindowRect.right - WindowRect.left;
   CurrentRect.bottom = WindowRect.bottom - WindowRect.top;
 
   /* Draw outer edge */
   if (UserHasWindowEdge(pWnd->style, pWnd->ExStyle))
   {
      DrawEdge(hDC, &CurrentRect, EDGE_RAISED, BF_RECT | BF_ADJUST);
   }
   else if (pWnd->ExStyle & WS_EX_STATICEDGE)
   {
#if 0
      DrawEdge(hDC, &CurrentRect, BDR_SUNKENINNER, BF_RECT | BF_ADJUST | BF_FLAT);
#else
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNSHADOW));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNHIGHLIGHT));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 
      RECTL_vInflateRect(&CurrentRect, -1, -1);
#endif
   }
 
   if (Flags & DC_FRAME) NC_DrawFrame(hDC, &CurrentRect, Active ? Active : (Flags & DC_ACTIVE), Style, ExStyle);
 
   /* Draw caption */
   if ((Style & WS_CAPTION) == WS_CAPTION)
   {
      HPEN PreviousPen;
      BOOL Gradient = FALSE;
 
      if (Flags & DC_REDRAWHUNGWND)
      {
         Flags &= ~DC_REDRAWHUNGWND;
         Flags |= DC_NOSENDMSG;
      }
 
      if (UserSystemParametersInfo(SPI_GETGRADIENTCAPTIONS, 0, &Gradient, 0) && Gradient)
      {
         Flags |= DC_GRADIENT;
      }
 
      if (Active)
      {
         if (pWnd->state & WNDS_ACTIVEFRAME)
            Flags |= DC_ACTIVE;
         else
         {
            ERR("Wnd is active and not set active!\n");
         }
      }
 
      TempRect = CurrentRect;
 
      if (ExStyle & WS_EX_TOOLWINDOW)
      {
         Flags |= DC_SMALLCAP;
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYSMCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYSMCAPTION);
      }
      else
      {
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYCAPTION);
      }
 
      UserDrawCaption(pWnd, hDC, &TempRect, NULL, NULL, NULL, Flags);
 
      /* Draw buttons */
      if (Style & WS_SYSMENU)
      {
         UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONCLOSE);
         if ((Style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(ExStyle & WS_EX_TOOLWINDOW))
         {
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMIN);
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMAX);
         }
      }
      if (!(Style & WS_MINIMIZE))
      {
        /* Line under caption */
         PreviousPen = NtGdiSelectPen(hDC, NtGdiGetStockObject(DC_PEN));
 
         IntSetDCPenColor( hDC, IntGetSysColor(
                         ((ExStyle & (WS_EX_STATICEDGE | WS_EX_CLIENTEDGE | WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
                          COLOR_WINDOWFRAME : COLOR_3DFACE));
 
         GreMoveTo(hDC, TempRect.left, TempRect.bottom, NULL);
 
         NtGdiLineTo(hDC, TempRect.right, TempRect.bottom);
 
         NtGdiSelectPen(hDC, PreviousPen);
      }
   }
 
   if (!(Style & WS_MINIMIZE))
   {
     /* Draw menu bar */
     if (pWnd->state & WNDS_HASMENU && pWnd->IDMenu) // Should be pWnd->spmenu
     {
         if (!(Flags & DC_NOSENDMSG))
         {
             PMENU menu;
             // Fix crash in test_menu_locked_by_window, should use pWnd->spmenu....
             if ((menu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu)))) // FIXME! Use pWnd->spmenu,
             {
                TempRect = CurrentRect;
                TempRect.bottom = TempRect.top + menu->cyMenu; // Should be pWnd->spmenu->cyMenu;
                CurrentRect.top += MENU_DrawMenuBar(hDC, &TempRect, pWnd, FALSE);
             }
         }
     }
 
     if (ExStyle & WS_EX_CLIENTEDGE)
     {
         DrawEdge(hDC, &CurrentRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
     }
 
     /* Draw the scrollbars */
     if ((Style & WS_VSCROLL) && (Style & WS_HSCROLL) &&
         IntIsScrollBarVisible(pWnd, OBJID_VSCROLL) && IntIsScrollBarVisible(pWnd, OBJID_HSCROLL))
     {
        RECT ParentClientRect;
 
        TempRect = CurrentRect;
 
        if (ExStyle & WS_EX_LEFTSCROLLBAR)
           TempRect.right = TempRect.left + UserGetSystemMetrics(SM_CXVSCROLL);
        else
           TempRect.left = TempRect.right - UserGetSystemMetrics(SM_CXVSCROLL);
 
        TempRect.top = TempRect.bottom - UserGetSystemMetrics(SM_CYHSCROLL);
 
        FillRect(hDC, &TempRect, IntGetSysColorBrush(COLOR_BTNFACE));
 
        if (Parent)
        {
           IntGetClientRect(Parent, &ParentClientRect);
 
           if (HASSIZEGRIP(Style, ExStyle, Parent->style, WindowRect, ParentClientRect))
           {
              DrawFrameControl(hDC, &TempRect, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
           }
        }
 
        IntDrawScrollBar(pWnd, hDC, SB_VERT);
        IntDrawScrollBar(pWnd, hDC, SB_HORZ);
     }
     else
     {
        if (Style & WS_VSCROLL && IntIsScrollBarVisible(pWnd, OBJID_VSCROLL))
        {
           IntDrawScrollBar(pWnd, hDC, SB_VERT);
        }
        else if (Style & WS_HSCROLL && IntIsScrollBarVisible(pWnd, OBJID_HSCROLL))
        {
           IntDrawScrollBar(pWnd, hDC, SB_HORZ);
        }
     }
   }
   return 0; // For WM_NCPAINT message, return 0.
}

Referenced by IntDefWindowProc(), NC_HandleNCActivate(), NtUserDrawCaptionTemp(), and PaintSuspendedWindow().

NC_DrawFrame()

VOID NC_DrawFrame	(	HDC	hDC,
		RECT *	CurrentRect,
		BOOL	Active,
		DWORD	Style,
		DWORD	ExStyle
	)

Definition at line 909 of file nonclient.c.

{
   /* Firstly the "thick" frame */
   if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE))
   {
      LONG Width =
         (UserGetSystemMetrics(SM_CXFRAME) - UserGetSystemMetrics(SM_CXDLGFRAME)) *
         UserGetSystemMetrics(SM_CXBORDER);
 
      LONG Height =
         (UserGetSystemMetrics(SM_CYFRAME) - UserGetSystemMetrics(SM_CYDLGFRAME)) *
         UserGetSystemMetrics(SM_CYBORDER);
 
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(Active ? COLOR_ACTIVEBORDER : COLOR_INACTIVEBORDER));
 
      /* Draw frame */
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, CurrentRect->right - CurrentRect->left, Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->bottom, CurrentRect->right - CurrentRect->left, -Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->right, CurrentRect->top, -Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
 
      RECTL_vInflateRect(CurrentRect, -Width, -Height);
   }
 
   /* Now the other bit of the frame */
   if (Style & (WS_DLGFRAME | WS_BORDER) || ExStyle & WS_EX_DLGMODALFRAME)
   {
      LONG Width = UserGetSystemMetrics(SM_CXBORDER);
      LONG Height = UserGetSystemMetrics(SM_CYBORDER);
 
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(
         (ExStyle & (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE)) ? COLOR_3DFACE :
         (ExStyle & WS_EX_STATICEDGE) ? COLOR_WINDOWFRAME :
         (Style & (WS_DLGFRAME | WS_THICKFRAME)) ? COLOR_3DFACE :
         COLOR_WINDOWFRAME));
 
      /* Draw frame */
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, CurrentRect->right - CurrentRect->left, Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->top, Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->left, CurrentRect->bottom, CurrentRect->right - CurrentRect->left, -Height, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect->right, CurrentRect->top, -Width, CurrentRect->bottom - CurrentRect->top, PATCOPY);
 
      RECTL_vInflateRect(CurrentRect, -Width, -Height);
   }
}

Referenced by NC_DoNCPaint(), and UserDrawCaptionBar().

NC_GetInsideRect()

void FASTCALL NC_GetInsideRect	(	PWND	Wnd,
		RECT *	rect
	)

Definition at line 71 of file nonclient.c.

{
    ULONG Style;
    ULONG ExStyle;
 
    Style = Wnd->style;
    ExStyle = Wnd->ExStyle;
 
    rect->top    = rect->left = 0;
    rect->right  = Wnd->rcWindow.right - Wnd->rcWindow.left;
    rect->bottom = Wnd->rcWindow.bottom - Wnd->rcWindow.top;
 
    if (Style & WS_ICONIC) return;
 
    /* Remove frame from rectangle */
    if (UserHasThickFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME));
    }
    else if (UserHasDlgFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
        /* FIXME: this isn't in NC_AdjustRect? why not? */
        if (ExStyle & WS_EX_DLGMODALFRAME)
            RECTL_vInflateRect( rect, -1, 0 );
    }
    else if (UserHasThinFrameStyle(Style, ExStyle))
    {
        RECTL_vInflateRect(rect, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
    }
 
    /* We have additional border information if the window
     * is a child (but not an MDI child) */
    if ((Style & WS_CHILD) && !(ExStyle & WS_EX_MDICHILD))
    {
       if (ExStyle & WS_EX_CLIENTEDGE)
          RECTL_vInflateRect (rect, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
       if (ExStyle & WS_EX_STATICEDGE)
          RECTL_vInflateRect (rect, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
    }
}

Referenced by MENU_DrawMenuItem(), NC_GetSysPopupPos(), and NC_HandleNCLButtonDown().

NC_GetSysPopupPos()

void FASTCALL NC_GetSysPopupPos	(	PWND	Wnd,
		RECT *	Rect
	)

Definition at line 117 of file nonclient.c.

{
  RECT WindowRect;
 
  if ((Wnd->style & WS_MINIMIZE) != 0)
  {
      IntGetWindowRect(Wnd, Rect);
  }
  else
    {
      NC_GetInsideRect(Wnd, Rect);
      IntGetWindowRect(Wnd, &WindowRect);
      RECTL_vOffsetRect(Rect, WindowRect.left, WindowRect.top);
      if (Wnd->style & WS_CHILD)
      {
          IntClientToScreen(IntGetParent(Wnd), (POINT *) Rect);
      }
      Rect->right = Rect->left + UserGetSystemMetrics(SM_CYCAPTION) - 1;
      Rect->bottom = Rect->top + UserGetSystemMetrics(SM_CYCAPTION) - 1;
    }
}

Referenced by MENU_ShowSubPopup().

NC_HandleNCActivate()

LRESULT NC_HandleNCActivate	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1438 of file nonclient.c.

{
   INT Flags;
  /* Lotus Notes draws menu descriptions in the caption of its main
   * window. When it wants to restore original "system" view, it just
   * sends WM_NCACTIVATE message to itself. Any optimizations here in
   * attempt to minimize redrawings lead to a not restored caption.
   */
   if (wParam & DC_ACTIVE)
   {
      Wnd->state |= WNDS_ACTIVEFRAME|WNDS_HASCAPTION;
      wParam = DC_CAPTION|DC_ACTIVE;
   }
   else
   {
      Wnd->state &= ~WNDS_ACTIVEFRAME;
      wParam = DC_CAPTION;
   }
 
   if ((Wnd->state & WNDS_NONCPAINT) || !(Wnd->style & WS_VISIBLE))
      return TRUE;
 
   /* This isn't documented but is reproducible in at least XP SP2 and
    * Outlook 2007 depends on it
    */
   // MSDN:
   // If this parameter is set to -1, DefWindowProc does not repaint the
   // nonclient area to reflect the state change.
   if ( lParam != -1 &&
        ( Flags = NC_DoNCActive(Wnd)) != 0 )
   {
      HDC hDC;
      HRGN hRgnTemp = NULL, hRgn = (HRGN)lParam;
 
      if (GreIsHandleValid(hRgn))
      {
         hRgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
         if (NtGdiCombineRgn(hRgnTemp, hRgn, 0, RGN_COPY) == ERROR)
         {
            GreDeleteObject(hRgnTemp);
            hRgnTemp = NULL;
         }
      }
 
      if ((hDC = UserGetDCEx(Wnd, hRgnTemp, DCX_WINDOW|DCX_USESTYLE)))
      {
         NC_DoNCPaint(Wnd, hDC, wParam | Flags); // Redraw MENUs.
         UserReleaseDC(Wnd, hDC, FALSE);
      }
      else
         GreDeleteObject(hRgnTemp);
   }
 
   return TRUE;
}

Referenced by IntDefWindowProc().

NC_HandleNCCalcSize()

LRESULT NC_HandleNCCalcSize	(	PWND	wnd,
		WPARAM	wparam,
		RECTL *	winRect,
		BOOL	Suspended
	)

Definition at line 1304 of file nonclient.c.

{
   LRESULT Result = 0;
   SIZE WindowBorders;
   RECT OrigRect;
   LONG Style = Wnd->style;
   LONG exStyle = Wnd->ExStyle;
 
   if (Rect == NULL)
   {
      return Result;
   }
   OrigRect = *Rect;
 
   Wnd->state &= ~WNDS_HASCAPTION;
 
   if (wparam)
   {
      if (Wnd->pcls->style & CS_VREDRAW)
      {
         Result |= WVR_VREDRAW;
      }
      if (Wnd->pcls->style & CS_HREDRAW)
      {
         Result |= WVR_HREDRAW;
      }
      Result |= WVR_VALIDRECTS;
   }
 
   if (!(Wnd->style & WS_MINIMIZE))
   {
      if (UserHasWindowEdge(Wnd->style, Wnd->ExStyle))
      {
         UserGetWindowBorders(Wnd->style, Wnd->ExStyle, &WindowBorders, FALSE);
         RECTL_vInflateRect(Rect, -WindowBorders.cx, -WindowBorders.cy);
      }
      else if ((Wnd->ExStyle & WS_EX_STATICEDGE) || (Wnd->style & WS_BORDER))
      {
         RECTL_vInflateRect(Rect, -1, -1);
      }
 
      if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
      {
         Wnd->state |= WNDS_HASCAPTION;
 
         if (Wnd->ExStyle & WS_EX_TOOLWINDOW)
            Rect->top += UserGetSystemMetrics(SM_CYSMCAPTION);
         else
            Rect->top += UserGetSystemMetrics(SM_CYCAPTION);
      }
 
      if (HAS_MENU(Wnd, Style))
      {
         HDC hDC = UserGetDCEx(Wnd, 0, DCX_USESTYLE | DCX_WINDOW);
 
         Wnd->state |= WNDS_HASMENU;
 
         if (hDC)
         {
           RECT CliRect = *Rect;
           CliRect.bottom -= OrigRect.top;
           CliRect.right -= OrigRect.left;
           CliRect.left -= OrigRect.left;
           CliRect.top -= OrigRect.top;
           if (!Suspended) Rect->top += MENU_DrawMenuBar(hDC, &CliRect, Wnd, TRUE);
           UserReleaseDC(Wnd, hDC, FALSE);
         }
      }
 
      if (Wnd->ExStyle & WS_EX_CLIENTEDGE)
      {
         RECTL_vInflateRect(Rect, -2 * UserGetSystemMetrics(SM_CXBORDER), -2 * UserGetSystemMetrics(SM_CYBORDER));
      }
 
      if (Style & WS_VSCROLL)
      {
         if (Rect->right - Rect->left >= UserGetSystemMetrics(SM_CXVSCROLL))
         {
             Wnd->state |= WNDS_HASVERTICALSCROOLLBAR;
 
             /* rectangle is in screen coords when wparam is false */
             if (!wparam && (exStyle & WS_EX_LAYOUTRTL)) exStyle ^= WS_EX_LEFTSCROLLBAR;
 
             if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
                 Rect->left  += UserGetSystemMetrics(SM_CXVSCROLL);
             else
                 Rect->right -= UserGetSystemMetrics(SM_CXVSCROLL);
          }
      }
 
      if (Style & WS_HSCROLL)
      {
         if( Rect->bottom - Rect->top > UserGetSystemMetrics(SM_CYHSCROLL))
         {
              Wnd->state |= WNDS_HASHORIZONTALSCROLLBAR;
 
              Rect->bottom -= UserGetSystemMetrics(SM_CYHSCROLL);
         }
      }
 
      if (Rect->top > Rect->bottom)
         Rect->bottom = Rect->top;
 
      if (Rect->left > Rect->right)
         Rect->right = Rect->left;
   }
   else
   {
      Rect->right = Rect->left;
      Rect->bottom = Rect->top;
   }
 
   return Result;
}

Referenced by IntDefWindowProc().

NC_HandleNCLButtonDblClk()

LRESULT NC_HandleNCLButtonDblClk	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1667 of file nonclient.c.

{
  ULONG Style;
 
  Style = pWnd->style;
  switch(wParam)
  {
    case HTCAPTION:
    {
      /* Maximize/Restore the window */
      if((Style & WS_CAPTION) == WS_CAPTION && (Style & WS_MAXIMIZEBOX))
      {
        co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, ((Style & (WS_MINIMIZE | WS_MAXIMIZE)) ? SC_RESTORE : SC_MAXIMIZE), 0);
      }
      break;
    }
    case HTSYSMENU:
    {
      PMENU SysMenu = IntGetSystemMenu(pWnd, FALSE);
      UINT state = IntGetMenuState(SysMenu ? UserHMGetHandle(SysMenu) : NULL, SC_CLOSE, MF_BYCOMMAND);
 
      /* If the close item of the sysmenu is disabled or not present do nothing */
      if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
          break;
 
      co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_CLOSE, lParam);
      break;
    }
    case HTTOP:
    case HTBOTTOM:
    {
      RECT sizingRect = pWnd->rcWindow, mouseRect;
 
      if (pWnd->ExStyle & WS_EX_MDICHILD)
          break;
 
      UserSystemParametersInfo(SPI_GETWORKAREA, 0, &mouseRect, 0);
 
      co_WinPosSetWindowPos(pWnd,
                            NULL,
                            sizingRect.left,
                            mouseRect.top,
                            sizingRect.right - sizingRect.left,
                            mouseRect.bottom - mouseRect.top,
                            0);
      break;
    }
    default:
      return NC_HandleNCLButtonDown(pWnd, wParam, lParam);
  }
  return(0);
}

Referenced by IntDefWindowProc().

NC_HandleNCLButtonDown()

LRESULT NC_HandleNCLButtonDown	(	PWND	Wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1575 of file nonclient.c.

{
    switch (wParam)
    {
        case HTCAPTION:
        {
            PWND TopWnd = pWnd, parent;
            while(1)
            {
                if ((TopWnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
                    break;
                parent = UserGetAncestor( TopWnd, GA_PARENT );
                if (!parent || UserIsDesktopWindow(parent)) break;
                TopWnd = parent;
            }
 
            if ( (pWnd && (pWnd->ExStyle & WS_EX_NOACTIVATE)) ||
                 co_IntSetForegroundWindowMouse(TopWnd) ||
                 //NtUserCallHwndLock(hTopWnd, HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOWMOUSE) ||
                 UserGetActiveWindow() == UserHMGetHandle(TopWnd))
            {
               co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam);
            }
            break;
        }
        case HTSYSMENU:
        {
          LONG style = pWnd->style;
          if (style & WS_SYSMENU)
          {
              if(!(style & WS_MINIMIZE) )
              {
                RECT rect;
                HDC hDC = UserGetWindowDC(pWnd);
                NC_GetInsideRect(pWnd, &rect);
                UserDrawSysMenuButton(pWnd, hDC, &rect, TRUE);
                UserReleaseDC( pWnd, hDC, FALSE );
              }
          co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam);
      }
      break;
        }
        case HTMENU:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_MOUSEMENU + HTMENU, lParam);
            break;
        }
        case HTHSCROLL:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam);
            break;
        }
        case HTVSCROLL:
        {
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam);
            break;
        }
        case HTMINBUTTON:
        case HTMAXBUTTON:
        case HTCLOSE:
        {
          NC_DoButton(pWnd, wParam, lParam);
          break;
        }
        case HTLEFT:
        case HTRIGHT:
        case HTTOP:
        case HTBOTTOM:
        case HTTOPLEFT:
        case HTTOPRIGHT:
        case HTBOTTOMLEFT:
        case HTBOTTOMRIGHT:
        {
           /* Old comment:
            * "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
            * This was previously done by setting wParam=SC_SIZE + wParam - 2
            */
           /* But that is not what WinNT does. Instead it sends this. This
            * is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
            * SC_MOUSEMENU into wParam.
            */
            co_IntSendMessage(UserHMGetHandle(pWnd), WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT - WMSZ_LEFT), lParam);
            break;
        }
        case HTBORDER:
            break;
    }
    return(0);
}

Referenced by IntDefWindowProc(), and NC_HandleNCLButtonDblClk().

NC_HandleNCRButtonDown()

LRESULT NC_HandleNCRButtonDown	(	PWND	wnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1725 of file nonclient.c.

{
  MSG msg;
  INT hittest = wParam;
 
  switch (hittest)
  {
  case HTCAPTION:
  case HTSYSMENU:
      if (!IntGetSystemMenu( pwnd, FALSE )) break;
 
      co_UserSetCapture( UserHMGetHandle(pwnd) );
      for (;;)
      {
          if (!co_IntGetPeekMessage(&msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE, TRUE)) break;
          if (IntCallMsgFilter( &msg, MSGF_MAX )) continue;
          if (msg.message == WM_RBUTTONUP)
          {
             hittest = GetNCHitEx( pwnd, msg.pt );
             break;
          }
          if (UserHMGetHandle(pwnd) != IntGetCapture()) return 0;
      }
      IntReleaseCapture();
 
      if (hittest == HTCAPTION || hittest == HTSYSMENU || hittest == HTHSCROLL || hittest == HTVSCROLL)
      {
         TRACE("Msg pt %x and Msg.lParam %x and lParam %x\n",MAKELONG(msg.pt.x,msg.pt.y),msg.lParam,lParam);
         co_IntSendMessage( UserHMGetHandle(pwnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(pwnd), MAKELONG(msg.pt.x,msg.pt.y));
      }
      break;
  }
  return 0;
}

Referenced by IntDefWindowProc().

SetLayeredStatus()

BOOL FASTCALL SetLayeredStatus	(	PWND	pWnd,
		BYTE	set
	)

Definition at line 34 of file layered.c.

{
   PLRD_PROP pLrdProp = UserGetProp(pWnd, AtomLayer, TRUE);
   if (pLrdProp)
   {
      pLrdProp->is_Layered = set;
      return TRUE;
   }
   return FALSE;
}

Referenced by co_IntSetWindowLongPtr().

UserCreateInputContext()

PIMC FASTCALL UserCreateInputContext

(

_In_ ULONG_PTR

dwClientImcData

)

Definition at line 1635 of file ime.c.

{
    PIMC pIMC;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    PDESKTOP pdesk = pti->rpdesk;
 
    if (!IS_IMM_MODE() || (pti->TIF_flags & TIF_DISABLEIME)) // Disabled?
    {
        ERR("IME is disabled\n");
        return NULL;
    }
 
    if (!pdesk) // No desktop?
        return NULL;
 
    // pti->spDefaultImc should be already set if non-first time.
    if (dwClientImcData && !pti->spDefaultImc)
        return NULL;
 
    // Create an input context user object.
    pIMC = UserCreateObject(gHandleTable, pdesk, pti, NULL, TYPE_INPUTCONTEXT, sizeof(IMC));
    if (!pIMC)
        return NULL;
 
    // Release the extra reference (UserCreateObject added 2 references).
    UserDereferenceObject(pIMC);
    ASSERT(pIMC->head.cLockObj == 1);
 
    if (dwClientImcData) // Non-first time.
    {
        // Insert pIMC to the second position (non-default) of the list.
        pIMC->pImcNext = pti->spDefaultImc->pImcNext;
        pti->spDefaultImc->pImcNext = pIMC;
    }
    else // First time. It's the default IMC.
    {
        // Add the first one (default) to the list.
        UserAssignmentLock((PVOID*)&pti->spDefaultImc, pIMC);
        pIMC->pImcNext = NULL;
        ASSERT(pIMC->head.cLockObj == 2); // UserAssignmentUnlock'ed at ExitThreadCallback
    }
 
    pIMC->dwClientImcData = dwClientImcData; // Set it.
    return pIMC;
}

Referenced by co_IntCreateDefaultImeWindow(), InitThreadCallback(), and NtUserCreateInputContext().

UserCreateMenu()

HMENU FASTCALL UserCreateMenu	(	PDESKTOP	Desktop,
		BOOL	PopupMenu
	)

Definition at line 5058 of file menu.c.

{
   PWINSTATION_OBJECT WinStaObject;
   HANDLE Handle;
   PMENU Menu;
   NTSTATUS Status;
   PEPROCESS CurrentProcess = PsGetCurrentProcess();
 
   if (gpepCSRSS != CurrentProcess)
   {
      /*
       * gpepCSRSS does not have a Win32WindowStation
       */
 
      Status = IntValidateWindowStationHandle(CurrentProcess->Win32WindowStation,
                     UserMode,
                     0,
                     &WinStaObject,
                     0);
 
       if (!NT_SUCCESS(Status))
       {
          ERR("Validation of window station handle (%p) failed\n",
              CurrentProcess->Win32WindowStation);
          SetLastNtError(Status);
          return (HMENU)0;
       }
       Menu = IntCreateMenu(&Handle, !PopupMenu, Desktop, GetW32ProcessInfo());
       if (Menu && Menu->head.rpdesk->rpwinstaParent != WinStaObject)
       {
          ERR("Desktop Window Station does not match Process one!\n");
       }
       ObDereferenceObject(WinStaObject);
   }
   else
   {
       Menu = IntCreateMenu(&Handle, !PopupMenu, GetW32ThreadInfo()->rpdesk, GetW32ProcessInfo());
   }
 
   if (Menu) UserDereferenceObject(Menu);
   return (HMENU)Handle;
}

Referenced by MENU_GetSystemMenu(), and NtUserCallNoParam().

UserDestroyInputContext()

BOOLEAN UserDestroyInputContext

(

_In_opt_ PVOID

Object

)

Definition at line 1560 of file ime.c.

{
    PIMC pIMC = Object;
    if (!pIMC)
        return TRUE;
 
    UserMarkObjectDestroy(pIMC);
    UserDeleteObject(UserHMGetHandle(pIMC), TYPE_INPUTCONTEXT);
    return TRUE;
}

UserDestroyMenu()

BOOL FASTCALL UserDestroyMenu

(

HMENU

hMenu

)

Definition at line 5822 of file menu.c.

{
   PMENU Menu;
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
   if(!(Menu = UserGetMenuObject(hMenu)))
   {
      return FALSE;
   }
 
   if (Menu->head.rpdesk != pti->rpdesk)
   {
      EngSetLastError(ERROR_ACCESS_DENIED);
      return FALSE;
   }
   return IntDestroyMenuObject(Menu, FALSE);
}

Referenced by MENU_GetSystemMenu().

UserDrawCaptionBar()

VOID UserDrawCaptionBar	(	PWND	pWnd,
		HDC	hDC,
		INT	Flags
	)

Definition at line 955 of file nonclient.c.

{
   DWORD Style, ExStyle;
   RECT WindowRect, CurrentRect, TempRect;
   HPEN PreviousPen;
   BOOL Gradient = FALSE;
   PCURICON_OBJECT pIcon = NULL;
 
   if (!(Flags & DC_NOVISIBLE) && !IntIsWindowVisible(pWnd)) return;
 
   TRACE("UserDrawCaptionBar: pWnd %p, hDc %p, Flags 0x%x.\n", pWnd, hDC, Flags);
 
   Style = pWnd->style;
   ExStyle = pWnd->ExStyle;
 
   IntGetWindowRect(pWnd, &WindowRect);
 
   CurrentRect.top = CurrentRect.left = 0;
   CurrentRect.right = WindowRect.right - WindowRect.left;
   CurrentRect.bottom = WindowRect.bottom - WindowRect.top;
 
   /* Draw outer edge */
   if (UserHasWindowEdge(Style, ExStyle))
   {
      DrawEdge(hDC, &CurrentRect, EDGE_RAISED, BF_RECT | BF_ADJUST);
   }
   else if (ExStyle & WS_EX_STATICEDGE)
   {
#if 0
      DrawEdge(hDC, &CurrentRect, BDR_SUNKENINNER, BF_RECT | BF_ADJUST | BF_FLAT);
#else
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNSHADOW));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 
      NtGdiSelectBrush(hDC, IntGetSysColorBrush(COLOR_BTNHIGHLIGHT));
      NtGdiPatBlt(hDC, CurrentRect.left, CurrentRect.bottom - 1, CurrentRect.right - CurrentRect.left, 1, PATCOPY);
      NtGdiPatBlt(hDC, CurrentRect.right - 1, CurrentRect.top, 1, CurrentRect.bottom - CurrentRect.top, PATCOPY);
 
      RECTL_vInflateRect(&CurrentRect, -1, -1);
#endif
   }
 
   if (Flags & DC_FRAME) NC_DrawFrame(hDC, &CurrentRect, (Flags & DC_ACTIVE), Style, ExStyle);
 
   /* Draw caption */
   if ((Style & WS_CAPTION) == WS_CAPTION)
   {
      TempRect = CurrentRect;
 
      Flags |= DC_TEXT|DC_BUTTONS; // Icon will be checked if not already set.
 
      if (UserSystemParametersInfo(SPI_GETGRADIENTCAPTIONS, 0, &Gradient, 0) && Gradient)
      {
         Flags |= DC_GRADIENT;
      }
 
      if (ExStyle & WS_EX_TOOLWINDOW)
      {
         Flags |= DC_SMALLCAP;
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYSMCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYSMCAPTION);
      }
      else
      {
         TempRect.bottom = TempRect.top + UserGetSystemMetrics(SM_CYCAPTION) - 1;
         CurrentRect.top += UserGetSystemMetrics(SM_CYCAPTION);
      }
 
      if (!(Flags & DC_ICON)               &&
          !(Flags & DC_SMALLCAP)           &&
           (Style & WS_SYSMENU)            &&
          !(ExStyle & WS_EX_TOOLWINDOW) )
      {
         pIcon = NC_IconForWindow(pWnd); // Force redraw of caption with icon if DC_ICON not flaged....
      }
      UserDrawCaption(pWnd, hDC, &TempRect, NULL, pIcon ? UserHMGetHandle(pIcon) : NULL, NULL, Flags);
 
      /* Draw buttons */
      if (Style & WS_SYSMENU)
      {
         UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONCLOSE);
         if ((Style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(ExStyle & WS_EX_TOOLWINDOW))
         {
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMIN);
            UserDrawCaptionButton(pWnd, &TempRect, Style, ExStyle, hDC, FALSE, DFCS_CAPTIONMAX);
         }
      }
 
      if (!(Style & WS_MINIMIZE))
      {
         /* Line under caption */
         PreviousPen = NtGdiSelectPen(hDC, NtGdiGetStockObject(DC_PEN));
 
         IntSetDCPenColor( hDC, IntGetSysColor(((ExStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
                                             COLOR_WINDOWFRAME : COLOR_3DFACE));
 
         GreMoveTo(hDC, TempRect.left, TempRect.bottom, NULL);
 
         NtGdiLineTo(hDC, TempRect.right, TempRect.bottom);
 
         NtGdiSelectPen(hDC, PreviousPen);
      }
   }
 
   if (!(Style & WS_MINIMIZE))
   {
      /* Draw menu bar */
      if (pWnd->state & WNDS_HASMENU && pWnd->IDMenu) // Should be pWnd->spmenu
      {
          PMENU menu;
          if ((menu = UserGetMenuObject(UlongToHandle(pWnd->IDMenu)))) // FIXME! Use pWnd->spmenu,
          {
             TempRect = CurrentRect;
             TempRect.bottom = TempRect.top + menu->cyMenu; // Should be pWnd->spmenu->cyMenu;
             CurrentRect.top += MENU_DrawMenuBar(hDC, &TempRect, pWnd, FALSE);
          }
      }
 
      if (ExStyle & WS_EX_CLIENTEDGE)
      {
          DrawEdge(hDC, &CurrentRect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
      }
   }
}

Referenced by IntDefWindowProc(), NtUserDrawCaptionTemp(), and UserPaintCaption().

UserDrawSysMenuButton()

BOOL UserDrawSysMenuButton	(	PWND	pWnd,
		HDC	hDC,
		LPRECT	Rect,
		BOOL	Down
	)

Definition at line 767 of file nonclient.c.

{
   PCURICON_OBJECT WindowIcon;
   BOOL Ret = FALSE;
 
   if ((WindowIcon = NC_IconForWindow(pWnd)))
   {
      UserReferenceObject(WindowIcon);
 
      Ret = UserDrawIconEx(hDC,
                           Rect->left + 2,
                           Rect->top + 2,
                           WindowIcon,
                           UserGetSystemMetrics(SM_CXSMICON),
                           UserGetSystemMetrics(SM_CYSMICON),
                           0, NULL, DI_NORMAL);
 
      UserDereferenceObject(WindowIcon);
   }
   return Ret;
}

Referenced by MENU_DrawMenuItem(), and NC_HandleNCLButtonDown().

UserFreeInputContext()

VOID UserFreeInputContext

(

_In_opt_ PVOID

Object

)

Definition at line 1532 of file ime.c.

{
    PTHRDESKHEAD ObjHead = Object;
    PDESKTOP pDesk = ObjHead->rpdesk;
    PIMC pNode, pIMC = Object;
    PTHREADINFO pti;
 
    if (!pIMC)
        return;
 
    // Remove pIMC from the list except spDefaultImc
    pti = pIMC->head.pti;
    for (pNode = pti->spDefaultImc; pNode; pNode = pNode->pImcNext)
    {
        if (pNode->pImcNext == pIMC)
        {
            pNode->pImcNext = pIMC->pImcNext;
            break;
        }
    }
 
    DesktopHeapFree(pDesk, Object);
 
    pti->ppi->UserHandleCount--;
    IntDereferenceThreadInfo(pti);
}

UserGetActiveWindow()

HWND FASTCALL UserGetActiveWindow

(

VOID

)

Definition at line 1432 of file focus.c.

{
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE ThreadQueue;
 
   pti = PsGetCurrentThreadWin32Thread();
   ThreadQueue = pti->MessageQueue;
   return( ThreadQueue ? (ThreadQueue->spwndActive ? UserHMGetHandle(ThreadQueue->spwndActive) : 0) : 0);
}

Referenced by co_UserCreateWindowEx(), DefWndHandleSysCommand(), IntDefWindowProc(), NC_HandleNCLButtonDown(), and NtUserGetThreadState().

UserGetAncestor()

PWND FASTCALL UserGetAncestor	(	PWND	Wnd,
		UINT	Type
	)

Referenced by co_WinPosActivateOtherWindow(), co_WinPosSetWindowPos(), IntDefWindowProc(), MENU_TrackKbdMenuBar(), MENU_TrackMouseMenuBar(), NC_HandleNCLButtonDown(), and WinPosFixupFlags().

UserGetDCEx()

HDC FASTCALL UserGetDCEx	(	PWND Window	OPTIONAL,
		HANDLE	ClipRegion,
		ULONG	Flags
	)

Referenced by co_IntDrawCaret(), co_IntPaintWindows(), co_UserGetUpdateRect(), co_WinPosSetWindowPos(), DefWndDoSizeMove(), ForceNCPaintErase(), IntBeginPaint(), IntDefWindowProc(), IntGetDialogBaseUnits(), IntPrintWindow(), IntRefeshScrollInterior(), IntScrollWindowEx(), IntSynthesizeBitmap(), IntSynthesizeDib(), IntUpdateLayeredWindowI(), MENU_PopupMenuCalcSize(), MENU_SelectItem(), MENU_ShowSubPopup(), NC_HandleNCActivate(), NC_HandleNCCalcSize(), NtUserCalcMenuBar(), PaintSuspendedWindow(), SnapWindow(), and UserPaintCaption().

UserGetForegroundWindow()

HWND FASTCALL UserGetForegroundWindow

(

VOID

)

Definition at line 1424 of file focus.c.

{
   PUSER_MESSAGE_QUEUE ForegroundQueue;
 
   ForegroundQueue = IntGetFocusMessageQueue();
   return( ForegroundQueue ? (ForegroundQueue->spwndActive ? UserHMGetHandle(ForegroundQueue->spwndActive) : 0) : 0);
}

Referenced by co_UserProcessHotKeys(), IntDefWindowProc(), NtUserGetForegroundWindow(), and WinPosFixupFlags().

UserGetKeyboardLayout()

HKL FASTCALL UserGetKeyboardLayout

(

DWORD

dwThreadId

)

Definition at line 995 of file kbdlayout.c.

{
    PTHREADINFO pti;
    PLIST_ENTRY ListEntry;
    PKL pKl;
 
    pti = PsGetCurrentThreadWin32Thread();
 
    if (!dwThreadId)
    {
        pKl = pti->KeyboardLayout;
        return pKl ? pKl->hkl : NULL;
    }
 
    ListEntry = pti->rpdesk->PtiList.Flink;
 
    //
    // Search the Desktop Thread list for related Desktop active Threads.
    //
    while(ListEntry != &pti->rpdesk->PtiList)
    {
        pti = CONTAINING_RECORD(ListEntry, THREADINFO, PtiLink);
 
        if (PsGetThreadId(pti->pEThread) == UlongToHandle(dwThreadId))
        {
           pKl = pti->KeyboardLayout;
           return pKl ? pKl->hkl : NULL;
        }
 
        ListEntry = ListEntry->Flink;
    }
 
    return NULL;
}

Referenced by IntGetActiveKeyboardLayout(), and NtUserCallOneParam().

UserGetKeyboardType()

DWORD FASTCALL UserGetKeyboardType

(

DWORD

TypeFlag

)

Definition at line 1684 of file keyboard.c.

{
    switch (dwTypeFlag)
    {
        case 0:        /* Keyboard type */
            return (DWORD)gKeyboardInfo.KeyboardIdentifier.Type;
        case 1:        /* Keyboard Subtype */
            return (DWORD)gKeyboardInfo.KeyboardIdentifier.Subtype;
        case 2:        /* Number of F-keys */
            return (DWORD)gKeyboardInfo.NumberOfFunctionKeys;
        default:
            ERR("Unknown type!\n");
            return 0;    /* Note: we don't have to set last error here */
    }
}

Referenced by NtUserCallOneParam().

UserGetKeyState()

DWORD FASTCALL UserGetKeyState

(

DWORD

key

)

Definition at line 221 of file msgqueue.c.

{
   DWORD dwRet = 0;
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   pti = PsGetCurrentThreadWin32Thread();
   MessageQueue = pti->MessageQueue;
 
   if (dwKey < 0x100)
   {
       if (IS_KEY_DOWN(MessageQueue->afKeyState, dwKey))
           dwRet |= 0xFF80; // If down, windows returns 0xFF80.
       if (IS_KEY_LOCKED(MessageQueue->afKeyState, dwKey))
           dwRet |= 0x1;
   }
   else
   {
      EngSetLastError(ERROR_INVALID_PARAMETER);
   }
   return dwRet;
}

Referenced by co_IntProcessKeyboardMessage(), co_IntTranslateAccelerator(), IntDefWindowProc(), MENU_InitPopup(), and NtUserGetKeyState().

UserGetMenuObject()

FORCEINLINE PMENU UserGetMenuObject

(

HMENU

hMenu

)

Definition at line 4 of file userfuncs.h.

{
   PMENU pMenu = UserGetObject(gHandleTable, hMenu, TYPE_MENU);
   if (!pMenu)
   {
      EngSetLastError(ERROR_INVALID_MENU_HANDLE);
   }
   return pMenu;
}

Referenced by co_IntSetWindowLongPtr(), co_IntTranslateAccelerator(), co_UserFreeWindow(), get_win_sys_menu(), IntDrawMenuBarTemp(), IntFindSubMenu(), IntGetMenu(), IntGetMenuObject(), IntGetMenuState(), IntGetSubMenu(), IntGetSystemMenu(), IntIsMenu(), IntMenuItemFromPoint(), IntSetMenuItemInfo(), IntSetSystemMenu(), MENU_DoNextMenu(), MENU_DrawMenuBar(), MENU_EndMenu(), MENU_FindItemByKey(), MENU_GetSystemMenu(), NC_DoNCPaint(), NtUserCheckMenuItem(), NtUserCreateWindowEx(), NtUserDeleteMenu(), NtUserDestroyMenu(), NtUserDrawMenuBarTemp(), NtUserEnableMenuItem(), NtUserGetMenuBarInfo(), NtUserGetMenuIndex(), NtUserGetMenuItemRect(), NtUserHiliteMenuItem(), NtUserMenuItemFromPoint(), NtUserRemoveMenu(), NtUserSetMenuContextHelpId(), NtUserSetMenuDefaultItem(), NtUserSetMenuFlagRtoL(), NtUserThunkedMenuInfo(), NtUserThunkedMenuItemInfo(), NtUserTrackPopupMenuEx(), PopupMenuWndProc(), UserDestroyMenu(), and UserDrawCaptionBar().

UserGetProcessWindowStation()

HWINSTA FASTCALL UserGetProcessWindowStation

(

VOID

)

Definition at line 1364 of file winsta.c.

{
    PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
 
    return ppi->hwinsta;
}

Referenced by IntGetWinStaForCbAccess(), NtUserCloseWindowStation(), and NtUserGetProcessWindowStation().

UserGetShellWindow()

HWND FASTCALL UserGetShellWindow

(

VOID

)

Definition at line 3697 of file window.c.

{
   PWINSTATION_OBJECT WinStaObject;
   HWND Ret;
 
   NTSTATUS Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
                     UserMode,
                     0,
                     &WinStaObject,
                     0);
 
   if (!NT_SUCCESS(Status))
   {
      SetLastNtError(Status);
      return NULL;
   }
 
   Ret = (HWND)WinStaObject->ShellWindow;
 
   ObDereferenceObject(WinStaObject);
   return Ret;
}

Referenced by co_WinPosSetWindowPos(), and SpiSetWallpaper().

UserGetSystemMetrics()

LONG NTAPI UserGetSystemMetrics

(

ULONG

Index

)

Definition at line 210 of file metric.c.

{
    ASSERT(gpsi);
    ASSERT(Setup);
    TRACE("UserGetSystemMetrics(%lu)\n", Index);
 
    if (Index == SM_DBCSENABLED)
        return !!(gpsi->dwSRVIFlags & SRVINFO_DBCSENABLED);
 
    if (Index == SM_IMMENABLED)
        return !!(gpsi->dwSRVIFlags & SRVINFO_IMM32);
 
    /* Get metrics from array */
    if (Index < SM_CMETRICS)
    {
        return gpsi->aiSysMet[Index];
    }
 
    /* Handle special values */
    switch (Index)
    {
        case SM_REMOTESESSION:
            return 0; // FIXME
 
        case SM_SHUTTINGDOWN:
            return 0; // FIXME
 
        case SM_REMOTECONTROL:
            return 0; // FIXME
    }
 
    ERR("UserGetSystemMetrics() called with invalid index %lu\n", Index);
    return 0;
}

Referenced by co_IntProcessMouseMessage(), co_WinPosArrangeIconicWindows(), co_WinPosDoWinPosChanging(), co_WinPosGetMinMaxInfo(), co_WinPosMinMaximize(), DefWndDoSizeMove(), DefWndStartSizeMove(), GetNCHitEx(), IntCalculateThumb(), IntCreateDesktop(), IntCreateWindow(), IntDefWindowProc(), IntDrawMenuBarTemp(), IntFixWindowCoordinates(), IntGetClientRect(), IntGetScrollBarRect(), intGetTitleBarInfo(), IntGetWindowBorderMeasures(), IntIsWindowFullscreen(), IntPaintDesktop(), MENU_CalcItemSize(), MENU_DrawBitmapItem(), MENU_DrawMenuBar(), MENU_DrawMenuItem(), MENU_EnsureMenuItemVisible(), MENU_FindItemByCoords(), MENU_FindItemByKey(), MENU_GetBitmapItemSize(), MENU_GetMaxPopupHeight(), MENU_ShowPopup(), MENU_ShowSubPopup(), NC_DoNCPaint(), NC_DrawFrame(), NC_GetInsideRect(), NC_GetSysPopupPos(), NC_HandleNCCalcSize(), NtUserCreateCaret(), NtUserDragDetect(), NtUserGetClipCursor(), NtUserSwitchDesktop(), UserDrawCaption(), UserDrawCaptionBar(), UserDrawCaptionButton(), UserDrawCaptionText(), UserDrawIconEx(), UserDrawMovingFrame(), UserDrawSysMenuButton(), UserGetWindowBorders(), UserSendMouseInput(), UserSetClassLongPtr(), and WinPosFindIconPos().

UserGetWindowDC()

HDC FASTCALL UserGetWindowDC

(

PWND

Wnd

)

Definition at line 947 of file windc.c.

{
  return UserGetDCEx(Wnd, 0, DCX_USESTYLE | DCX_WINDOW);
}

Referenced by DefWndScreenshot(), IntAnimatePalette(), NC_DoButton(), NC_HandleNCLButtonDown(), UserGetDesktopDC(), and UserRealizePalette().

UserGetWindowObject()

PWND FASTCALL UserGetWindowObject

(

HWND

hWnd

)

Definition at line 124 of file window.c.

{
    PWND Window;
 
   if (!hWnd)
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      return NULL;
   }
 
   Window = (PWND)UserGetObject(gHandleTable, hWnd, TYPE_WINDOW);
   if (!Window || 0 != (Window->state & WNDS_DESTROYED))
   {
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      return NULL;
   }
 
   return Window;
}

Referenced by CaretSystemTimerProc(), co_IntCallHookProc(), co_IntDoSendMessage(), co_IntGetPeekMessage(), co_IntHideCaret(), co_IntPaintWindows(), co_IntSendActivateMessages(), co_IntSendMessageTimeout(), co_IntSendMessageTimeoutSingle(), co_IntSendMessageWithCallBack(), co_IntSetCaretPos(), co_IntSetWindowLongPtr(), co_MsqInsertMouseMessage(), co_UserCreateWindowEx(), co_UserHideCaret(), co_UserSetCapture(), co_UserSetParent(), DceResetActiveDCEs(), DceUpdateVisRgn(), EngCreateWnd(), EngDeleteWnd(), IntClientShutdown(), IntDdeGetMessageHook(), IntDdePostMessageHook(), IntDdeSendMessageHook(), IntDefWindowProc(), IntDispatchMessage(), IntEnableWindow(), IntFindWindow(), IntGetMenuItemRect(), IntGetWindowObject(), IntIsWindow(), IntLinkHwnd(), IntNtUserSetClassLongPtr(), IntPaintDesktop(), IntScrollWindowEx(), IntSendDestroyMsg(), IntSetOwner(), IntSetTebWndCallback(), IntTrackMouseEvent(), NtGdiUpdateColors(), NtUserBeginPaint(), NtUserBuildHwndList(), NtUserBuildPropList(), NtUserCalcMenuBar(), NtUserCallHwnd(), NtUserCallHwndLock(), NtUserCallHwndParam(), NtUserCallHwndParamLock(), NtUserCallTwoParam(), NtUserChangeClipboardChain(), NtUserChildWindowFromPointEx(), NtUserCreateCaret(), NtUserDeferWindowPos(), NtUserDefSetText(), NtUserDestroyWindow(), NtUserDrawCaptionTemp(), NtUserDrawMenuBarTemp(), NtUserEnableScrollBar(), NtUserEndPaint(), NtUserExcludeUpdateRgn(), NtUserFillWindow(), NtUserFindWindowEx(), NtUserGetAncestor(), NtUserGetClassName(), NtUserGetComboBoxInfo(), NtUserGetControlBrush(), NtUserGetControlColor(), NtUserGetCPD(), NtUserGetDCEx(), NtUserGetInternalWindowPos(), NtUserGetLayeredWindowAttributes(), NtUserGetListBoxInfo(), NtUserGetMenuBarInfo(), NtUserGetMenuItemRect(), NtUserGetScrollBarInfo(), NtUserGetSystemMenu(), NtUserGetTitleBarInfo(), NtUserGetUpdateRect(), NtUserGetUpdateRgn(), NtUserGetWindowPlacement(), NtUserHideCaret(), NtUserHiliteMenuItem(), NtUserInternalGetWindowText(), NtUserKillTimer(), NtUserMenuItemFromPoint(), NtUserMessageCall(), NtUserMinMaximize(), NtUserMonitorFromWindow(), NtUserNotifyWinEvent(), NtUserPaintMenuBar(), NtUserPrintWindow(), NtUserQueryWindow(), NtUserRealChildWindowFromPoint(), NtUserRedrawWindow(), NtUserRegisterHotKey(), NtUserRemoveProp(), NtUserSBGetParms(), NtUserScrollWindowEx(), NtUserSetActiveWindow(), NtUserSetClipboardViewer(), NtUserSetFocus(), NtUserSetInternalWindowPos(), NtUserSetLayeredWindowAttributes(), NtUserSetMenu(), NtUserSetProp(), NtUserSetScrollBarInfo(), NtUserSetScrollInfo(), NtUserSetShellWindowEx(), NtUserSetSystemMenu(), NtUserSetSystemTimer(), NtUserSetTimer(), NtUserSetWindowFNID(), NtUserSetWindowPlacement(), NtUserSetWindowPos(), NtUserSetWindowRgn(), NtUserSetWindowWord(), NtUserShowCaret(), NtUserShowScrollBar(), NtUserShowWindow(), NtUserShowWindowAsync(), NtUserTrackPopupMenuEx(), NtUserTranslateAccelerator(), NtUserTranslateMessage(), NtUserUnregisterHotKey(), NtUserUpdateLayeredWindow(), NtUserWindowFromPoint(), ScrollBarWndProc(), SnapWindow(), SpiNotifyNCMetricsChanged(), SystemTimerProc(), UserGetDesktopWindow(), UserGethWnd(), UserOpenClipboard(), UserPostMessage(), UserRealizePalette(), UserRegisterUserApiHook(), and UserSendNotifyMessage().

UserIsCTFIMEEnabled()

BOOL FASTCALL UserIsCTFIMEEnabled

(

VOID

)

Definition at line 31 of file metric.c.

{
    if (RegGetSectionDWORD(L"IMM", L"DontLoadCTFIME", FALSE))
        return FALSE;
 
    return UserIsIMMEnabled();
}

Referenced by InitMetrics().

UserIsDBCSEnabled()

BOOL FASTCALL UserIsDBCSEnabled

(

VOID

)

Definition at line 17 of file metric.c.

{
    return NLS_MB_CODE_PAGE_TAG;
}

Referenced by InitMetrics().

UserIsIMMEnabled()

BOOL FASTCALL UserIsIMMEnabled

(

VOID

)

Definition at line 22 of file metric.c.

{
    if (NLS_MB_CODE_PAGE_TAG)
        return TRUE;
 
    /* "LoadIMM" means Cicero despite its name */
    return !!RegGetSectionDWORD(L"IMM", L"LoadIMM", FALSE);
}

Referenced by InitMetrics(), NtUserCallNoParam(), and UserIsCTFIMEEnabled().

UserPaintCaption()

BOOL UserPaintCaption	(	PWND	pWnd,
		INT	Flags
	)

Definition at line 398 of file defwnd.c.

{
  BOOL Ret = FALSE;
 
  if ( (pWnd->style & WS_VISIBLE) && ((pWnd->style & WS_CAPTION) == WS_CAPTION) )
  {
      if (pWnd->state & WNDS_HASCAPTION && pWnd->head.pti->MessageQueue == gpqForeground)
         Flags |= DC_ACTIVE;
    /*
     * When themes are not enabled we can go on and paint the non client area.
     * However if we do that with themes enabled we will draw a classic frame.
     * This is solved by sending a themes specific message to notify the themes
     * engine that the caption needs to be redrawn.
     */
      if (gpsi->dwSRVIFlags & SRVINFO_APIHOOK)
      {
        /*
         * This will cause uxtheme to either paint the themed caption or call
         * RealUserDrawCaption in order to draw the classic caption when themes
         * are disabled but the themes service is enabled.
         */
         TRACE("UDCB Flags %08x\n", Flags);
         co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCUAHDRAWCAPTION, Flags, 0);
      }
      else
      {
         HDC hDC = UserGetDCEx(pWnd, NULL, DCX_WINDOW|DCX_USESTYLE);
         UserDrawCaptionBar(pWnd, hDC, Flags | DC_FRAME); // DCFRAME added as fix for CORE-10855.
         UserReleaseDC(pWnd, hDC, FALSE);
      }
      Ret = TRUE;
   }
   // Support window tray
   return Ret;
}

Referenced by DefWndSetIcon(), IntDefWindowProc(), IntEnableMenuItem(), IntNtUserSetClassLongPtr(), NtUserCallTwoParam(), RealDefWindowProcA(), and RealDefWindowProcW().

UserPostMessage()

BOOL FASTCALL UserPostMessage	(	HWND	Wnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1395 of file message.c.

{
    PTHREADINFO pti;
    MSG Message;
    LONG_PTR ExtraInfo = 0;
 
    Message.hwnd = Wnd;
    Message.message = Msg;
    Message.wParam = wParam;
    Message.lParam = lParam;
    Message.pt = gpsi->ptCursor;
    Message.time = EngGetTickCount32();
 
    if (is_pointer_message(Message.message, Message.wParam))
    {
        EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
        return FALSE;
    }
 
    if (Wnd == HWND_BROADCAST || Wnd == HWND_TOPMOST)
    {
        HWND *List;
        PWND DesktopWindow;
        ULONG i;
 
        if (!is_message_broadcastable(Msg)) return TRUE;
 
        DesktopWindow = UserGetDesktopWindow();
        List = IntWinListChildren(DesktopWindow);
 
        if (List != NULL)
        {
            UserPostMessage(UserHMGetHandle(DesktopWindow), Msg, wParam, lParam);
            for (i = 0; List[i]; i++)
            {
                PWND pwnd = UserGetWindowObject(List[i]);
                if (!pwnd) continue;
 
                if ( pwnd->fnid == FNID_MENU || // Also need pwnd->pcls->atomClassName == gaOleMainThreadWndClass
                     pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_SWITCH] )
                   continue;
 
                UserPostMessage(List[i], Msg, wParam, lParam);
            }
            ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
        }
    }
    else
    {
        PWND Window;
 
        if (!Wnd)
        {
           return UserPostThreadMessage( gptiCurrent,
                                         Msg,
                                         wParam,
                                         lParam);
        }
 
        Window = UserGetWindowObject(Wnd);
        if ( !Window )
        {
            ERR("UserPostMessage: Invalid handle 0x%p Msg 0x%x!\n", Wnd, Msg);
            return FALSE;
        }
 
        pti = Window->head.pti;
 
        if ( pti->TIF_flags & TIF_INCLEANUP )
        {
            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 %p that is being destroyed!\n", Wnd);
            EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
            return FALSE;
        }
 
        if ( Msg >= WM_DDE_FIRST && Msg <= WM_DDE_LAST )
        {
           if (!IntDdePostMessageHook(Window, Msg, wParam, &lParam, &ExtraInfo))
           {
              TRACE("Posting Exit DDE 0x%x\n",Msg);
              return FALSE;
           }
           Message.lParam = lParam;
        }
 
        MsqPostMessage(pti, &Message, FALSE, QS_POSTMESSAGE, 0, ExtraInfo);
    }
    return TRUE;
}

Referenced by co_IntProcessKeyboardMessage(), co_IntShellHookNotify(), co_UserProcessHotKeys(), DefWndHandleSetCursor(), DefWndHandleSysCommand(), DoTheScreenSaver(), ExitThreadCallback(), IntDefWindowProc(), IntImmProcessKey(), IntLanguageToggle(), IntRemoveTrackMouseEvent(), IntTrackMouseEvent(), IntTrackMouseMove(), MENU_EndMenu(), MENU_ExecFocusedItem(), MENU_TrackKbdMenuBar(), MENU_TrackMenu(), NotifyLogon(), NtUserCallOneParam(), NtUserEndMenu(), NtUserLockWorkStation(), NtUserMessageCall(), NtUserPostMessage(), SystemTimerProc(), and UserPostMessage().

UserReleaseDC()

INT FASTCALL UserReleaseDC	(	PWND	Window,
		HDC	hDc,
		BOOL	EndPaint
	)

Definition at line 918 of file windc.c.

{
  PDCE dce;
  PLIST_ENTRY ListEntry;
  INT nRet = 0;
  BOOL Hit = FALSE;
 
  TRACE("%p %p\n", Window, hDc);
  ListEntry = LEDce.Flink;
  while (ListEntry != &LEDce)
  {
     dce = CONTAINING_RECORD(ListEntry, DCE, List);
     ListEntry = ListEntry->Flink;
     if (dce->hDC == hDc)
     {
        Hit = TRUE;
        break;
     }
  }
 
  if ( Hit && (dce->DCXFlags & DCX_DCEBUSY))
  {
     nRet = DceReleaseDC(dce, EndPaint);
  }
 
  return nRet;
}

Referenced by co_IntDrawCaret(), co_IntPaintWindows(), co_UserGetUpdateRect(), co_WinPosSetWindowPos(), DefWndDoSizeMove(), DefWndScreenshot(), ForceNCPaintErase(), IntAnimatePalette(), IntDefWindowProc(), IntEndPaint(), IntGdiDeleteDC(), IntGetDialogBaseUnits(), IntPrintWindow(), IntRefeshScrollInterior(), IntScrollWindowEx(), IntSynthesizeBitmap(), IntSynthesizeDib(), IntUpdateLayeredWindowI(), MENU_PopupMenuCalcSize(), MENU_SelectItem(), MENU_ShowSubPopup(), NC_DoButton(), NC_HandleNCActivate(), NC_HandleNCCalcSize(), NC_HandleNCLButtonDown(), NtUserCalcMenuBar(), NtUserCallOneParam(), PaintSuspendedWindow(), SnapWindow(), UserPaintCaption(), and UserRealizePalette().

UserSetMenuDefaultItem()

BOOL FASTCALL UserSetMenuDefaultItem	(	PMENU	Menu,
		UINT	uItem,
		UINT	fByPos
	)

Definition at line 1274 of file menu.c.

{
   UINT i;
   PITEM MenuItem = MenuObject->rgItems;
 
   if (!MenuItem) return FALSE;
 
   /* reset all default-item flags */
   for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
   {
       MenuItem->fState &= ~MFS_DEFAULT;
   }
 
   /* no default item */
   if(uItem == (UINT)-1)
   {
      return TRUE;
   }
   MenuItem = MenuObject->rgItems;
   if ( fByPos )
   {
      if ( uItem >= MenuObject->cItems ) return FALSE;
         MenuItem[uItem].fState |= MFS_DEFAULT;
      return TRUE;
   }
   else
   {
      for (i = 0; i < MenuObject->cItems; i++, MenuItem++)
      {
          if (MenuItem->wID == uItem)
          {
             MenuItem->fState |= MFS_DEFAULT;
             return TRUE;
          }
      }
 
   }
   return FALSE;
}

Referenced by co_UserTrackSystemMenu(), IntSetMenuItemInfo(), MENU_GetSystemMenu(), MENU_InitSysMenuPopup(), and NtUserSetMenuDefaultItem().

UserSystemParametersInfo()

BOOL FASTCALL UserSystemParametersInfo	(	UINT	uiAction,
		UINT	uiParam,
		PVOID	pvParam,
		UINT	fWinIni
	)

Definition at line 2116 of file sysparams.c.

{
    ULONG_PTR ulResult;
    PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
 
    ASSERT(ppi);
 
    if (!gbSpiInitialized)
    {
        KeRosDumpStackFrames(NULL, 20);
        //ASSERT(FALSE);
        return FALSE;
    }
 
    /* Get a pointer to the current Windowstation */
    if (!ppi->prpwinsta)
    {
        ERR("UserSystemParametersInfo called without active window station.\n");
        //ASSERT(FALSE);
        //return FALSE;
    }
 
    if ((fWinIni & SPIF_PROTECT) && !SpiGetSetProbeBuffer(uiAction, uiParam, pvParam))
    {
        EngSetLastError(ERROR_NOACCESS);
        return FALSE;
    }
 
    /* Do the actual operation */
    ulResult = SpiGetSet(uiAction, uiParam, pvParam, fWinIni);
 
    /* Did we change something? */
    if (ulResult > 1)
    {
        SpiFixupValues();
 
        /* Update system metrics */
        InitMetrics();
 
        /* Send notification to toplevel windows, if requested */
        if (fWinIni & SPIF_SENDCHANGE)
        {
            /* Send WM_SETTINGCHANGE to all toplevel windows */
            co_IntSendMessageTimeout(HWND_BROADCAST,
                                     WM_SETTINGCHANGE,
                                     (WPARAM)uiAction,
                                     (LPARAM)ulResult,
                                     SMTO_NORMAL,
                                     100,
                                     &ulResult);
        }
        ulResult = 1;
    }
 
    return ulResult;
}

Referenced by co_IntCalculateSnapPosition(), DefWndDoSizeMove(), GetSnapActivationPoint(), IntDrawMenuBarTemp(), IntPaintDesktop(), MENU_DrawBitmapItem(), MENU_DrawMenuItem(), MenuInit(), NC_DoNCPaint(), NC_HandleNCLButtonDblClk(), NtUserSystemParametersInfo(), UserDrawCaptionBar(), and UserDrawCaptionText().

Variable Documentation

gAtomTable

PRTL_ATOM_TABLE gAtomTable

extern

Definition at line 13 of file session.c.

Referenced by _Success_(), FreeCurIconObject(), InitSessionImpl(), IntAddAtom(), IntAddGlobalAtom(), IntDeregisterClassAtom(), IntGetAtomName(), IntRegisterClassAtom(), IntSetAconData(), IntSetCursorData(), NtUserFindExistingCursorIcon(), UserGetClassName(), and UserSetCursorIconData().