window.h File Reference

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

Go to the source code of this file.

Classes
struct	tagWINDOWLIST

Macros
#define	HAS_DLGFRAME(Style, ExStyle)
#define	HAS_THICKFRAME(Style, ExStyle)
#define	HAS_THINFRAME(Style, ExStyle)    (((Style) & WS_BORDER) || (!((Style) & (WS_CHILD | WS_POPUP))))
#define	HAS_CLIENTFRAME(Style, ExStyle)    (((ExStyle) & WS_EX_CLIENTEDGE) || (!((Style) & (WS_CHILD | WS_POPUP))))
#define	HAS_MENU(pWnd, style)   ((((style) & (WS_CHILD | WS_POPUP)) != WS_CHILD) && (pWnd->IDMenu) && IntIsMenu(UlongToHandle(pWnd->IDMenu)))
#define	IntIsDesktopWindow(WndObj)    (WndObj->spwndParent == NULL)
#define	IntIsBroadcastHwnd(hWnd)    (hWnd == HWND_BROADCAST || hWnd == HWND_TOPMOST)
#define	IntWndBelongsToThread(WndObj, W32Thread)    ((WndObj->head.pti) && (WndObj->head.pti == W32Thread))
#define	IntGetWndThreadId(WndObj)    PsGetThreadId(WndObj->head.pti->pEThread)
#define	IntGetWndProcessId(WndObj)    PsGetProcessId(WndObj->head.pti->ppi->peProcess)
#define	WINVER_WIN2K   _WIN32_WINNT_WIN2K
#define	WINVER_WINNT4   _WIN32_WINNT_NT4
#define	WINVER_WIN31   0x30A
#define	HWND_TERMINATOR   ((HWND)UlongToHandle(1))
#define	WL_IS_BAD(pwl)   ((pwl)->phwndEnd <= (pwl)->phwndLast)
#define	WL_CAPACITY(pwl)   ((pwl)->phwndEnd - &((pwl)->ahwnd[0]))
#define	IACE_LIST   0x0002
#define	IS_WND_CHILD(pWnd)   ((pWnd)->style & WS_CHILD)
#define	IS_WND_MENU(pWnd)   ((pWnd)->pcls->atomClassName == gpsi->atomSysClass[ICLS_MENU])
#define	IS_WND_IMELIKE(pWnd)

Typedefs
typedef struct tagWINDOWLIST	WINDOWLIST
typedef struct tagWINDOWLIST *	PWINDOWLIST

Functions
PWND FASTCALL	ValidateHwndNoErr (HWND)
BOOL FASTCALL	UserUpdateUiState (PWND Wnd, WPARAM wParam)
BOOL FASTCALL	IntIsWindow (HWND hWnd)
HWND *FASTCALL	IntWinListChildren (PWND Window)
HWND *FASTCALL	IntWinListOwnedPopups (PWND Window)
VOID FASTCALL	IntGetClientRect (PWND WindowObject, RECTL *Rect)
INT FASTCALL	IntMapWindowPoints (PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
BOOL FASTCALL	IntIsChildWindow (PWND Parent, PWND Child)
VOID FASTCALL	IntUnlinkWindow (PWND Wnd)
VOID FASTCALL	IntLinkHwnd (PWND Wnd, HWND hWndPrev)
PWND FASTCALL	IntGetParent (PWND Wnd)
VOID FASTCALL	IntGetWindowBorderMeasures (PWND WindowObject, UINT *cx, UINT *cy)
BOOL FASTCALL	IntShowOwnedPopups (PWND owner, BOOL fShow)
LRESULT FASTCALL	IntDefWindowProc (PWND Window, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)
VOID FASTCALL	IntNotifyWinEvent (DWORD, PWND, LONG, LONG, DWORD)
PWND FASTCALL	IntCreateWindow (CREATESTRUCTW *Cs, PLARGE_STRING WindowName, PCLS Class, PWND ParentWindow, PWND OwnerWindow, PVOID acbiBuffer, PDESKTOP pdeskCreated, DWORD dwVer)
PWND FASTCALL	co_UserCreateWindowEx (CREATESTRUCTW *Cs, PUNICODE_STRING ClassName, PLARGE_STRING WindowName, PVOID acbiBuffer, DWORD dwVer)
BOOL FASTCALL	IntEnableWindow (HWND, BOOL)
BOOL FASTCALL	IntIsWindowVisible (PWND)
DWORD FASTCALL	GetNCHitEx (PWND, POINT)
ULONG FASTCALL	IntSetStyle (PWND, ULONG, ULONG)
PWND FASTCALL	VerifyWnd (PWND)
PWND FASTCALL	IntGetNonChildAncestor (PWND)
LONG FASTCALL	co_UserSetWindowLong (HWND, DWORD, LONG, BOOL)
LONG_PTR FASTCALL	co_UserSetWindowLongPtr (HWND, DWORD, LONG_PTR, BOOL)
HWND FASTCALL	IntGetWindow (HWND, UINT)
LRESULT	co_UserFreeWindow (PWND, PPROCESSINFO, PTHREADINFO, BOOLEAN)
PWINDOWLIST FASTCALL	IntBuildHwndList (PWND pwnd, DWORD dwFlags, PTHREADINFO pti)
VOID FASTCALL	IntFreeHwndList (PWINDOWLIST pwlTarget)
HWND FASTCALL	IntFindWindow (PWND Parent, PWND ChildAfter, RTL_ATOM ClassAtom, PUNICODE_STRING WindowName)
BOOL FASTCALL	IntWantImeWindow (_In_ PWND pwndTarget)
PWND FASTCALL	co_IntCreateDefaultImeWindow (_In_ PWND pwndTarget, _In_ HINSTANCE hInst)
BOOL FASTCALL	IntImeCanDestroyDefIMEforChild (_In_ PWND pImeWnd, _In_ PWND pwndTarget)
BOOL FASTCALL	IntImeCanDestroyDefIME (_In_ PWND pImeWnd, _In_ PWND pwndTarget)
BOOL FASTCALL	IntBroadcastImeShowStatusChange (_In_ PWND pImeWnd, _In_ BOOL bShow)
VOID FASTCALL	IntNotifyImeShowStatus (_In_ PWND pImeWnd)
VOID FASTCALL	IntCheckImeShowStatusInThread (_In_ PWND pImeWnd)
static VOID	ReplaceWndPtr (_Inout_ PWND *ppwnd, _In_opt_ PWND pwndNew)
static VOID	WndSetOwner (_Inout_ PWND pwnd, _In_opt_ PWND pwndOwner)
static VOID	WndSetParent (_Inout_ PWND pwnd, _In_opt_ PWND pwndParent)
static VOID	WndSetChild (_Inout_ PWND pwnd, _In_opt_ PWND pwndChild)
static VOID	WndSetNext (_Inout_ PWND pwnd, _In_opt_ PWND pwndNext)
static VOID	WndSetPrev (_Inout_ PWND pwnd, _In_opt_ PWND pwndPrev)
static VOID	WndSetLastActive (_Inout_ PWND pwnd, _In_opt_ PWND pwndLastActive)

Variables
ATOM	AtomMessage
ATOM	AtomWndObj
ATOM	AtomLayer
ATOM	AtomFlashWndState
BOOL	g_bWindowSnapEnabled
PWINDOWLIST	gpwlList
PWINDOWLIST	gpwlCache
BOOL	gfIMEShowStatus

Macro Definition Documentation

HAS_CLIENTFRAME

#define HAS_CLIENTFRAME	(		Style,
			ExStyle
	)		(((ExStyle) & WS_EX_CLIENTEDGE) || (!((Style) & (WS_CHILD | WS_POPUP))))

Definition at line 20 of file window.h.

HAS_DLGFRAME

#define HAS_DLGFRAME	(		Style,
			ExStyle
	)

Value:

            (((ExStyle) & WS_EX_DLGMODALFRAME) || \
            (((Style) & WS_DLGFRAME) && (!((Style) & WS_THICKFRAME))))

Definition at line 9 of file window.h.

HAS_MENU

#define HAS_MENU	(		pWnd,
			style
	)		((((style) & (WS_CHILD | WS_POPUP)) != WS_CHILD) && (pWnd->IDMenu) && IntIsMenu(UlongToHandle(pWnd->IDMenu)))

Definition at line 23 of file window.h.

HAS_THICKFRAME

#define HAS_THICKFRAME	(		Style,
			ExStyle
	)

Value:

            (((Style) & WS_THICKFRAME) && \
            (!(((Style) & (WS_DLGFRAME | WS_BORDER)) == WS_DLGFRAME)))

Definition at line 13 of file window.h.

HAS_THINFRAME

#define HAS_THINFRAME	(		Style,
			ExStyle
	)		(((Style) & WS_BORDER) || (!((Style) & (WS_CHILD | WS_POPUP))))

Definition at line 17 of file window.h.

HWND_TERMINATOR

#define HWND_TERMINATOR   ((HWND)UlongToHandle(1))

Definition at line 83 of file window.h.

IACE_LIST

#define IACE_LIST   0x0002

Definition at line 106 of file window.h.

IntGetWndProcessId

#define IntGetWndProcessId

(

WndObj

)

PsGetProcessId(WndObj->head.pti->ppi->peProcess)

Definition at line 38 of file window.h.

IntGetWndThreadId

#define IntGetWndThreadId

(

WndObj

)

PsGetThreadId(WndObj->head.pti->pEThread)

Definition at line 35 of file window.h.

IntIsBroadcastHwnd

#define IntIsBroadcastHwnd

(

hWnd

)

(hWnd == HWND_BROADCAST || hWnd == HWND_TOPMOST)

Definition at line 28 of file window.h.

IntIsDesktopWindow

#define IntIsDesktopWindow

(

WndObj

)

(WndObj->spwndParent == NULL)

Definition at line 25 of file window.h.

IntWndBelongsToThread

#define IntWndBelongsToThread	(		WndObj,
			W32Thread
	)		((WndObj->head.pti) && (WndObj->head.pti == W32Thread))

Definition at line 32 of file window.h.

IS_WND_CHILD

#define IS_WND_CHILD

(

pWnd

)

((pWnd)->style & WS_CHILD)

Definition at line 108 of file window.h.

IS_WND_IMELIKE

#define IS_WND_IMELIKE

(

pWnd

)

Value:

    (((pWnd)->pcls->style & CS_IME) || \
     ((pWnd)->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]))

Definition at line 114 of file window.h.

IS_WND_MENU

#define IS_WND_MENU

(

pWnd

)

((pWnd)->pcls->atomClassName == gpsi->atomSysClass[ICLS_MENU])

Definition at line 109 of file window.h.

WINVER_WIN2K

#define WINVER_WIN2K   _WIN32_WINNT_WIN2K

Definition at line 56 of file window.h.

WINVER_WIN31

#define WINVER_WIN31   0x30A

Definition at line 58 of file window.h.

WINVER_WINNT4

#define WINVER_WINNT4   _WIN32_WINNT_NT4

Definition at line 57 of file window.h.

WL_CAPACITY

#define WL_CAPACITY

(

pwl

)

((pwl)->phwndEnd - &((pwl)->ahwnd[0]))

Definition at line 98 of file window.h.

WL_IS_BAD

#define WL_IS_BAD

(

pwl

)

((pwl)->phwndEnd <= (pwl)->phwndLast)

Definition at line 97 of file window.h.

Typedef Documentation

PWINDOWLIST

typedef struct tagWINDOWLIST * PWINDOWLIST

WINDOWLIST

typedef struct tagWINDOWLIST WINDOWLIST

Function Documentation

co_IntCreateDefaultImeWindow()

PWND FASTCALL co_IntCreateDefaultImeWindow	(	_In_ PWND	pwndTarget,
		_In_ HINSTANCE	hInst
	)

Definition at line 2064 of file ime.c.

{
    LARGE_UNICODE_STRING WindowName;
    UNICODE_STRING ClassName;
    PWND pImeWnd;
    PIMEUI pimeui;
    CREATESTRUCTW Cs;
    USER_REFERENCE_ENTRY Ref;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    HANDLE pid = PsGetThreadProcessId(pti->pEThread);
 
    if (!(pti->spDefaultImc) && pid == gpidLogon)
        UserCreateInputContext(0);
 
    if (!(pti->spDefaultImc) || IS_WND_IMELIKE(pwndTarget) || !(pti->rpdesk->pheapDesktop))
        return NULL;
 
    if (IS_WND_CHILD(pwndTarget) && !(pwndTarget->style & WS_VISIBLE) &&
        pwndTarget->spwndParent->head.pti->ppi != pti->ppi)
    {
        return NULL;
    }
 
    RtlInitLargeUnicodeString(&WindowName, L"Default IME", 0);
 
    ClassName.Buffer = UlongToPtr(gpsi->atomSysClass[ICLS_IME]);
    ClassName.Length = 0;
    ClassName.MaximumLength = 0;
 
    UserRefObjectCo(pwndTarget, &Ref);
 
    RtlZeroMemory(&Cs, sizeof(Cs));
    Cs.style = WS_POPUP | WS_DISABLED;
    Cs.hInstance = hInst;
    Cs.hwndParent = UserHMGetHandle(pwndTarget);
    Cs.lpszName = WindowName.Buffer;
    Cs.lpszClass = ClassName.Buffer;
 
    // NOTE: LARGE_UNICODE_STRING is compatible to LARGE_STRING.
    pImeWnd = co_UserCreateWindowEx(&Cs, &ClassName, (PLARGE_STRING)&WindowName, NULL, WINVER);
    if (pImeWnd)
    {
        pimeui = IntGetImeUIFromWnd(pImeWnd);
        ASSERT(pimeui);
        _SEH2_TRY
        {
            ProbeForWrite(pimeui, sizeof(*pimeui), 1);
            pimeui->fDefault = TRUE;
            if (IS_WND_CHILD(pwndTarget) && pwndTarget->spwndParent->head.pti != pti)
                pimeui->fChildThreadDef = TRUE;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            ERR("Exception in co_IntCreateDefaultImeWindow: %p\n", pimeui);
        }
        _SEH2_END;
    }
 
    UserDerefObjectCo(pwndTarget);
    return pImeWnd;
}

Referenced by co_UserCreateWindowEx().

co_UserCreateWindowEx()

PWND FASTCALL co_UserCreateWindowEx	(	CREATESTRUCTW *	Cs,
		PUNICODE_STRING	ClassName,
		PLARGE_STRING	WindowName,
		PVOID	acbiBuffer,
		DWORD	dwVer
	)

Definition at line 2169 of file window.c.

{
   ULONG style;
   PWND Window = NULL, ParentWindow = NULL, OwnerWindow;
   HWND hWnd, hWndParent, hWndOwner, hwndInsertAfter;
   PWINSTATION_OBJECT WinSta;
   PCLS Class = NULL;
   SIZE Size;
   POINT MaxSize, MaxPos, MinTrack, MaxTrack;
   CBT_CREATEWNDW * pCbtCreate;
   LRESULT Result;
   USER_REFERENCE_ENTRY ParentRef, Ref;
   PTHREADINFO pti;
   DWORD dwShowMode = SW_SHOW;
   CREATESTRUCTW *pCsw = NULL;
   PVOID pszClass = NULL, pszName = NULL;
   PWND ret = NULL;
 
   /* Get the current window station and reference it */
   pti = GetW32ThreadInfo();
   if (pti == NULL || pti->rpdesk == NULL)
   {
      ERR("Thread is not attached to a desktop! Cannot create window (%wZ)\n", ClassName);
      return NULL; // There is nothing to cleanup.
   }
   WinSta = pti->rpdesk->rpwinstaParent;
   ObReferenceObjectByPointer(WinSta, KernelMode, ExWindowStationObjectType, 0);
 
   pCsw = NULL;
   pCbtCreate = NULL;
 
   /* Get the class and reference it */
   Class = IntGetAndReferenceClass(ClassName, Cs->hInstance, FALSE);
   if(!Class)
   {
       EngSetLastError(ERROR_CANNOT_FIND_WND_CLASS);
       ERR("Failed to find class %wZ\n", ClassName);
       goto cleanup;
   }
 
   /* Now find the parent and the owner window */
   hWndParent = UserHMGetHandle(pti->rpdesk->pDeskInfo->spwnd);
   hWndOwner = NULL;
 
    if (Cs->hwndParent == HWND_MESSAGE)
    {
        Cs->hwndParent = hWndParent = UserHMGetHandle(pti->rpdesk->spwndMessage);
    }
    else if (Cs->hwndParent)
    {
        if ((Cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
            hWndOwner = Cs->hwndParent;
        else
            hWndParent = Cs->hwndParent;
    }
    else if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
    {
         ERR("Cannot create a child window (%wZ) without a parent\n", ClassName);
         EngSetLastError(ERROR_TLW_WITH_WSCHILD);
         goto cleanup;  /* WS_CHILD needs a parent, but WS_POPUP doesn't */
    }
    else if (Cs->lpszClass != (LPCWSTR)MAKEINTATOM(gpsi->atomSysClass[ICLS_DESKTOP]) &&
             (IS_INTRESOURCE(Cs->lpszClass) ||
              Cs->lpszClass != (LPCWSTR)MAKEINTATOM(gpsi->atomSysClass[ICLS_HWNDMESSAGE]) ||
              _wcsicmp(Cs->lpszClass, L"Message") != 0))
    {
        if (pti->ppi->dwLayout & LAYOUT_RTL)
        {
            Cs->dwExStyle |= WS_EX_LAYOUTRTL;
        }
    }
 
    ParentWindow = hWndParent ? UserGetWindowObject(hWndParent): NULL;
    OwnerWindow = hWndOwner ? UserGetWindowObject(hWndOwner): NULL;
 
    if (hWndParent && !ParentWindow)
    {
        ERR("Got invalid parent window handle for %wZ\n", ClassName);
        goto cleanup;
    }
    else if (hWndOwner && !OwnerWindow)
    {
        ERR("Got invalid owner window handle for %wZ\n", ClassName);
        ParentWindow = NULL;
        goto cleanup;
    }
 
    if(OwnerWindow)
    {
       if (IntIsDesktopWindow(OwnerWindow)) OwnerWindow = NULL;
       else if (ParentWindow && !IntIsDesktopWindow(ParentWindow))
       {
          ERR("an owned window must be created as top-level\n");
          EngSetLastError( STATUS_ACCESS_DENIED );
          goto cleanup;
       }
       else /* owner must be a top-level window */
       {
          while ((OwnerWindow->style & (WS_POPUP|WS_CHILD)) == WS_CHILD && !IntIsDesktopWindow(OwnerWindow->spwndParent))
                 OwnerWindow = OwnerWindow->spwndParent;
       }
    }
 
   /* Fix the position and the size of the window */
   if (ParentWindow)
   {
       UserRefObjectCo(ParentWindow, &ParentRef);
       IntFixWindowCoordinates(Cs, ParentWindow, &dwShowMode);
   }
 
   /* Allocate and initialize the new window */
   Window = IntCreateWindow(Cs,
                            WindowName,
                            Class,
                            ParentWindow,
                            OwnerWindow,
                            acbiBuffer,
                            NULL,
                            dwVer );
   if(!Window)
   {
       ERR("IntCreateWindow(%wZ) failed\n", ClassName);
       goto cleanup;
   }
 
   hWnd = UserHMGetHandle(Window);
   hwndInsertAfter = HWND_TOP;
 
   UserRefObjectCo(Window, &Ref);
   UserDereferenceObject(Window);
   ObDereferenceObject(WinSta);
 
   /* NCCREATE, WM_NCCALCSIZE and Hooks need the original values */
   Cs->lpszName = (LPCWSTR) WindowName;
   Cs->lpszClass = (LPCWSTR) ClassName;
 
   if ( ISITHOOKED(WH_CBT) ||  (pti->rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)) )
   {
      // Allocate the calling structures Justin Case this goes Global.
      pCsw = ExAllocatePoolWithTag(NonPagedPool, sizeof(CREATESTRUCTW), TAG_HOOK);
      pCbtCreate = ExAllocatePoolWithTag(NonPagedPool, sizeof(CBT_CREATEWNDW), TAG_HOOK);
      if (!pCsw || !pCbtCreate)
      {
         ERR("UserHeapAlloc() failed!\n");
         goto cleanup;
      }
 
      if (!IntMsgCreateStructW( Window, pCsw, Cs, &pszClass, &pszName ) )
      {
          ERR("IntMsgCreateStructW() failed!\n");
          goto cleanup;
      }
 
      pCbtCreate->lpcs = pCsw;
      pCbtCreate->hwndInsertAfter = hwndInsertAfter;
 
      Result = co_HOOK_CallHooks(WH_CBT, HCBT_CREATEWND, (WPARAM) hWnd, (LPARAM) pCbtCreate);
      if (Result != 0)
      {
         ERR("WH_CBT HCBT_CREATEWND hook failed! 0x%x\n", Result);
         goto cleanup;
      }
      // Write back changes.
      Cs->cx = pCsw->cx;
      Cs->cy = pCsw->cy;
      Cs->x = pCsw->x;
      Cs->y = pCsw->y;
      hwndInsertAfter = pCbtCreate->hwndInsertAfter;
   }
 
   if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
   {
      if (ParentWindow != co_GetDesktopWindow(Window))
      {
         Cs->x += ParentWindow->rcClient.left;
         Cs->y += ParentWindow->rcClient.top;
      }
   }
 
   /* Send the WM_GETMINMAXINFO message */
   Size.cx = Cs->cx;
   Size.cy = Cs->cy;
 
   if ((Cs->style & WS_THICKFRAME) || !(Cs->style & (WS_POPUP | WS_CHILD)))
   {
      co_WinPosGetMinMaxInfo(Window, &MaxSize, &MaxPos, &MinTrack, &MaxTrack);
      if (Size.cx > MaxTrack.x) Size.cx = MaxTrack.x;
      if (Size.cy > MaxTrack.y) Size.cy = MaxTrack.y;
      if (Size.cx < MinTrack.x) Size.cx = MinTrack.x;
      if (Size.cy < MinTrack.y) Size.cy = MinTrack.y;
   }
 
   Window->rcWindow.left = Cs->x;
   Window->rcWindow.top = Cs->y;
   Window->rcWindow.right = Cs->x + Size.cx;
   Window->rcWindow.bottom = Cs->y + Size.cy;
 /*
   if (0 != (Window->style & WS_CHILD) && ParentWindow)
   {
      ERR("co_UserCreateWindowEx(): Offset rcWindow\n");
      RECTL_vOffsetRect(&Window->rcWindow,
                        ParentWindow->rcClient.left,
                        ParentWindow->rcClient.top);
   }
 */
   /* correct child window coordinates if mirroring on parent is enabled */
   if (ParentWindow != NULL)
   {
      if ( ((Cs->style & WS_CHILD) == WS_CHILD) &&
          ((ParentWindow->ExStyle & WS_EX_LAYOUTRTL) ==  WS_EX_LAYOUTRTL))
      {
          Window->rcWindow.right = ParentWindow->rcClient.right - (Window->rcWindow.left - ParentWindow->rcClient.left);
          Window->rcWindow.left = Window->rcWindow.right - Size.cx;
      }
   }
 
   Window->rcClient = Window->rcWindow;
 
   if (Window->spwndNext || Window->spwndPrev)
   {
      ERR("Window 0x%p has been linked too early!\n", Window);
   }
 
   if (!(Window->state2 & WNDS2_WIN31COMPAT))
   {
      if (Class->style & CS_PARENTDC && !(ParentWindow->style & WS_CLIPCHILDREN))
         Window->style &= ~(WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
   }
 
   if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
   {
      if ( !IntIsTopLevelWindow(Window) )
      {
         if (pti != ParentWindow->head.pti)
         {
            //ERR("CreateWindow Parent in.\n");
            UserAttachThreadInput(pti, ParentWindow->head.pti, TRUE);
         }
      }
   }
 
   /* Send the NCCREATE message */
   Result = co_IntSendMessage(UserHMGetHandle(Window), WM_NCCREATE, 0, (LPARAM) Cs);
   if (!Result)
   {
      ERR("co_UserCreateWindowEx(%wZ): NCCREATE message failed\n", ClassName);
      goto cleanup;
   }
 
   /* Link the window */
   if (ParentWindow != NULL)
   {
      /* Link the window into the siblings list */
      if ((Cs->style & (WS_CHILD | WS_MAXIMIZE)) == WS_CHILD)
          IntLinkHwnd(Window, HWND_BOTTOM);
      else
          IntLinkHwnd(Window, hwndInsertAfter);
   }
 
   /* Create the IME window for pWnd */
   if (IS_IMM_MODE() && !pti->spwndDefaultIme && IntWantImeWindow(Window))
   {
      PWND pwndDefaultIme = co_IntCreateDefaultImeWindow(Window, Window->hModule);
      UserAssignmentLock((PVOID*)&pti->spwndDefaultIme, pwndDefaultIme);
 
      if (pwndDefaultIme)
      {
         HWND hImeWnd;
         USER_REFERENCE_ENTRY Ref;
         UserRefObjectCo(pwndDefaultIme, &Ref);
 
         hImeWnd = UserHMGetHandle(pwndDefaultIme);
 
         co_IntSendMessage(hImeWnd, WM_IME_SYSTEM, IMS_LOADTHREADLAYOUT, 0);
 
         if (pti->pClientInfo->CI_flags & CI_IMMACTIVATE)
         {
            HKL hKL = pti->KeyboardLayout->hkl;
            co_IntSendMessage(hImeWnd, WM_IME_SYSTEM, IMS_ACTIVATELAYOUT, (LPARAM)hKL);
            pti->pClientInfo->CI_flags &= ~CI_IMMACTIVATE;
         }
 
         UserDerefObjectCo(pwndDefaultIme);
      }
   }
 
   /* Send the WM_NCCALCSIZE message */
   {
  // RECT rc;
   MaxPos.x = Window->rcWindow.left;
   MaxPos.y = Window->rcWindow.top;
 
   Result = co_WinPosGetNonClientSize(Window, &Window->rcWindow, &Window->rcClient);
   //rc = Window->rcWindow;
   //Result = co_IntSendMessageNoWait(UserHMGetHandle(Window), WM_NCCALCSIZE, FALSE, (LPARAM)&rc);
   //Window->rcClient = rc;
 
   RECTL_vOffsetRect(&Window->rcWindow, MaxPos.x - Window->rcWindow.left,
                                     MaxPos.y - Window->rcWindow.top);
   }
 
   /* Send the WM_CREATE message. */
   Result = co_IntSendMessage(UserHMGetHandle(Window), WM_CREATE, 0, (LPARAM) Cs);
   if (Result == (LRESULT)-1)
   {
      ERR("co_UserCreateWindowEx(%wZ): WM_CREATE message failed\n", ClassName);
      goto cleanup;
   }
 
   /* Send the EVENT_OBJECT_CREATE event */
   IntNotifyWinEvent(EVENT_OBJECT_CREATE, Window, OBJID_WINDOW, CHILDID_SELF, 0);
 
   /* By setting the flag below it can be examined to determine if the window
      was created successfully and a valid pwnd was passed back to caller since
      from here the function has to succeed. */
   Window->state2 |= WNDS2_WMCREATEMSGPROCESSED;
 
   /* Send the WM_SIZE and WM_MOVE messages. */
   if (!(Window->state & WNDS_SENDSIZEMOVEMSGS))
   {
        co_WinPosSendSizeMove(Window);
   }
 
   /* Show or maybe minimize or maximize the window. */
 
   style = IntSetStyle( Window, 0, WS_MAXIMIZE | WS_MINIMIZE );
   if (style & (WS_MINIMIZE | WS_MAXIMIZE))
   {
      RECTL NewPos;
      UINT SwFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
 
      SwFlag = co_WinPosMinMaximize(Window, SwFlag, &NewPos);
      SwFlag |= SWP_NOZORDER|SWP_FRAMECHANGED; /* Frame always gets changed */
      if (!(style & WS_VISIBLE) || (style & WS_CHILD) || UserGetActiveWindow() ||
          (Window->ExStyle & WS_EX_NOACTIVATE))
      {
         SwFlag |= SWP_NOACTIVATE;
      }
      co_WinPosSetWindowPos(Window, 0, NewPos.left, NewPos.top,
                            NewPos.right, NewPos.bottom, SwFlag);
   }
 
   /* Send the WM_PARENTNOTIFY message */
   IntSendParentNotify(Window, WM_CREATE);
 
   /* Notify the shell that a new window was created */
   if (Window->spwndOwner == NULL ||
       !(Window->spwndOwner->style & WS_VISIBLE) ||
       (Window->spwndOwner->ExStyle & WS_EX_TOOLWINDOW))
   {
      if (UserIsDesktopWindow(Window->spwndParent) &&
          (Window->style & WS_VISIBLE) &&
          (!(Window->ExStyle & WS_EX_TOOLWINDOW) ||
           (Window->ExStyle & WS_EX_APPWINDOW)))
      {
         co_IntShellHookNotify(HSHELL_WINDOWCREATED, (WPARAM)hWnd, 0);
      }
   }
 
   /* Initialize and show the window's scrollbars */
   if (Window->style & WS_VSCROLL)
   {
      co_UserShowScrollBar(Window, SB_VERT, FALSE, TRUE);
   }
   if (Window->style & WS_HSCROLL)
   {
      co_UserShowScrollBar(Window, SB_HORZ, TRUE, FALSE);
   }
 
   /* Show the new window */
   if (Cs->style & WS_VISIBLE)
   {
      if (Window->style & WS_MAXIMIZE)
         dwShowMode = SW_SHOW;
      else if (Window->style & WS_MINIMIZE)
         dwShowMode = SW_SHOWMINIMIZED;
 
      co_WinPosShowWindow(Window, dwShowMode);
 
      if (Window->ExStyle & WS_EX_MDICHILD)
      {
          ASSERT(ParentWindow);
          if(!ParentWindow)
              goto cleanup;
        co_IntSendMessage(UserHMGetHandle(ParentWindow), WM_MDIREFRESHMENU, 0, 0);
        /* ShowWindow won't activate child windows */
        co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
      }
   }
 
   if (Class->atomClassName == gaGuiConsoleWndClass)
   {
       /* Count only console windows manually */
       co_IntUserManualGuiCheck(TRUE);
   }
 
   /* Set the hotkey */
   if (!(Window->style & (WS_POPUP | WS_CHILD)) || (Window->ExStyle & WS_EX_APPWINDOW))
   {
       if (pti->ppi->dwHotkey)
       {
          co_IntSendMessage(UserHMGetHandle(Window), WM_SETHOTKEY, pti->ppi->dwHotkey, 0);
          pti->ppi->dwHotkey = 0; /* Only the first suitable window gets the hotkey */
       }
   }
 
   TRACE("co_UserCreateWindowEx(%wZ): Created window %p\n", ClassName, hWnd);
   ret = Window;
 
cleanup:
   if (!ret)
   {
       TRACE("co_UserCreateWindowEx(): Error Created window!\n");
       /* If the window was created, the class will be dereferenced by co_UserDestroyWindow */
       if (Window)
            co_UserDestroyWindow(Window);
       else if (Class)
           IntDereferenceClass(Class, pti->pDeskInfo, pti->ppi);
   }
 
   if (pCsw) ExFreePoolWithTag(pCsw, TAG_HOOK);
   if (pCbtCreate) ExFreePoolWithTag(pCbtCreate, TAG_HOOK);
   if (pszName) UserHeapFree(pszName);
   if (pszClass) UserHeapFree(pszClass);
 
   if (Window)
   {
      UserDerefObjectCo(Window);
   }
   if (ParentWindow) UserDerefObjectCo(ParentWindow);
 
   // See CORE-13717, not setting error on success.
   if (ret)
      EngSetLastError(ERROR_SUCCESS);
 
   return ret;
}

Referenced by co_IntCreateDefaultImeWindow(), MENU_InitPopup(), and NtUserCreateWindowEx().

co_UserFreeWindow()

LRESULT co_UserFreeWindow	(	PWND	Window,
		PPROCESSINFO	ProcessData,
		PTHREADINFO	ThreadData,
		BOOLEAN	SendMessages
	)

Definition at line 575 of file window.c.

{
   HWND *Children;
   HWND *ChildHandle;
   PWND Child;
   PMENU Menu;
   BOOLEAN BelongsToThreadData;
   USER_REFERENCE_ENTRY Ref;
 
   ASSERT(Window);
 
   if(Window->state2 & WNDS2_INDESTROY)
   {
      TRACE("Tried to call co_UserFreeWindow() twice\n");
      return 0;
   }
   Window->state2 |= WNDS2_INDESTROY;
   Window->style &= ~WS_VISIBLE;
   Window->head.pti->cVisWindows--;
 
   /* remove the window already at this point from the thread window list so we
      don't get into trouble when destroying the thread windows while we're still
      in co_UserFreeWindow() */
   if (!IsListEmpty(&Window->ThreadListEntry))
       RemoveEntryList(&Window->ThreadListEntry);
 
   BelongsToThreadData = IntWndBelongsToThread(Window, ThreadData);
 
   IntDeRegisterShellHookWindow(UserHMGetHandle(Window));
 
   /* free child windows */
   Children = IntWinListChildren(Window);
   if (Children)
   {
      for (ChildHandle = Children; *ChildHandle; ++ChildHandle)
      {
         if ((Child = IntGetWindowObject(*ChildHandle)))
         {
            if (!IntWndBelongsToThread(Child, ThreadData))
            {
               /* send WM_DESTROY messages to windows not belonging to the same thread */
               co_IntSendMessage( UserHMGetHandle(Child), WM_ASYNC_DESTROYWINDOW, 0, 0 );
            }
            else
               co_UserFreeWindow(Child, ProcessData, ThreadData, SendMessages);
 
            UserDereferenceObject(Child);
         }
      }
      ExFreePoolWithTag(Children, USERTAG_WINDOWLIST);
   }
 
   if (SendMessages)
   {
      /*
       * Clear the update region to make sure no WM_PAINT messages will be
       * generated for this window while processing the WM_NCDESTROY.
       */
      co_UserRedrawWindow(Window, NULL, 0,
                          RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE |
                          RDW_NOINTERNALPAINT | RDW_NOCHILDREN);
      if (BelongsToThreadData)
         co_IntSendMessage(UserHMGetHandle(Window), WM_NCDESTROY, 0, 0);
   }
 
   UserClipboardFreeWindow(Window);
 
   DestroyTimersForWindow(ThreadData, Window);
 
   /* Unregister hot keys */
   UnregisterWindowHotKeys(Window);
 
   /* flush the message queue */
   MsqRemoveWindowMessagesFromQueue(Window);
 
   /* from now on no messages can be sent to this window anymore */
   Window->state |= WNDS_DESTROYED;
   Window->fnid |= FNID_FREED;
 
   /* don't remove the WINDOWSTATUS_DESTROYING bit */
 
   /* reset shell window handles */
   if (ThreadData->rpdesk)
   {
      if (UserHMGetHandle(Window) == ThreadData->rpdesk->rpwinstaParent->ShellWindow)
         ThreadData->rpdesk->rpwinstaParent->ShellWindow = NULL;
 
      if (UserHMGetHandle(Window) == ThreadData->rpdesk->rpwinstaParent->ShellListView)
         ThreadData->rpdesk->rpwinstaParent->ShellListView = NULL;
   }
 
   if (ThreadData->spwndDefaultIme &&
       ThreadData->spwndDefaultIme->spwndOwner == Window)
   {
      WndSetOwner(ThreadData->spwndDefaultIme, NULL);
   }
 
   if (IS_IMM_MODE() && Window == ThreadData->spwndDefaultIme)
   {
      UserAssignmentUnlock((PVOID*)&(ThreadData->spwndDefaultIme));
   }
 
   /* Fixes dialog test_focus breakage due to r66237. */
   if (ThreadData->MessageQueue->spwndFocus == Window)
      ThreadData->MessageQueue->spwndFocus = NULL;
 
   if (ThreadData->MessageQueue->spwndActive == Window)
      ThreadData->MessageQueue->spwndActive = NULL;
 
   if (ThreadData->MessageQueue->spwndCapture == Window)
   {
      IntReleaseCapture();
   }
 
   if ( Window->hrgnUpdate != NULL || Window->state & WNDS_INTERNALPAINT )
   {
      MsqDecPaintCountQueue(Window->head.pti);
      if (Window->hrgnUpdate > HRGN_WINDOW && GreIsHandleValid(Window->hrgnUpdate))
      {
         IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
         GreDeleteObject(Window->hrgnUpdate);
      }
      Window->hrgnUpdate = NULL;
      Window->state &= ~WNDS_INTERNALPAINT;
   }
 
   if (Window->state & (WNDS_SENDERASEBACKGROUND|WNDS_SENDNCPAINT))
   {
      Window->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_SENDNCPAINT);
   }
 
   if ( ((Window->style & (WS_CHILD|WS_POPUP)) != WS_CHILD) &&
        Window->IDMenu &&
        (Menu = UserGetMenuObject((HMENU)Window->IDMenu)))
   {
      TRACE("UFW: IDMenu %p\n",Window->IDMenu);
      IntDestroyMenuObject(Menu, TRUE);
      Window->IDMenu = 0;
   }
 
   if (Window->SystemMenu
        && (Menu = UserGetMenuObject(Window->SystemMenu)))
   {
      IntDestroyMenuObject(Menu, TRUE);
      Window->SystemMenu = (HMENU)0;
   }
 
   DceFreeWindowDCE(Window);    /* Always do this to catch orphaned DCs */
 
   IntUnlinkWindow(Window);
 
   if (Window->PropListItems)
   {
      UserRemoveWindowProps(Window);
      TRACE("Window->PropListItems %lu\n",Window->PropListItems);
      ASSERT(Window->PropListItems==0);
   }
 
   /* Kill any reference to linked windows. Prev & Next are taken care of in IntUnlinkWindow */
   WndSetOwner(Window, NULL);
   WndSetParent(Window, NULL);
   WndSetChild(Window, NULL);
   WndSetLastActive(Window, NULL);
 
   UserRefObjectCo(Window, &Ref);
   UserMarkObjectDestroy(Window);
 
   IntDestroyScrollBars(Window);
 
   if (Window->pcls->atomClassName == gaGuiConsoleWndClass)
   {
       /* Count only console windows manually */
       co_IntUserManualGuiCheck(FALSE);
   }
 
   /* dereference the class */
   NT_ASSERT(Window->head.pti != NULL);
   IntDereferenceClass(Window->pcls,
                       Window->head.pti->pDeskInfo,
                       Window->head.pti->ppi);
   Window->pcls = NULL;
 
   if (Window->hrgnClip)
   {
      IntGdiSetRegionOwner(Window->hrgnClip, GDI_OBJ_HMGR_POWNED);
      GreDeleteObject(Window->hrgnClip);
      Window->hrgnClip = NULL;
   }
   Window->head.pti->cWindows--;
 
//   ASSERT(Window != NULL);
   UserFreeWindowInfo(Window->head.pti, Window);
 
   UserDerefObjectCo(Window);
   UserDeleteObject(UserHMGetHandle(Window), TYPE_WINDOW);
 
   return 0;
}

Referenced by co_UserDestroyWindow(), co_UserFreeWindow(), and handle_internal_message().

co_UserSetWindowLong()

LONG FASTCALL co_UserSetWindowLong	(	HWND	hWnd,
		DWORD	Index,
		LONG	NewValue,
		BOOL	Ansi
	)

Definition at line 4025 of file window.c.

{
    return (LONG)co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG), FALSE);
}

Referenced by DesktopWindowProc(), and NtUserSetWindowWord().

co_UserSetWindowLongPtr()

LONG_PTR FASTCALL co_UserSetWindowLongPtr	(	HWND	hWnd,
		DWORD	Index,
		LONG_PTR	NewValue,
		BOOL	Ansi
	)

Definition at line 4031 of file window.c.

{
    return co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG_PTR), FALSE);
}

GetNCHitEx()

DWORD FASTCALL GetNCHitEx	(	PWND	pWnd,
		POINT	pt
	)

Definition at line 1994 of file nonclient.c.

{
   RECT rcWindow, rcClient;
   DWORD Style, ExStyle;
 
   if (!pWnd) return HTNOWHERE;
 
   if (UserIsDesktopWindow(pWnd))
   {
      rcClient.left = rcClient.top = rcWindow.left = rcWindow.top = 0;
      rcWindow.right  = UserGetSystemMetrics(SM_CXSCREEN);
      rcWindow.bottom = UserGetSystemMetrics(SM_CYSCREEN);
      rcClient.right  = UserGetSystemMetrics(SM_CXSCREEN);
      rcClient.bottom = UserGetSystemMetrics(SM_CYSCREEN);
   }
   else
   {
      rcClient = pWnd->rcClient;
      rcWindow = pWnd->rcWindow;
   }
 
   if (!RECTL_bPointInRect(&rcWindow, pt.x, pt.y)) return HTNOWHERE;
 
   Style = pWnd->style;
   ExStyle = pWnd->ExStyle;
 
   if (Style & WS_MINIMIZE) return HTCAPTION;
 
   if (RECTL_bPointInRect( &rcClient,  pt.x, pt.y )) return HTCLIENT;
 
   /* Check borders */
   if (HAS_THICKFRAME( Style, ExStyle ))
   {
      RECTL_vInflateRect(&rcWindow, -UserGetSystemMetrics(SM_CXFRAME), -UserGetSystemMetrics(SM_CYFRAME) );
      if (!RECTL_bPointInRect(&rcWindow, pt.x, pt.y ))
      {
            /* Check top sizing border */
            if (pt.y < rcWindow.top)
            {
                if (pt.x < rcWindow.left+UserGetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
                if (pt.x >= rcWindow.right-UserGetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
                return HTTOP;
            }
            /* Check bottom sizing border */
            if (pt.y >= rcWindow.bottom)
            {
                if (pt.x < rcWindow.left+UserGetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
                if (pt.x >= rcWindow.right-UserGetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
                return HTBOTTOM;
            }
            /* Check left sizing border */
            if (pt.x < rcWindow.left)
            {
                if (pt.y < rcWindow.top+UserGetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
                if (pt.y >= rcWindow.bottom-UserGetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
                return HTLEFT;
            }
            /* Check right sizing border */
            if (pt.x >= rcWindow.right)
            {
                if (pt.y < rcWindow.top+UserGetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
                if (pt.y >= rcWindow.bottom-UserGetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
                return HTRIGHT;
            }
        }
    }
    else  /* No thick frame */
    {
        if (HAS_DLGFRAME( Style, ExStyle ))
            RECTL_vInflateRect(&rcWindow, -UserGetSystemMetrics(SM_CXDLGFRAME), -UserGetSystemMetrics(SM_CYDLGFRAME));
        else if (HAS_THINFRAME( Style, ExStyle ))
            RECTL_vInflateRect(&rcWindow, -UserGetSystemMetrics(SM_CXBORDER), -UserGetSystemMetrics(SM_CYBORDER));
        else if (HAS_CLIENTFRAME( Style, ExStyle ))
            RECTL_vInflateRect(&rcWindow, -UserGetSystemMetrics(SM_CXEDGE), -UserGetSystemMetrics(SM_CYEDGE));
        if (!RECTL_bPointInRect( &rcWindow, pt.x, pt.y  )) return HTBORDER;
    }
 
    /* Check caption */
 
    if ((Style & WS_CAPTION) == WS_CAPTION)
    {
        if (ExStyle & WS_EX_TOOLWINDOW)
            rcWindow.top += UserGetSystemMetrics(SM_CYSMCAPTION) - 1;
        else
            rcWindow.top += UserGetSystemMetrics(SM_CYCAPTION) - 1;
        if (!RECTL_bPointInRect( &rcWindow, pt.x, pt.y ))
        {
            BOOL min_or_max_box = (Style & WS_SYSMENU) && (Style & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX));
            if (ExStyle & WS_EX_LAYOUTRTL)
            {
                /* Check system menu */
                if ((Style & WS_SYSMENU) && !(ExStyle & WS_EX_TOOLWINDOW) && NC_IconForWindow(pWnd))
                {
                    rcWindow.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
                    if (pt.x > rcWindow.right) return HTSYSMENU;
                }
 
                /* Check close button */
                if (Style & WS_SYSMENU)
                {
                    rcWindow.left += UserGetSystemMetrics(SM_CYCAPTION);
                    if (pt.x < rcWindow.left) return HTCLOSE;
                }
 
                /* Check maximize box */
                /* In Win95 there is automatically a Maximize button when there is a minimize one */
                if (min_or_max_box && !(ExStyle & WS_EX_TOOLWINDOW))
                {
                    rcWindow.left += UserGetSystemMetrics(SM_CXSIZE);
                    if (pt.x < rcWindow.left) return HTMAXBUTTON;
                }
 
                /* Check minimize box */
                if (min_or_max_box && !(ExStyle & WS_EX_TOOLWINDOW))
                {
                    rcWindow.left += UserGetSystemMetrics(SM_CXSIZE);
                    if (pt.x < rcWindow.left) return HTMINBUTTON;
                }
            }
            else
            {
                /* Check system menu */
                if ((Style & WS_SYSMENU) && !(ExStyle & WS_EX_TOOLWINDOW) && NC_IconForWindow(pWnd))
                {
                    rcWindow.left += UserGetSystemMetrics(SM_CYCAPTION) - 1;
                    if (pt.x < rcWindow.left) return HTSYSMENU;
                }
 
                /* Check close button */
                if (Style & WS_SYSMENU)
                {
                    rcWindow.right -= UserGetSystemMetrics(SM_CYCAPTION);
                    if (pt.x > rcWindow.right) return HTCLOSE;
                }
 
                /* Check maximize box */
                /* In Win95 there is automatically a Maximize button when there is a minimize one */
                if (min_or_max_box && !(ExStyle & WS_EX_TOOLWINDOW))
                {
                    rcWindow.right -= UserGetSystemMetrics(SM_CXSIZE);
                    if (pt.x > rcWindow.right) return HTMAXBUTTON;
                }
 
                /* Check minimize box */
                if (min_or_max_box && !(ExStyle & WS_EX_TOOLWINDOW))
                {
                    rcWindow.right -= UserGetSystemMetrics(SM_CXSIZE);
                    if (pt.x > rcWindow.right) return HTMINBUTTON;
                }
            }
            return HTCAPTION;
        }
    }
 
      /* Check menu bar */
 
    if (HAS_MENU( pWnd, Style ) && (pt.y < rcClient.top) &&
        (pt.x >= rcClient.left) && (pt.x < rcClient.right))
        return HTMENU;
 
      /* Check vertical scroll bar */
 
    if (ExStyle & WS_EX_LAYOUTRTL) ExStyle ^= WS_EX_LEFTSCROLLBAR;
    if (Style & WS_VSCROLL)
    {
        if((ExStyle & WS_EX_LEFTSCROLLBAR) != 0)
            rcClient.left -= UserGetSystemMetrics(SM_CXVSCROLL);
        else
            rcClient.right += UserGetSystemMetrics(SM_CXVSCROLL);
        if (RECTL_bPointInRect( &rcClient, pt.x, pt.y )) return HTVSCROLL;
    }
 
      /* Check horizontal scroll bar */
 
    if (Style & WS_HSCROLL)
    {
        rcClient.bottom += UserGetSystemMetrics(SM_CYHSCROLL);
        if (RECTL_bPointInRect( &rcClient, pt.x, pt.y ))
        {
            /* Check size box */
            if ((Style & WS_VSCROLL) &&
                ((((ExStyle & WS_EX_LEFTSCROLLBAR) != 0) && (pt.x <= rcClient.left + UserGetSystemMetrics(SM_CXVSCROLL))) ||
                (((ExStyle & WS_EX_LEFTSCROLLBAR) == 0) && (pt.x >= rcClient.right - UserGetSystemMetrics(SM_CXVSCROLL)))))
                return HTSIZE;
            return HTHSCROLL;
        }
    }
 
    /* Has to return HTNOWHERE if nothing was found
       Could happen when a window has a customized non client area */
    return HTNOWHERE;
}

Referenced by DefWndStartSizeMove(), IntDefWindowProc(), MENU_PtMenu(), MENU_TrackMenu(), NC_DoButton(), and NC_HandleNCRButtonDown().

IntBroadcastImeShowStatusChange()

BOOL FASTCALL IntBroadcastImeShowStatusChange	(	_In_ PWND	pImeWnd,
		_In_ BOOL	bShow
	)

Definition at line 2514 of file ime.c.

{
    if (gfIMEShowStatus == bShow || !IS_IMM_MODE())
        return TRUE;
 
    gfIMEShowStatus = bShow;
    IntNotifyImeShowStatus(pImeWnd);
    return TRUE;
}

Referenced by NtUserCallHwndParamLock().

IntBuildHwndList()

PWINDOWLIST FASTCALL IntBuildHwndList	(	PWND	pwnd,
		DWORD	dwFlags,
		PTHREADINFO	pti
	)

Definition at line 1422 of file window.c.

{
    PWINDOWLIST pwl;
    DWORD cbWL;
 
    if (gpwlCache)
    {
        pwl = gpwlCache;
        gpwlCache = NULL;
    }
    else
    {
#define INITIAL_COUNT 32
        cbWL = sizeof(WINDOWLIST) + (INITIAL_COUNT - 1) * sizeof(HWND);
        pwl = ExAllocatePoolWithTag(PagedPool, cbWL, USERTAG_WINDOWLIST);
        if (!pwl)
            return NULL;
 
        pwl->phwndEnd = &pwl->ahwnd[INITIAL_COUNT];
#undef INITIAL_COUNT
    }
 
    pwl->pti = pti;
    pwl->phwndLast = pwl->ahwnd;
    pwl = IntPopulateHwndList(pwl, pwnd, dwFlags);
    if (WL_IS_BAD(pwl))
    {
        ExFreePoolWithTag(pwl, USERTAG_WINDOWLIST);
        return NULL;
    }
 
    *(pwl->phwndLast) = HWND_TERMINATOR;
 
    if (dwFlags & 0x8)
    {
        // TODO:
    }
 
    pwl->pti = GetW32ThreadInfo();
    pwl->pNextList = gpwlList;
    gpwlList = pwl;
 
    return pwl;
}

Referenced by IntAssociateInputContextEx(), IntCheckImeShowStatus(), IntDestroyInputContext(), and IntImeWindowPosChanged().

IntCheckImeShowStatusInThread()

VOID FASTCALL IntCheckImeShowStatusInThread

(

_In_ PWND

pImeWnd

)

Definition at line 2527 of file ime.c.

{
    if (IS_IMM_MODE() && !(pImeWnd->state2 & WNDS2_INDESTROY))
        IntCheckImeShowStatus(pImeWnd, pImeWnd->head.pti);
}

Referenced by NtUserCallHwndLock().

IntCreateWindow()

PWND FASTCALL IntCreateWindow	(	CREATESTRUCTW *	Cs,
		PLARGE_STRING	WindowName,
		PCLS	Class,
		PWND	ParentWindow,
		PWND	OwnerWindow,
		PVOID	acbiBuffer,
		PDESKTOP	pdeskCreated,
		DWORD	dwVer
	)

Definition at line 1805 of file window.c.

{
   PWND pWnd = NULL;
   HWND hWnd;
   PTHREADINFO pti;
   BOOL MenuChanged;
   BOOL bUnicodeWindow;
   PCALLPROCDATA pcpd;
 
   pti = pdeskCreated ? gptiDesktopThread : GetW32ThreadInfo();
 
   if (!(Cs->dwExStyle & WS_EX_LAYOUTRTL))
   {      // Need both here for wine win.c test_CreateWindow.
      //if (Cs->hwndParent && ParentWindow)
      if (ParentWindow) // It breaks more tests..... WIP.
      {
         if ( (Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD &&
              ParentWindow->ExStyle & WS_EX_LAYOUTRTL &&
             !(ParentWindow->ExStyle & WS_EX_NOINHERITLAYOUT) )
            Cs->dwExStyle |= WS_EX_LAYOUTRTL;
      }
      else
      { /*
         * Note from MSDN <https://learn.microsoft.com/en-us/previous-versions/aa913269(v=msdn.10)>:
         *
         * Dialog boxes and message boxes do not inherit layout, so you must
         * set the layout explicitly.
         */
         if ( Class->fnid != FNID_DIALOG )
         {
            if (pti->ppi->dwLayout & LAYOUT_RTL)
            {
               Cs->dwExStyle |= WS_EX_LAYOUTRTL;
            }
         }
      }
   }
 
   /* Automatically add WS_EX_WINDOWEDGE */
   if ((Cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
         ((!(Cs->dwExStyle & WS_EX_STATICEDGE)) &&
         (Cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
      Cs->dwExStyle |= WS_EX_WINDOWEDGE;
   else
      Cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
 
   /* Is it a unicode window? */
   bUnicodeWindow =!(Cs->dwExStyle & WS_EX_SETANSICREATOR);
   Cs->dwExStyle &= ~WS_EX_SETANSICREATOR;
 
   /* Allocate the new window */
   pWnd = (PWND) UserCreateObject( gHandleTable,
                                   pdeskCreated ? pdeskCreated : pti->rpdesk,
                                   pti,
                                  (PHANDLE)&hWnd,
                                   TYPE_WINDOW,
                                   sizeof(WND) + Class->cbwndExtra);
 
   if (!pWnd)
   {
      goto AllocError;
   }
 
   TRACE("Created window object with handle %p\n", hWnd);
 
   /*
    * Fill out the structure describing it.
    */
   /* Remember, pWnd->head is setup in object.c ... */
   WndSetParent(pWnd, ParentWindow);
   WndSetOwner(pWnd, OwnerWindow);
   pWnd->fnid = 0;
   WndSetLastActive(pWnd, pWnd);
   // Ramp up compatible version sets.
   if ( dwVer >= WINVER_WIN31 )
   {
       pWnd->state2 |= WNDS2_WIN31COMPAT;
       if ( dwVer >= WINVER_WINNT4 )
       {
           pWnd->state2 |= WNDS2_WIN40COMPAT;
           if ( dwVer >= WINVER_WIN2K )
           {
               pWnd->state2 |= WNDS2_WIN50COMPAT;
           }
       }
   }
   pWnd->pcls = Class;
   pWnd->hModule = Cs->hInstance;
   pWnd->style = Cs->style & ~WS_VISIBLE;
   pWnd->ExStyle = Cs->dwExStyle;
   pWnd->cbwndExtra = pWnd->pcls->cbwndExtra;
   pWnd->pActCtx = acbiBuffer;
 
   if (pti->spDefaultImc && Class->atomClassName != gpsi->atomSysClass[ICLS_BUTTON])
      pWnd->hImc = UserHMGetHandle(pti->spDefaultImc);
 
   pWnd->InternalPos.MaxPos.x  = pWnd->InternalPos.MaxPos.y  = -1;
   pWnd->InternalPos.IconPos.x = pWnd->InternalPos.IconPos.y = -1;
 
   if (pWnd->spwndParent != NULL && Cs->hwndParent != 0)
   {
       pWnd->HideFocus = pWnd->spwndParent->HideFocus;
       pWnd->HideAccel = pWnd->spwndParent->HideAccel;
   }
 
   InitializeListHead(&pWnd->ThreadListEntry);
   pWnd->head.pti->cWindows++;
 
   if (Class->spicn && !Class->spicnSm)
   {
       HICON IconSmHandle = NULL;
       if((Class->spicn->CURSORF_flags & (CURSORF_LRSHARED | CURSORF_FROMRESOURCE))
               == (CURSORF_LRSHARED | CURSORF_FROMRESOURCE))
       {
           IconSmHandle = co_IntCopyImage(
               UserHMGetHandle(Class->spicn),
               IMAGE_ICON,
               UserGetSystemMetrics( SM_CXSMICON ),
               UserGetSystemMetrics( SM_CYSMICON ),
               LR_COPYFROMRESOURCE);
       }
       if (!IconSmHandle)
       {
           /* Retry without copying from resource */
           IconSmHandle = co_IntCopyImage(
               UserHMGetHandle(Class->spicn),
               IMAGE_ICON,
               UserGetSystemMetrics( SM_CXSMICON ),
               UserGetSystemMetrics( SM_CYSMICON ),
               0);
       }
 
       if (IconSmHandle)
       {
           Class->spicnSm = UserGetCurIconObject(IconSmHandle);
           Class->CSF_flags |= CSF_CACHEDSMICON;
       }
   }
 
   if (pWnd->pcls->CSF_flags & CSF_SERVERSIDEPROC)
      pWnd->state |= WNDS_SERVERSIDEWINDOWPROC;
 
 /* BugBoy Comments: Comment below say that System classes are always created
    as UNICODE. In windows, creating a window with the ANSI version of CreateWindow
    sets the window to ansi as verified by testing with IsUnicodeWindow API.
 
    No where can I see in code or through testing does the window change back
    to ANSI after being created as UNICODE in ROS. I didnt do more testing to
    see what problems this would cause. */
 
   // Set WndProc from Class.
   if (IsCallProcHandle(pWnd->pcls->lpfnWndProc))
   {
      pcpd = UserGetObject(gHandleTable, pWnd->pcls->lpfnWndProc, TYPE_CALLPROC);
      if (pcpd)
         pWnd->lpfnWndProc = pcpd->pfnClientPrevious;
   }
   else
   {
      pWnd->lpfnWndProc = pWnd->pcls->lpfnWndProc;
   }
 
   // GetWindowProc, test for non server side default classes and set WndProc.
    if ( pWnd->pcls->fnid <= FNID_GHOST && pWnd->pcls->fnid >= FNID_BUTTON )
    {
      if (bUnicodeWindow)
      {
         if (GETPFNCLIENTA(pWnd->pcls->fnid) == pWnd->lpfnWndProc)
            pWnd->lpfnWndProc = GETPFNCLIENTW(pWnd->pcls->fnid);
      }
      else
      {
         if (GETPFNCLIENTW(pWnd->pcls->fnid) == pWnd->lpfnWndProc)
            pWnd->lpfnWndProc = GETPFNCLIENTA(pWnd->pcls->fnid);
      }
    }
 
   // If not an Unicode caller, set Ansi creator bit.
   if (!bUnicodeWindow) pWnd->state |= WNDS_ANSICREATOR;
 
   // Clone Class Ansi/Unicode proc type.
   if (pWnd->pcls->CSF_flags & CSF_ANSIPROC)
   {
      pWnd->state |= WNDS_ANSIWINDOWPROC;
      pWnd->Unicode = FALSE;
   }
   else
   { /*
      * It seems there can be both an Ansi creator and Unicode Class Window
      * WndProc, unless the following overriding conditions occur:
      */
      if ( !bUnicodeWindow &&
          ( Class->atomClassName == gpsi->atomSysClass[ICLS_BUTTON]    ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOBOX]  ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOLBOX] ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_DIALOG]    ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT]      ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_IME]       ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_LISTBOX]   ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_MDICLIENT] ||
            Class->atomClassName == gpsi->atomSysClass[ICLS_STATIC] ) )
      { // Override Class and set the window Ansi WndProc.
         pWnd->state |= WNDS_ANSIWINDOWPROC;
         pWnd->Unicode = FALSE;
      }
      else
      { // Set the window Unicode WndProc.
         pWnd->state &= ~WNDS_ANSIWINDOWPROC;
         pWnd->Unicode = TRUE;
      }
   }
 
   /* BugBoy Comments: if the window being created is a edit control, ATOM 0xCxxx,
      then my testing shows that windows (2k and XP) creates a CallProc for it immediately
      Dont understand why it does this. */
   if (Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT])
   {
      PCALLPROCDATA CallProc;
      CallProc = CreateCallProc(pWnd->head.rpdesk, pWnd->lpfnWndProc, pWnd->Unicode , pWnd->head.pti->ppi);
 
      if (!CallProc)
      {
         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
         ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %p\n", hWnd);
      }
      else
      {
         UserAddCallProcToClass(pWnd->pcls, CallProc);
      }
   }
 
   InitializeListHead(&pWnd->PropListHead);
   pWnd->PropListItems = 0;
 
   if ( WindowName->Buffer != NULL && WindowName->Length > 0 )
   {
      pWnd->strName.Buffer = DesktopHeapAlloc(pWnd->head.rpdesk,
                                             WindowName->Length + sizeof(UNICODE_NULL));
      if (pWnd->strName.Buffer == NULL)
      {
          goto AllocError;
      }
 
      RtlCopyMemory(pWnd->strName.Buffer, WindowName->Buffer, WindowName->Length);
      pWnd->strName.Buffer[WindowName->Length / sizeof(WCHAR)] = L'\0';
      pWnd->strName.Length = WindowName->Length;
      pWnd->strName.MaximumLength = WindowName->Length + sizeof(UNICODE_NULL);
   }
 
   /* Correct the window style. */
   if ((pWnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
   {
      pWnd->style |= WS_CLIPSIBLINGS;
      if (!(pWnd->style & WS_POPUP))
      {
         pWnd->style |= WS_CAPTION;
      }
   }
 
   /* WS_EX_WINDOWEDGE depends on some other styles */
   if (pWnd->ExStyle & WS_EX_DLGMODALFRAME)
       pWnd->ExStyle |= WS_EX_WINDOWEDGE;
   else if (pWnd->style & (WS_DLGFRAME | WS_THICKFRAME))
   {
       if (!((pWnd->ExStyle & WS_EX_STATICEDGE) &&
            (pWnd->style & (WS_CHILD | WS_POPUP))))
           pWnd->ExStyle |= WS_EX_WINDOWEDGE;
   }
    else
        pWnd->ExStyle &= ~WS_EX_WINDOWEDGE;
 
   if (!(pWnd->style & (WS_CHILD | WS_POPUP)))
      pWnd->state |= WNDS_SENDSIZEMOVEMSGS;
 
   /* Set the window menu */
   if ((Cs->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
   {
      if (Cs->hMenu)
      {
         IntSetMenu(pWnd, Cs->hMenu, &MenuChanged);
      }
      else if (pWnd->pcls->lpszMenuName) // Take it from the parent.
      {
          UNICODE_STRING MenuName;
          HMENU hMenu;
 
          if (IS_INTRESOURCE(pWnd->pcls->lpszMenuName))
          {
             MenuName.Length = 0;
             MenuName.MaximumLength = 0;
             MenuName.Buffer = pWnd->pcls->lpszMenuName;
          }
          else
          {
             RtlInitUnicodeString( &MenuName, pWnd->pcls->lpszMenuName);
          }
          hMenu = co_IntCallLoadMenu( pWnd->pcls->hModule, &MenuName);
          if (hMenu) IntSetMenu(pWnd, hMenu, &MenuChanged);
      }
   }
   else // Not a child
      pWnd->IDMenu = (UINT_PTR)Cs->hMenu;
 
 
   if ( ParentWindow &&
        ParentWindow != ParentWindow->head.rpdesk->spwndMessage &&
        ParentWindow != ParentWindow->head.rpdesk->pDeskInfo->spwnd )
   {
       PWND Owner = IntGetNonChildAncestor(ParentWindow);
 
       if (!IntValidateOwnerDepth(pWnd, Owner))
       {
          EngSetLastError(ERROR_INVALID_PARAMETER);
          goto Error;
       }
       if ( pWnd->spwndOwner &&
            pWnd->spwndOwner->ExStyle & WS_EX_TOPMOST )
       {
          pWnd->ExStyle |= WS_EX_TOPMOST;
       }
       if ( pWnd->spwndOwner &&
            Class->atomClassName != gpsi->atomSysClass[ICLS_IME] &&
            pti != pWnd->spwndOwner->head.pti)
       {
          //ERR("CreateWindow Owner in.\n");
          UserAttachThreadInput(pti, pWnd->spwndOwner->head.pti, TRUE);
       }
   }
 
   /* Insert the window into the thread's window list. */
   InsertTailList (&pti->WindowListHead, &pWnd->ThreadListEntry);
 
   /* Handle "CS_CLASSDC", it is tested first. */
   if ( (pWnd->pcls->style & CS_CLASSDC) && !(pWnd->pcls->pdce) )
   {  /* One DCE per class to have CLASS. */
      pWnd->pcls->pdce = DceAllocDCE( pWnd, DCE_CLASS_DC );
   }
   else if ( pWnd->pcls->style & CS_OWNDC)
   {  /* Allocate a DCE for this window. */
      DceAllocDCE(pWnd, DCE_WINDOW_DC);
   }
 
   return pWnd;
 
AllocError:
   ERR("IntCreateWindow Allocation Error.\n");
   SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
Error:
   if(pWnd)
      UserDereferenceObject(pWnd);
   return NULL;
}

Referenced by co_UserCreateWindowEx(), and IntCreateDesktop().

IntDefWindowProc()

LRESULT FASTCALL IntDefWindowProc	(	PWND	Window,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	Ansi
	)

Definition at line 633 of file defwnd.c.

{
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
   LRESULT lResult = 0;
   USER_REFERENCE_ENTRY Ref;
 
   if (Msg > WM_USER) return 0;
 
   switch (Msg)
   {
      case WM_DEVICECHANGE:
            return TRUE;
 
      case WM_GETTEXTLENGTH:
      {
            PWSTR buf;
            ULONG len;
 
            if (Wnd != NULL && Wnd->strName.Length != 0)
            {
                buf = Wnd->strName.Buffer;
                if (buf != NULL &&
                    NT_SUCCESS(RtlUnicodeToMultiByteSize(&len,
                                                         buf,
                                                         Wnd->strName.Length)))
                {
                    lResult = (LRESULT) (Wnd->strName.Length / sizeof(WCHAR));
                }
            }
 
            break;
      }
 
      case WM_GETTEXT: // FIXME: Handle Ansi
      {
            PWSTR buf = NULL;
            PWSTR outbuf = (PWSTR)lParam;
 
            if (Wnd != NULL && wParam != 0)
            {
                if (Wnd->strName.Buffer != NULL)
                    buf = Wnd->strName.Buffer;
                else
                    outbuf[0] = L'\0';
 
                if (buf != NULL)
                {
                    if (Wnd->strName.Length != 0)
                    {
                        lResult = min(Wnd->strName.Length / sizeof(WCHAR), wParam - 1);
                        RtlCopyMemory(outbuf,
                                      buf,
                                      lResult * sizeof(WCHAR));
                        outbuf[lResult] = L'\0';
                    }
                    else
                        outbuf[0] = L'\0';
                }
            }
            break;
      }
 
      case WM_SETTEXT: // FIXME: Handle Ansi
      {
            DefSetText(Wnd, (PCWSTR)lParam);
 
            if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
                UserPaintCaption(Wnd, DC_TEXT);
            IntNotifyWinEvent(EVENT_OBJECT_NAMECHANGE, Wnd, OBJID_WINDOW, CHILDID_SELF, 0);
            lResult = 1;
            break;
      }
 
      case WM_SYSCOMMAND:
      {
         TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", UserHMGetHandle(Wnd), wParam, lParam );
         lResult = DefWndHandleSysCommand(Wnd, wParam, lParam);
         break;
      }
 
      case WM_SHOWWINDOW:
      {
         if ((Wnd->style & WS_VISIBLE) && wParam) break;
         if (!(Wnd->style & WS_VISIBLE) && !wParam) break;
         if (!Wnd->spwndOwner) break;
         if (LOWORD(lParam))
         {
            co_WinPosShowWindow(Wnd, wParam ? SW_SHOWNOACTIVATE : SW_HIDE);
         }
         break;
      }
 
      case WM_CLIENTSHUTDOWN:
         return IntClientShutdown(Wnd, wParam, lParam);
 
      case WM_APPCOMMAND:
      {
         PWND Parent;
         if ( (Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
               Wnd != co_GetDesktopWindow(Wnd) )
         {
            if (!co_HOOK_CallHooks(WH_SHELL, HSHELL_APPCOMMAND, wParam, lParam))
               co_IntShellHookNotify(HSHELL_APPCOMMAND, wParam, lParam);
            break;
         }
         Parent = Wnd->spwndParent;
         UserRefObjectCo(Parent, &Ref);
         lResult = co_IntSendMessage(UserHMGetHandle(Parent), WM_APPCOMMAND, wParam, lParam);
         UserDerefObjectCo(Parent);
         break;
      }
 
      case WM_POPUPSYSTEMMENU:
         /* This is an undocumented message used by the windows taskbar to
            display the system menu of windows that belong to other processes. */
         co_UserTrackSystemMenu(Wnd, (LONG)lParam, NULL);
         break;
 
      case WM_KEYF1:
      {
         HELPINFO hi;
         HMENU hMenu = UlongToHandle(Wnd->IDMenu);
         PWND pwndActive = MENU_IsMenuActive();
         hi.cbSize = sizeof(HELPINFO);
         hi.MousePos = gpsi->ptCursor;
         hi.iContextType = HELPINFO_MENUITEM;
         hi.hItemHandle = pwndActive ? UserHMGetHandle(pwndActive) : UserHMGetHandle(Wnd);
         hi.iCtrlId = (Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD ? IntMenuItemFromPoint(Wnd, hMenu, hi.MousePos) : 0;
         hi.dwContextId = IntGetWindowContextHelpId(Wnd);
 
         co_IntSendMessage( UserHMGetHandle(Wnd), WM_HELP, 0, (LPARAM)&hi );
         break;
      }
 
      case WM_SETICON:
      {
         return DefWndSetIcon(Wnd, wParam, lParam);
      }
 
      case WM_GETICON:
      {
         return DefWndGetIcon(Wnd, wParam, lParam);
      }
 
      case WM_HELP:
      {
         PWND Parent = IntGetParent(Wnd);
         co_IntSendMessage(UserHMGetHandle(Parent), Msg, wParam, lParam);
         break;
      }
 
      case WM_LBUTTONDOWN:
      case WM_RBUTTONDOWN:
      case WM_MBUTTONDOWN:
          pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
          break;
 
      case WM_NCLBUTTONDOWN:
          return NC_HandleNCLButtonDown(Wnd, wParam, lParam);
 
      case WM_NCRBUTTONDOWN:
          return NC_HandleNCRButtonDown(Wnd, wParam, lParam);
 
      case WM_LBUTTONDBLCLK:
          return NC_HandleNCLButtonDblClk(Wnd, HTCLIENT, lParam);
 
      case WM_NCLBUTTONDBLCLK:
          return NC_HandleNCLButtonDblClk(Wnd, wParam, lParam);
 
      case WM_RBUTTONUP:
      {
            POINT Pt;
 
            Pt.x = GET_X_LPARAM(lParam);
            Pt.y = GET_Y_LPARAM(lParam);
            IntClientToScreen(Wnd, &Pt);
            lParam = MAKELPARAM(Pt.x, Pt.y);
            co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), lParam);
            break;
      }
 
      case WM_NCRBUTTONUP:
          /*
           * FIXME : we must NOT send WM_CONTEXTMENU on a WM_NCRBUTTONUP (checked
           * in Windows), but what _should_ we do? According to MSDN :
           * "If it is appropriate to do so, the system sends the WM_SYSCOMMAND
           * message to the window". When is it appropriate?
           */
          ERR("WM_NCRBUTTONUP\n");
          break;
 
      case WM_XBUTTONUP:
      case WM_NCXBUTTONUP:
          if (HIWORD(wParam) == XBUTTON1 || HIWORD(wParam) == XBUTTON2)
          {
              co_IntSendMessage(UserHMGetHandle(Wnd), WM_APPCOMMAND, (WPARAM)UserHMGetHandle(Wnd),
                                MAKELPARAM(LOWORD(wParam), FAPPCOMMAND_MOUSE | HIWORD(wParam)));
          }
          break;
 
 
      case WM_CONTEXTMENU:
      {
            if (Wnd->style & WS_CHILD)
            {
                co_IntSendMessage(UserHMGetHandle(IntGetParent(Wnd)), Msg, (WPARAM)UserHMGetHandle(Wnd), lParam);
            }
            else
            {
                POINT Pt;
                LONG_PTR Style;
                LONG HitCode;
 
                Style = Wnd->style;
 
                Pt.x = GET_X_LPARAM(lParam);
                Pt.y = GET_Y_LPARAM(lParam);
                if (Style & WS_CHILD)
                {
                    IntScreenToClient(IntGetParent(Wnd), &Pt);
                }
 
                HitCode = GetNCHitEx(Wnd, Pt);
 
                if (HitCode == HTCAPTION || HitCode == HTSYSMENU)
                {
                    PMENU SystemMenu;
                    UINT Flags;
 
                    if((SystemMenu = IntGetSystemMenu(Wnd, FALSE)))
                    {
                      MENU_InitSysMenuPopup(SystemMenu, Wnd->style, Wnd->pcls->style, HitCode);
 
                      if(HitCode == HTCAPTION)
                        Flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON;
                      else
                        Flags = TPM_LEFTBUTTON;
 
                      IntTrackPopupMenuEx(SystemMenu, Flags|TPM_SYSTEM_MENU, Pt.x, Pt.y, Wnd, NULL);
                    }
                }
                if (HitCode == HTHSCROLL || HitCode == HTVSCROLL)
                {
                   WARN("Scroll Menu Not Supported\n");
                }
            }
            break;
      }
 
      case WM_KEYDOWN:
         if (wParam == VK_F10)
         {
            pti->MessageQueue->QF_flags |= QF_FF10STATUS;
 
            if (UserGetKeyState(VK_SHIFT) & 0x8000)
            {
               co_IntSendMessage(UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1));
            }
         }
         if (g_bWindowSnapEnabled && (IS_KEY_DOWN(gafAsyncKeyState, VK_LWIN) || IS_KEY_DOWN(gafAsyncKeyState, VK_RWIN)))
         {
            HWND hwndTop = UserGetForegroundWindow();
            PWND topWnd = UserGetWindowObject(hwndTop);
            BOOL allowSnap;
 
            // MS Doc: foreground window can be NULL, e.g. when window is losing activation
            if (!topWnd)
               return 0;
 
            allowSnap = IntIsSnapAllowedForWindow(topWnd);
            /* Allow the minimize action if it has a minimize button, even if the window cannot be snapped (e.g. Calc.exe) */
            if (!allowSnap && (topWnd->style & (WS_MINIMIZEBOX|WS_THICKFRAME)) == WS_MINIMIZEBOX)
                allowSnap = wParam == VK_DOWN;
 
            if (allowSnap)
            {
               UINT snapped = IntGetWindowSnapEdge(topWnd);
 
               if (wParam == VK_DOWN)
               {
                   if (topWnd->style & WS_MAXIMIZE)
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, MAKELONG(0, 1));
                   else if (snapped)
                       co_IntUnsnapWindow(topWnd);
                   else
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(0, 1));
               }
               else if (wParam == VK_UP)
               {
                   if (topWnd->style & WS_MINIMIZE)
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, MAKELONG(0, 1));
                   else
                       co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_MAXIMIZE, MAKELONG(0, 1));
               }
               else if (wParam == VK_LEFT || wParam == VK_RIGHT)
               {
                  UINT edge = wParam == VK_LEFT ? HTLEFT : HTRIGHT;
                  UINT otherEdge = edge == HTLEFT ? HTRIGHT : HTLEFT;
 
                  if (topWnd->style & WS_MAXIMIZE)
                  {
                     /* SC_RESTORE + Snap causes the window to visually move twice, place it manually in the snap position */
                     RECT normalRect = topWnd->InternalPos.NormalRect;
                     co_IntCalculateSnapPosition(topWnd, edge, &topWnd->InternalPos.NormalRect); /* Calculate edge position */
                     IntSetSnapEdge(topWnd, edge); /* Tell everyone the edge we are snapped to */
                     co_IntSendMessage(hwndTop, WM_SYSCOMMAND, SC_RESTORE, MAKELONG(0, 1));
                     IntSetSnapInfo(topWnd, edge, &normalRect); /* Reset the real place to unsnap to */
                     snapped = HTNOWHERE; /* Force snap */
                  }
#if 0 /* Windows 8 does this but is it a good feature? */
                  else if (snapped == edge)
                  {
                     /* Already snapped to this edge, snap to the opposite side */
                     edge = otherEdge;
                  }
#endif
 
                  if (snapped == otherEdge)
                     co_IntUnsnapWindow(topWnd);
                  else
                     co_IntSnapWindow(topWnd, edge);
               }
            }
         }
         break;
 
      case WM_SYSKEYDOWN:
      {
            if (HIWORD(lParam) & KF_ALTDOWN)
            {   /* Previous state, if the key was down before this message,
                   this is a cheap way to ignore autorepeat keys. */
                if ( !(HIWORD(lParam) & KF_REPEAT) )
                {
                   if ( ( wParam == VK_MENU  ||
                          wParam == VK_LMENU ||
                          wParam == VK_RMENU ) && !(pti->MessageQueue->QF_flags & QF_FMENUSTATUS)) //iMenuSysKey )
                       pti->MessageQueue->QF_flags |= QF_FMENUSTATUS; //iMenuSysKey = 1;
                   else
                       pti->MessageQueue->QF_flags &= ~QF_FMENUSTATUS; //iMenuSysKey = 0;
                }
 
                pti->MessageQueue->QF_flags &= ~QF_FF10STATUS; //iF10Key = 0;
 
                if (wParam == VK_F4) /* Try to close the window */
                {
                   PWND top = UserGetAncestor(Wnd, GA_ROOT);
                   if (!(top->pcls->style & CS_NOCLOSE))
                      UserPostMessage(UserHMGetHandle(top), WM_SYSCOMMAND, SC_CLOSE, 0);
                }
                else if (wParam == VK_SNAPSHOT) // Alt-VK_SNAPSHOT?
                {
                   PWND pwnd = Wnd;
                   while (IntGetParent(pwnd) != NULL)
                   {
                       pwnd = IntGetParent(pwnd);
                   }
                   ERR("DefWndScreenshot\n");
                   DefWndScreenshot(pwnd);
                }
                else if ( wParam == VK_ESCAPE || wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
                {
                   WPARAM wParamTmp;
                   HWND Active = UserGetActiveWindow(); // Noticed MDI problem.
                   if (!Active)
                   {
                      FIXME("WM_SYSKEYDOWN VK_ESCAPE no active\n");
                      break;
                   }
                   wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
                   co_IntSendMessage( Active, WM_SYSCOMMAND, wParamTmp, wParam );
                }
            }
            else if( wParam == VK_F10 )
            {
                if (UserGetKeyState(VK_SHIFT) & 0x8000)
                    co_IntSendMessage( UserHMGetHandle(Wnd), WM_CONTEXTMENU, (WPARAM)UserHMGetHandle(Wnd), MAKELPARAM(-1, -1) );
                pti->MessageQueue->QF_flags |= QF_FF10STATUS; //iF10Key = 1;
            }
            else if( wParam == VK_ESCAPE && (UserGetKeyState(VK_SHIFT) & 0x8000))
                  co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, ' ' );
            break;
      }
 
      case WM_KEYUP:
      case WM_SYSKEYUP:
      {
           /* Press and release F10 or ALT */
            if (((wParam == VK_MENU || wParam == VK_LMENU || wParam == VK_RMENU)
                 && (pti->MessageQueue->QF_flags & (QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) == QF_FMENUSTATUS /*iMenuSysKey*/) ||
                 ((wParam == VK_F10) && pti->MessageQueue->QF_flags & QF_FF10STATUS /*iF10Key*/))
                co_IntSendMessage( UserHMGetHandle(UserGetAncestor( Wnd, GA_ROOT )), WM_SYSCOMMAND, SC_KEYMENU, 0L );
            pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK|QF_FF10STATUS); //iMenuSysKey = iF10Key = 0;
            break;
      }
 
      case WM_SYSCHAR:
      {
            pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK); //iMenuSysKey = 0;
            if (wParam == VK_RETURN && (Wnd->style & WS_MINIMIZE) != 0)
            {
                UserPostMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_RESTORE, 0L );
                break;
            }
            if ((HIWORD(lParam) & KF_ALTDOWN) && wParam)
            {
                if (wParam == VK_TAB || wParam == VK_ESCAPE) break;
                if (wParam == VK_SPACE && Wnd->style & WS_CHILD)
                    co_IntSendMessage( UserHMGetHandle(IntGetParent(Wnd)), Msg, wParam, lParam );
                else
                    co_IntSendMessage( UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_KEYMENU, wParam );
            }
            else /* check for Ctrl-Esc */
                if (wParam != VK_ESCAPE) UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, 0); //MessageBeep(0);
            break;
      }
 
      case WM_CANCELMODE:
      {
         pti->MessageQueue->QF_flags &= ~(QF_FMENUSTATUS|QF_FMENUSTATUSBREAK);
 
         MENU_EndMenu( Wnd );
         if (IntGetCaptureWindow() == UserHMGetHandle(Wnd))
         {
            IntReleaseCapture();
         }
         break;
      }
 
      case WM_CLOSE:
         co_UserDestroyWindow(Wnd);
         break;
 
      case WM_CTLCOLORMSGBOX:
      case WM_CTLCOLOREDIT:
      case WM_CTLCOLORLISTBOX:
      case WM_CTLCOLORBTN:
      case WM_CTLCOLORDLG:
      case WM_CTLCOLORSTATIC:
      case WM_CTLCOLORSCROLLBAR:
           return (LRESULT) DefWndControlColor((HDC)wParam, Msg - WM_CTLCOLORMSGBOX);
 
      case WM_CTLCOLOR:
           return (LRESULT) DefWndControlColor((HDC)wParam, HIWORD(lParam));
 
      case WM_SETCURSOR:
      {
         if (Wnd->style & WS_CHILD)
         {
             /* with the exception of the border around a resizable wnd,
              * give the parent first chance to set the cursor */
             if (LOWORD(lParam) < HTLEFT || LOWORD(lParam) > HTBOTTOMRIGHT)
             {
                 PWND parent = Wnd->spwndParent;//IntGetParent( Wnd );
                 if (parent != UserGetDesktopWindow() &&
                     co_IntSendMessage( UserHMGetHandle(parent), WM_SETCURSOR, wParam, lParam))
                    return TRUE;
             }
         }
         return DefWndHandleSetCursor(Wnd, wParam, lParam);
      }
 
      case WM_MOUSEACTIVATE:
         if (Wnd->style & WS_CHILD)
         {
             HWND hwndParent;
             PWND pwndParent = IntGetParent(Wnd);
             hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
             if (hwndParent)
             {
                 lResult = co_IntSendMessage(hwndParent, WM_MOUSEACTIVATE, wParam, lParam);
                 if (lResult)
                     break;
             }
         }
         return ( (HIWORD(lParam) == WM_LBUTTONDOWN && LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE );
 
      case WM_ACTIVATE:
       /* The default action in Windows is to set the keyboard focus to
        * the window, if it's being activated and not minimized */
         if (LOWORD(wParam) != WA_INACTIVE &&
              !(Wnd->style & WS_MINIMIZE))
         {
            //ERR("WM_ACTIVATE %p\n",hWnd);
            co_UserSetFocus(Wnd);
         }
         break;
 
      case WM_MOUSEWHEEL:
         if (Wnd->style & WS_CHILD)
         {
            HWND hwndParent;
            PWND pwndParent = IntGetParent(Wnd);
            hwndParent = pwndParent ? UserHMGetHandle(pwndParent) : NULL;
            return co_IntSendMessage( hwndParent, WM_MOUSEWHEEL, wParam, lParam);
         }
         break;
 
      case WM_ERASEBKGND:
      case WM_ICONERASEBKGND:
      {
         RECT Rect;
         HBRUSH hBrush = Wnd->pcls->hbrBackground;
         if (!hBrush) return 0;
         if (hBrush <= (HBRUSH)COLOR_MENUBAR)
         {
            hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
         }
         if (Wnd->pcls->style & CS_PARENTDC)
         {
            /* can't use GetClipBox with a parent DC or we fill the whole parent */
            IntGetClientRect(Wnd, &Rect);
            GreDPtoLP((HDC)wParam, (LPPOINT)&Rect, 2);
         }
         else
         {
            GdiGetClipBox((HDC)wParam, &Rect);
         }
         FillRect((HDC)wParam, &Rect, hBrush);
         return (1);
      }
 
      case WM_GETHOTKEY:
         //ERR("WM_GETHOTKEY\n");
         return DefWndGetHotKey(Wnd);
      case WM_SETHOTKEY:
         //ERR("WM_SETHOTKEY\n");
         return DefWndSetHotKey(Wnd, wParam);
 
      case WM_NCHITTEST:
      {
         POINT Point;
         Point.x = GET_X_LPARAM(lParam);
         Point.y = GET_Y_LPARAM(lParam);
         return GetNCHitEx(Wnd, Point);
      }
 
      case WM_PRINT:
      {
         DefWndPrint(Wnd, (HDC)wParam, lParam);
         return (0);
      }
 
      case WM_SYSCOLORCHANGE:
      {
         /* force to redraw non-client area */
         UserPaintCaption(Wnd, DC_NC);
         /* Use InvalidateRect to redraw client area, enable
          * erase to redraw all subcontrols otherwise send the
          * WM_SYSCOLORCHANGE to child windows/controls is required
          */
         co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN|RDW_INVALIDATE|RDW_ERASE);
         return (0);
      }
 
      case WM_PAINTICON:
      case WM_PAINT:
      {
         PAINTSTRUCT Ps;
         HDC hDC;
 
         /* If already in Paint and Client area is not empty just return. */
         if (Wnd->state2 & WNDS2_STARTPAINT && !RECTL_bIsEmptyRect(&Wnd->rcClient))
         {
            ERR("In Paint and Client area is not empty!\n");
            return 0;
         }
 
         hDC = IntBeginPaint(Wnd, &Ps);
         if (hDC)
         {
             if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn))
             {
                 RECT ClientRect;
                 INT x, y;
 
                 ERR("Doing Paint and Client area is empty!\n");
                 IntGetClientRect(Wnd, &ClientRect);
                 x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2;
                 y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2;
                 UserReferenceObject(Wnd->pcls->spicn);
                 UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE);
                 UserDereferenceObject(Wnd->pcls->spicn);
             }
 
             IntEndPaint(Wnd, &Ps);
         }
         return (0);
      }
 
      case WM_SYNCPAINT:
      {
         HRGN hRgn;
         Wnd->state &= ~WNDS_SYNCPAINTPENDING;
         TRACE("WM_SYNCPAINT\n");
         hRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
         if (hRgn)
         {
             if (co_UserGetUpdateRgn(Wnd, hRgn, FALSE) != NULLREGION)
             {
                PREGION pRgn = REGION_LockRgn(hRgn);
                if (pRgn) REGION_UnlockRgn(pRgn);
                if (!wParam)
                    wParam = (RDW_ERASENOW | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN);
                co_UserRedrawWindow(Wnd, NULL, pRgn, wParam);
             }
             GreDeleteObject(hRgn);
         }
         return 0;
      }
 
      case WM_SETREDRAW:
          if (wParam)
          {
             if (!(Wnd->style & WS_VISIBLE))
             {
                IntSetStyle( Wnd, WS_VISIBLE, 0 );
                Wnd->state |= WNDS_SENDNCPAINT;
             }
          }
          else
          {
             if (Wnd->style & WS_VISIBLE)
             {
                co_UserRedrawWindow( Wnd, NULL, NULL, RDW_ALLCHILDREN | RDW_VALIDATE );
                IntSetStyle( Wnd, 0, WS_VISIBLE );
             }
          }
          return 0;
 
      case WM_WINDOWPOSCHANGING:
      {
          return (DefWndHandleWindowPosChanging(Wnd, (WINDOWPOS*)lParam));
      }
 
      case WM_WINDOWPOSCHANGED:
      {
          return (DefWndHandleWindowPosChanged(Wnd, (WINDOWPOS*)lParam));
      }
 
      case WM_NCCALCSIZE:
      {
         return NC_HandleNCCalcSize( Wnd, wParam, (RECTL *)lParam, FALSE );
      }
 
      case WM_NCACTIVATE:
      {
          return NC_HandleNCActivate( Wnd, wParam, lParam );
      }
 
      //
      // NC Paint mode.
      //
      case WM_NCPAINT:
      {
          HDC hDC = UserGetDCEx(Wnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN);
          Wnd->state |= WNDS_FORCEMENUDRAW;
          NC_DoNCPaint(Wnd, hDC, -1);
          Wnd->state &= ~WNDS_FORCEMENUDRAW;
          UserReleaseDC(Wnd, hDC, FALSE);
          return 0;
      }
      //
      //  Draw Caption mode.
      //
      //  wParam are DC_* flags.
      //
      case WM_NCUAHDRAWCAPTION:
      {
          HDC hDC = UserGetDCEx(Wnd, NULL, DCX_WINDOW|DCX_USESTYLE);
          TRACE("WM_NCUAHDRAWCAPTION: wParam DC_ flags %08x\n",wParam);
          UserDrawCaptionBar(Wnd, hDC, wParam | DC_FRAME); // Include DC_FRAME to comp for drawing glitch.
          UserReleaseDC(Wnd, hDC, FALSE);
          return 0;
      }
      //
      //  Draw Frame mode.
      //
      //  wParam is HDC, lParam are DC_ACTIVE and or DC_REDRAWHUNGWND.
      //
      case WM_NCUAHDRAWFRAME:
      {
          TRACE("WM_NCUAHDRAWFRAME: wParam hDC %p lParam DC_ flags %08x\n",wParam,lParam);
          NC_DoNCPaint(Wnd, (HDC)wParam, lParam|DC_NC);
          return 0;
      }
 
      /* ReactOS only. */
      case WM_CBT:
      {
         switch (wParam)
         {
            case HCBT_MOVESIZE:
            {
               RECTL rt;
 
               if (lParam)
               {
                  _SEH2_TRY
                  {
                      ProbeForRead((PVOID)lParam,
                                   sizeof(RECT),
                                   1);
 
                      RtlCopyMemory(&rt,
                                    (PVOID)lParam,
                                    sizeof(RECT));
                  }
                  _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
                  {
                      lResult = 1;
                  }
                  _SEH2_END;
               }
               if (!lResult)
                  lResult = co_HOOK_CallHooks(WH_CBT, HCBT_MOVESIZE, (WPARAM)UserHMGetHandle(Wnd), lParam ? (LPARAM)&rt : 0);
 
               break;
            }
         }
         break;
      }
   }
   return lResult;
}

Referenced by DesktopWindowProc(), GetControlColor(), NtUserMessageCall(), PopupMenuWndProc(), and UserMessageWindowProc().

IntEnableWindow()

BOOL FASTCALL IntEnableWindow	(	HWND	hWnd,
		BOOL	bEnable
	)

Definition at line 221 of file window.c.

{
   BOOL Update;
   PWND pWnd;
   UINT bIsDisabled;
 
   if(!(pWnd = UserGetWindowObject(hWnd)))
   {
      return FALSE;
   }
 
   /* check if updating is needed */
   bIsDisabled = !!(pWnd->style & WS_DISABLED);
   Update = bIsDisabled;
 
    if (bEnable)
    {
       IntSetStyle( pWnd, 0, WS_DISABLED );
    }
    else
    {
       Update = !bIsDisabled;
 
       co_IntSendMessage( hWnd, WM_CANCELMODE, 0, 0);
 
       /* Remove keyboard focus from that window if it had focus */
       if (hWnd == IntGetThreadFocusWindow())
       {
          TRACE("IntEnableWindow SF NULL\n");
          co_UserSetFocus(NULL);
       }
       IntSetStyle( pWnd, WS_DISABLED, 0 );
    }
 
    if (Update)
    {
        IntNotifyWinEvent(EVENT_OBJECT_STATECHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, 0);
        co_IntSendMessage(hWnd, WM_ENABLE, (LPARAM)bEnable, 0);
    }
    // Return nonzero if it was disabled, or zero if it wasn't:
    return bIsDisabled;
}

Referenced by NtUserCallTwoParam(), and NtUserEnableScrollBar().

IntFindWindow()

HWND FASTCALL IntFindWindow	(	PWND	Parent,
		PWND	ChildAfter,
		RTL_ATOM	ClassAtom,
		PUNICODE_STRING	WindowName
	)

Definition at line 3065 of file window.c.

{
   BOOL CheckWindowName;
   HWND *List, *phWnd;
   HWND Ret = NULL;
   UNICODE_STRING CurrentWindowName;
 
   ASSERT(Parent);
 
   CheckWindowName = WindowName->Buffer != 0;
 
   if((List = IntWinListChildren(Parent)))
   {
      phWnd = List;
      if(ChildAfter)
      {
         /* skip handles before and including ChildAfter */
         while(*phWnd && (*(phWnd++) != UserHMGetHandle(ChildAfter)))
            ;
      }
 
      /* search children */
      while(*phWnd)
      {
         PWND Child;
         if(!(Child = UserGetWindowObject(*(phWnd++))))
         {
            continue;
         }
 
         /* Do not send WM_GETTEXT messages in the kernel mode version!
            The user mode version however calls GetWindowText() which will
            send WM_GETTEXT messages to windows belonging to its processes */
         if (!ClassAtom || Child->pcls->atomNVClassName == ClassAtom)
         {
             // FIXME: LARGE_STRING truncated
             CurrentWindowName.Buffer = Child->strName.Buffer;
             CurrentWindowName.Length = (USHORT)min(Child->strName.Length, MAXUSHORT);
             CurrentWindowName.MaximumLength = (USHORT)min(Child->strName.MaximumLength, MAXUSHORT);
             if(!CheckWindowName ||
                (Child->strName.Length < 0xFFFF &&
                 !RtlCompareUnicodeString(WindowName, &CurrentWindowName, TRUE)))
             {
                Ret = UserHMGetHandle(Child);
                break;
             }
         }
      }
      ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
   }
 
   return Ret;
}

Referenced by NtUserFindWindowEx().

IntFreeHwndList()

VOID FASTCALL IntFreeHwndList

(

PWINDOWLIST

pwlTarget

)

Definition at line 1467 of file window.c.

{
    PWINDOWLIST pwl, *ppwl;
 
    for (ppwl = &gpwlList; *ppwl; ppwl = &(*ppwl)->pNextList)
    {
        if (*ppwl != pwlTarget)
            continue;
 
        *ppwl = pwlTarget->pNextList;
 
        if (gpwlCache)
        {
            if (WL_CAPACITY(pwlTarget) > WL_CAPACITY(gpwlCache))
            {
                pwl = gpwlCache;
                gpwlCache = pwlTarget;
                ExFreePoolWithTag(pwl, USERTAG_WINDOWLIST);
            }
            else
            {
                ExFreePoolWithTag(pwlTarget, USERTAG_WINDOWLIST);
            }
        }
        else
        {
            gpwlCache = pwlTarget;
        }
 
        break;
    }
}

Referenced by ExitThreadCallback(), IntAssociateInputContextEx(), IntCheckImeShowStatus(), IntDestroyInputContext(), and IntImeWindowPosChanged().

IntGetClientRect()

VOID FASTCALL IntGetClientRect	(	PWND	Wnd,
		RECTL *	Rect
	)

Internal function. Returns client window rectangle relative to the upper-left corner of client area.

Note

Does not check the validity of the parameters

Definition at line 92 of file winpos.c.

{
   ASSERT( Wnd );
   ASSERT( Rect );
   if (Wnd->style & WS_MINIMIZED)
   {
      Rect->left = Rect->top = 0;
      Rect->right = UserGetSystemMetrics(SM_CXMINIMIZED);
      Rect->bottom = UserGetSystemMetrics(SM_CYMINIMIZED);
      return;
   }
   if (!UserIsDesktopWindow(Wnd))
   {
      *Rect = Wnd->rcClient;
      RECTL_vOffsetRect(Rect, -Wnd->rcClient.left, -Wnd->rcClient.top);
   }
   else
   {
      Rect->left = Rect->top = 0;
      Rect->right  = Wnd->rcClient.right;
      Rect->bottom = Wnd->rcClient.bottom;
   /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
      Rect->right  = UserGetSystemMetrics(SM_CXSCREEN);
      Rect->bottom = UserGetSystemMetrics(SM_CYSCREEN);
   */
   }
}

Referenced by co_IntDrawCaret(), co_WinPosArrangeIconicWindows(), co_WinPosGetMinMaxInfo(), co_WinPosSendSizeMove(), DefWndDoSizeMove(), DefWndHandleWindowPosChanged(), IntBeginPaint(), IntCalculateThumb(), IntDefWindowProc(), IntFillWindow(), IntGetScrollBarRect(), IntScrollWindowEx(), MENU_DrawPopupMenu(), MENU_EnsureMenuItemVisible(), NC_DoNCPaint(), and WinPosFindIconPos().

IntGetNonChildAncestor()

PWND FASTCALL IntGetNonChildAncestor

(

PWND

pWnd

)

Definition at line 352 of file window.c.

{
   while(pWnd && (pWnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
      pWnd = pWnd->spwndParent;
   return pWnd;
}

Referenced by co_IntProcessMouseMessage(), co_IntSetActiveWindow(), and IntCreateWindow().

IntGetParent()

PWND FASTCALL IntGetParent

(

PWND

Wnd

)

Definition at line 205 of file window.c.

{
   if (Wnd->style & WS_POPUP)
   {
      return Wnd->spwndOwner;
   }
   else if (Wnd->style & WS_CHILD)
   {
      return Wnd->spwndParent;
   }
 
   return NULL;
}

Referenced by co_UserDestroyWindow(), DefSetText(), DefWndDoSizeMove(), DefWndHandleWindowPosChanged(), GetControlBrush(), IntDefWindowProc(), IntGetWindowContextHelpId(), MsqSendParentNotify(), NC_DoNCPaint(), NC_GetSysPopupPos(), NtUserCallHwndLock(), NtUserDefSetText(), and UserGetAncestor().

IntGetWindow()

HWND FASTCALL IntGetWindow	(	HWND	hWnd,
		UINT	uCmd
	)

Definition at line 382 of file window.c.

{
    PWND Wnd, FoundWnd;
    HWND Ret = NULL;
 
    Wnd = ValidateHwndNoErr(hWnd);
    if (!Wnd)
        return NULL;
 
    FoundWnd = NULL;
    switch (uCmd)
    {
            case GW_OWNER:
                if (Wnd->spwndOwner != NULL)
                    FoundWnd = Wnd->spwndOwner;
                break;
 
            case GW_HWNDFIRST:
                if(Wnd->spwndParent != NULL)
                {
                    FoundWnd = Wnd->spwndParent;
                    if (FoundWnd->spwndChild != NULL)
                        FoundWnd = FoundWnd->spwndChild;
                }
                break;
            case GW_HWNDNEXT:
                if (Wnd->spwndNext != NULL)
                    FoundWnd = Wnd->spwndNext;
                break;
 
            case GW_HWNDPREV:
                if (Wnd->spwndPrev != NULL)
                    FoundWnd = Wnd->spwndPrev;
                break;
 
            case GW_CHILD:
                if (Wnd->spwndChild != NULL)
                    FoundWnd = Wnd->spwndChild;
                break;
 
            case GW_HWNDLAST:
                FoundWnd = Wnd;
                while ( FoundWnd->spwndNext != NULL)
                    FoundWnd = FoundWnd->spwndNext;
                break;
 
            default:
                EngSetLastError(ERROR_INVALID_GW_COMMAND);
                break;
    }
 
    if (FoundWnd != NULL)
        Ret = UserHMGetHandle(FoundWnd);
    return Ret;
}

Referenced by WinPosFixupFlags().

IntGetWindowBorderMeasures()

VOID FASTCALL IntGetWindowBorderMeasures	(	PWND	WindowObject,
		UINT *	cx,
		UINT *	cy
	)

Definition at line 867 of file winpos.c.

{
   if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
   {
      *cx = UserGetSystemMetrics(SM_CXDLGFRAME);
      *cy = UserGetSystemMetrics(SM_CYDLGFRAME);
   }
   else
   {
      if(HAS_THICKFRAME(Wnd->style, Wnd->ExStyle)&& !(Wnd->style & WS_MINIMIZE))
      {
         *cx = UserGetSystemMetrics(SM_CXFRAME);
         *cy = UserGetSystemMetrics(SM_CYFRAME);
      }
      else if(HAS_THINFRAME(Wnd->style, Wnd->ExStyle))
      {
         *cx = UserGetSystemMetrics(SM_CXBORDER);
         *cy = UserGetSystemMetrics(SM_CYBORDER);
      }
      else
      {
         *cx = *cy = 0;
      }
   }
}

IntImeCanDestroyDefIME()

BOOL FASTCALL IntImeCanDestroyDefIME	(	_In_ PWND	pImeWnd,
		_In_ PWND	pwndTarget
	)

Definition at line 2177 of file ime.c.

{
    PWND pwndNode;
    PIMEUI pimeui;
    IMEUI SafeImeUI;
 
    pimeui = IntGetImeUIFromWnd(pImeWnd);
    if (!pimeui)
        return FALSE;
 
    // Check IMEUI.fDestroy
    _SEH2_TRY
    {
        ProbeForRead(pimeui, sizeof(IMEUI), 1);
        SafeImeUI = *pimeui;
        if (SafeImeUI.fDestroy)
            return FALSE;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("Exception in IntImeCanDestroyDefIME: %p\n", pimeui);
    }
    _SEH2_END;
 
    // Any ancestor of pImeWnd is pwndTarget?
    if (pImeWnd->spwndOwner)
    {
        for (pwndNode = pImeWnd->spwndOwner; pwndNode; pwndNode = pwndNode->spwndOwner)
        {
            if (pwndNode == pwndTarget)
                break;
        }
 
        if (!pwndNode)
            return FALSE;
    }
 
    // Any ancestor of pwndTarget is IME-like?
    for (pwndNode = pwndTarget; pwndNode; pwndNode = pwndNode->spwndOwner)
    {
        if (IS_WND_IMELIKE(pwndNode))
            return FALSE;
    }
 
    // Adjust the ordering and top-mode status
    IntImeSetFutureOwner(pImeWnd, pwndTarget);
    for (pwndNode = pImeWnd->spwndOwner; pwndNode; pwndNode = pwndNode->spwndNext)
    {
        if (pwndNode == pImeWnd)
            break;
    }
    if (pwndNode == pImeWnd)
        IntImeCheckTopmost(pImeWnd);
 
    // Is the owner of pImeWnd NULL or pwndTarget?
    if (pImeWnd->spwndOwner && pwndTarget != pImeWnd->spwndOwner)
        return FALSE;
 
    WndSetOwner(pImeWnd, NULL);
    return TRUE;
}

Referenced by co_UserDestroyWindow().

IntImeCanDestroyDefIMEforChild()

BOOL FASTCALL IntImeCanDestroyDefIMEforChild	(	_In_ PWND	pImeWnd,
		_In_ PWND	pwndTarget
	)

Definition at line 2130 of file ime.c.

{
    PWND pwndNode;
    PIMEUI pimeui;
    IMEUI SafeImeUI;
 
    pimeui = IntGetImeUIFromWnd(pImeWnd);
    if (!pimeui)
        return FALSE;
 
    // Check IMEUI.fChildThreadDef
    _SEH2_TRY
    {
        ProbeForRead(pimeui, sizeof(IMEUI), 1);
        SafeImeUI = *pimeui;
        if (!SafeImeUI.fChildThreadDef)
            return FALSE;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("Exception in IntImeCanDestroyDefIMEforChild: %p\n", pimeui);
    }
    _SEH2_END;
 
    // The parent of pwndTarget is NULL or of the same thread of pwndTarget?
    if (pwndTarget->spwndParent == NULL ||
        pwndTarget->head.pti == pwndTarget->spwndParent->head.pti)
    {
        return FALSE;
    }
 
    for (pwndNode = pwndTarget; pwndNode; pwndNode = pwndNode->spwndParent)
    {
        if (pwndNode == pwndNode->head.rpdesk->pDeskInfo->spwnd)
            break;
 
        if (IntFindNonImeRelatedWndOfSameThread(pwndNode->spwndParent, pwndTarget))
            return FALSE;
    }
 
    return TRUE;
}

Referenced by co_UserDestroyWindow().

IntIsChildWindow()

BOOL FASTCALL IntIsChildWindow	(	PWND	Parent,
		PWND	Child
	)

Definition at line 929 of file window.c.

{
   PWND Window = BaseWindow;
   do
   {
     if ( Window == NULL || (Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD )
        return FALSE;
 
     Window = Window->spwndParent;
   }
   while(Parent != Window);
   return TRUE;
}

Referenced by co_IntFixCaret(), co_IntSetParent(), DceResetActiveDCEs(), IntGetPaintMessage(), and NC_DoNCPaint().

IntIsWindow()

BOOL FASTCALL IntIsWindow

(

HWND

hWnd

)

Definition at line 177 of file window.c.

{
   PWND Window;
 
   if (!(Window = UserGetWindowObject(hWnd)))
   {
      return FALSE;
   }
 
   return TRUE;
}

Referenced by co_IntPaintWindows(), co_UserDestroyWindow(), co_UserSetFocus(), co_WinPosSetWindowPos(), DefWndDoSizeMove(), IntSendDestroyMsg(), IntTrackPopupMenuEx(), NtUserCallHwnd(), NtUserSetActiveWindow(), and NtUserSetLogonNotifyWindow().

IntIsWindowVisible()

BOOL FASTCALL IntIsWindowVisible

(

PWND

Wnd

)

Definition at line 190 of file window.c.

{
   PWND Temp = Wnd;
   for (;;)
   {
      if (!Temp) return TRUE;
      if (!(Temp->style & WS_VISIBLE)) break;
      if (Temp->style & WS_MINIMIZE && Temp != Wnd) break;
      if (Temp->fnid == FNID_DESKTOP) return TRUE;
      Temp = Temp->spwndParent;
   }
   return FALSE;
}

Referenced by co_IntSendActivateMessages(), DefWndDoSizeMove(), DefWndPrint(), NC_DoNCPaint(), UserDrawCaptionBar(), and WinPosFixupFlags().

IntLinkHwnd()

VOID FASTCALL IntLinkHwnd	(	PWND	Wnd,
		HWND	hWndPrev
	)

Definition at line 985 of file window.c.

{
    if (hWndPrev == HWND_NOTOPMOST)
    {
        if (!(Wnd->ExStyle & WS_EX_TOPMOST) && (Wnd->ExStyle2 & WS_EX2_LINKED))
            return;  /* nothing to do */
        Wnd->ExStyle &= ~WS_EX_TOPMOST;
        hWndPrev = HWND_TOP;  /* fallback to the HWND_TOP case */
    }
 
    IntUnlinkWindow(Wnd);  /* unlink it from the previous location */
 
    if (hWndPrev == HWND_BOTTOM)
    {
        /* Link in the bottom of the list */
        PWND WndInsertAfter;
 
        WndInsertAfter = Wnd->spwndParent->spwndChild;
        while (WndInsertAfter && WndInsertAfter->spwndNext)
        {
            WndInsertAfter = WndInsertAfter->spwndNext;
        }
 
        IntLinkWindow(Wnd, WndInsertAfter);
        Wnd->ExStyle &= ~WS_EX_TOPMOST;
    }
    else if (hWndPrev == HWND_TOPMOST)
    {
        /* Link in the top of the list */
        IntLinkWindow(Wnd, NULL);
        Wnd->ExStyle |= WS_EX_TOPMOST;
    }
    else if (hWndPrev == HWND_TOP)
    {
        /* Link it after the last topmost window */
        PWND WndInsertBefore;
 
        WndInsertBefore = Wnd->spwndParent->spwndChild;
 
        if (!(Wnd->ExStyle & WS_EX_TOPMOST))  /* put it above the first non-topmost window */
        {
            while (WndInsertBefore != NULL && WndInsertBefore->spwndNext != NULL)
            {
                if (!(WndInsertBefore->ExStyle & WS_EX_TOPMOST))
                    break;
 
                if (WndInsertBefore == Wnd->spwndOwner)  /* keep it above owner */
                {
                    Wnd->ExStyle |= WS_EX_TOPMOST;
                    break;
                }
                WndInsertBefore = WndInsertBefore->spwndNext;
            }
        }
 
        IntLinkWindow(Wnd, WndInsertBefore ? WndInsertBefore->spwndPrev : NULL);
    }
    else
    {
        /* Link it after hWndPrev */
        PWND WndInsertAfter;
 
        WndInsertAfter = UserGetWindowObject(hWndPrev);
        /* Are we called with an erroneous handle */
        if (WndInsertAfter == NULL)
        {
            /* Link in a default position */
            IntLinkHwnd(Wnd, HWND_TOP);
            return;
        }
 
        if (Wnd == WndInsertAfter)
        {
            ERR("Trying to link window 0x%p to itself\n", Wnd);
            ASSERT(WndInsertAfter != Wnd);
            // FIXME: IntUnlinkWindow(Wnd) was already called. Continuing as is seems wrong!
        }
        else
        {
            IntLinkWindow(Wnd, WndInsertAfter);
        }
 
        /* Fix the WS_EX_TOPMOST flag */
        if (!(WndInsertAfter->ExStyle & WS_EX_TOPMOST))
        {
            Wnd->ExStyle &= ~WS_EX_TOPMOST;
        }
        else
        {
            if (WndInsertAfter->spwndNext &&
                (WndInsertAfter->spwndNext->ExStyle & WS_EX_TOPMOST))
            {
                Wnd->ExStyle |= WS_EX_TOPMOST;
            }
        }
    }
    Wnd->ExStyle2 |= WS_EX2_LINKED;
}

Referenced by co_IntSetParent(), co_UserCreateWindowEx(), co_WinPosSetWindowPos(), IntImeSetTopMost(), and IntLinkHwnd().

IntMapWindowPoints()

INT FASTCALL IntMapWindowPoints	(	PWND	FromWnd,
		PWND	ToWnd,
		LPPOINT	lpPoints,
		UINT	cPoints
	)

Definition at line 144 of file winpos.c.

{
    BOOL mirror_from, mirror_to;
    POINT Delta;
    UINT i;
    int Change = 1;
 
    /* Note: Desktop Top and Left is always 0! */
    Delta.x = Delta.y = 0;
    mirror_from = mirror_to = FALSE;
 
    if (FromWnd && !UserIsDesktopWindow(FromWnd))
    {
       if (FromWnd->ExStyle & WS_EX_LAYOUTRTL)
       {
          mirror_from = TRUE;
          Change = -Change;
          Delta.x = -FromWnd->rcClient.right;
       }
       else
          Delta.x = FromWnd->rcClient.left;
       Delta.y = FromWnd->rcClient.top;
    }
 
    if (ToWnd && !UserIsDesktopWindow(ToWnd))
    {
       if (ToWnd->ExStyle & WS_EX_LAYOUTRTL)
       {
          mirror_to = TRUE;
          Change = -Change;
          Delta.x += Change * ToWnd->rcClient.right;
       }
       else
          Delta.x -= Change * ToWnd->rcClient.left;
       Delta.y -= ToWnd->rcClient.top;
    }
 
    for (i = 0; i != cPoints; i++)
    {
        lpPoints[i].x += Delta.x;
        lpPoints[i].x *= Change;
        lpPoints[i].y += Delta.y;
    }
 
    if ((mirror_from || mirror_to) && cPoints == 2)  /* special case for rectangle */
    {
       int tmp = min(lpPoints[0].x, lpPoints[1].x);
       lpPoints[1].x = max(lpPoints[0].x, lpPoints[1].x);
       lpPoints[0].x = tmp;
    }
 
    return MAKELONG(LOWORD(Delta.x), LOWORD(Delta.y));
}

Referenced by DefWndDoSizeMove(), and DefWndHandleWindowPosChanged().

IntNotifyImeShowStatus()

VOID FASTCALL IntNotifyImeShowStatus

(

_In_ PWND

pImeWnd

)

Definition at line 2447 of file ime.c.

{
    PIMEUI pimeui;
    PWND pWnd;
    PTHREADINFO pti, ptiIME;
    BOOL bShow, bSendNotify = FALSE;
    IMEUI SafeImeUI;
 
    if (!IS_IMM_MODE() || (pImeWnd->state2 & WNDS2_INDESTROY))
        return;
 
    pti = PsGetCurrentThreadWin32Thread();
    ptiIME = pImeWnd->head.pti;
 
    pimeui = IntGetImeUIFromWnd(pImeWnd);
    if (!pimeui)
    {
        ERR("Invalid IMEWND %p\n", pImeWnd);
        return;
    }
 
    // Attach to the process if necessary
    if (pti != ptiIME)
        KeAttachProcess(&(ptiIME->ppi->peProcess->Pcb));
 
    // Get an IMEUI and check whether hwndIMC is valid and update fShowStatus
    _SEH2_TRY
    {
        ProbeForWrite(pimeui, sizeof(*pimeui), 1);
        SafeImeUI = *pimeui;
 
        bShow = (gfIMEShowStatus == TRUE) && SafeImeUI.fCtrlShowStatus;
 
        pWnd = ValidateHwndNoErr(SafeImeUI.hwndIMC);
        if (!pWnd)
            pWnd = ptiIME->MessageQueue->spwndFocus;
 
        if (pWnd)
        {
            bSendNotify = TRUE;
            pimeui->fShowStatus = bShow;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("Exception in IntNotifyImeShowStatus: %p, %p, %p, %d, %d\n",
            pImeWnd, pimeui, ptiIME, SafeImeUI.fCtrlShowStatus, gfIMEShowStatus);
 
        if (pti != ptiIME)
            KeDetachProcess();
 
        _SEH2_YIELD(return);
    }
    _SEH2_END;
 
    // Detach from the process if necessary
    if (pti != ptiIME)
        KeDetachProcess();
 
    if (bSendNotify)
        IntSendOpenStatusNotify(ptiIME, &SafeImeUI, pWnd, bShow);
 
    if (!(pImeWnd->state2 & WNDS2_INDESTROY))
        IntCheckImeShowStatus(pImeWnd, NULL);
}

Referenced by IntBroadcastImeShowStatusChange().

IntNotifyWinEvent()

VOID FASTCALL IntNotifyWinEvent	(	DWORD	Event,
		PWND	pWnd,
		LONG	idObject,
		LONG	idChild,
		DWORD	flags
	)

Definition at line 178 of file event.c.

{
   PEVENTHOOK pEH;
   PLIST_ENTRY ListEntry;
   PTHREADINFO pti, ptiCurrent;
   USER_REFERENCE_ENTRY Ref;
 
   TRACE("IntNotifyWinEvent GlobalEvents = %p pWnd %p\n", GlobalEvents, pWnd);
 
   if (!GlobalEvents || !GlobalEvents->Counts) return;
 
   if (pWnd && pWnd->state & WNDS_DESTROYED) return;
 
   ptiCurrent = PsGetCurrentThreadWin32Thread();
 
   if (pWnd && flags & WEF_SETBYWNDPTI)
      pti = pWnd->head.pti;
   else
      pti = ptiCurrent;
 
   ListEntry = GlobalEvents->Events.Flink;
   ASSERT(ListEntry != &GlobalEvents->Events);
   while (ListEntry != &GlobalEvents->Events)
   {
     pEH = CONTAINING_RECORD(ListEntry, EVENTHOOK, Chain);
     ListEntry = ListEntry->Flink;
 
     // Must be inside the event window.
     if ( Event >= pEH->eventMin && Event <= pEH->eventMax )
     {
     // if all process || all thread || other thread same process
     // if ^skip own thread && ((Pid && CPid == Pid && ^skip own process) || all process)
        if (!( (pEH->idProcess && pEH->idProcess != PtrToUint(pti->pEThread->Cid.UniqueProcess)) ||
               (pEH->Flags & WINEVENT_SKIPOWNPROCESS && pEH->head.pti->ppi == pti->ppi) ||
               (pEH->idThread && pEH->idThread != PtrToUint(pti->pEThread->Cid.UniqueThread)) ||
               (pEH->Flags & WINEVENT_SKIPOWNTHREAD && pEH->head.pti == pti) ||
                pEH->head.pti->rpdesk != ptiCurrent->rpdesk ) ) // Same as hooks.
        {
           UserRefObjectCo(pEH, &Ref);
           if (pEH->Flags & WINEVENT_INCONTEXT)
           {
              TRACE("In       Event 0x%x, idObject %d hwnd %p\n", Event, idObject, pWnd ? UserHMGetHandle(pWnd) : NULL);
              co_IntCallEventProc( UserHMGetHandle(pEH),
                                   Event,
                                   pWnd ? UserHMGetHandle(pWnd) : NULL,
                                   idObject,
                                   idChild,
                                   PtrToUint(NtCurrentTeb()->ClientId.UniqueThread),
                                   EngGetTickCount32(),
                                   pEH->Proc,
                                   pEH->ihmod,
                                   pEH->offPfn);
           }
           else
           {
              TRACE("Out      Event 0x%x, idObject %d hwnd %p\n", Event, idObject, pWnd ? UserHMGetHandle(pWnd) : NULL);
              IntCallLowLevelEvent( pEH,
                                    Event,
                                    pWnd ? UserHMGetHandle(pWnd) : NULL,
                                    idObject,
                                    idChild,
                                    PtrToUint(NtCurrentTeb()->ClientId.UniqueThread));
           }
           UserDerefObjectCo(pEH);
        }
     }
   }
}

Referenced by co_IntDestroyCaret(), co_IntHideCaret(), co_IntProcessMouseMessage(), co_IntSetActiveWindow(), co_IntSetCaretPos(), co_IntSetParent(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserSetCapture(), co_UserShowCaret(), co_WinPosSetWindowPos(), co_WinPosShowWindow(), DefWndDoSizeMove(), DIALOG_CreateIndirect(), IntDefWindowProc(), IntEnableWindow(), IntSendFocusMessages(), IntSetScrollInfo(), MENU_ExitTracking(), MENU_InitTracking(), MENU_ShowPopup(), MENU_TrackMenu(), NtUserCallHwndParam(), NtUserCreateCaret(), NtUserNotifyWinEvent(), and RealDefWindowProcA().

IntSetStyle()

ULONG FASTCALL IntSetStyle	(	PWND	pwnd,
		ULONG	set_bits,
		ULONG	clear_bits
	)

Definition at line 144 of file window.c.

{
    ULONG styleOld, styleNew;
    styleOld = pwnd->style;
    styleNew = (pwnd->style | set_bits) & ~clear_bits;
    if (styleNew == styleOld) return styleNew;
    pwnd->style = styleNew;
    if ((styleOld ^ styleNew) & WS_VISIBLE) // State Change.
    {
       if (styleOld & WS_VISIBLE) pwnd->head.pti->cVisWindows--;
       if (styleNew & WS_VISIBLE) pwnd->head.pti->cVisWindows++;
       DceResetActiveDCEs( pwnd );
    }
    return styleOld;
}

Referenced by co_UserCreateWindowEx(), co_UserShowScrollBar(), co_WinPosMinMaximize(), co_WinPosShowWindow(), DefWndDoSizeMove(), IntDefWindowProc(), IntEnableWindow(), and IntForceMinimizeWindow().

IntShowOwnedPopups()

BOOL FASTCALL IntShowOwnedPopups	(	PWND	owner,
		BOOL	fShow
	)

Definition at line 4654 of file window.c.

{
   int count = 0;
   PWND pWnd;
   HWND *win_array;
 
//   ASSERT(OwnerWnd);
 
   TRACE("Enter ShowOwnedPopups Show: %s\n", (fShow ? "TRUE" : "FALSE"));
 
   /* NOTE: Popups are not children */
   win_array = IntWinListOwnedPopups(OwnerWnd);
 
   if (!win_array)
      return TRUE;
 
   while (win_array[count])
      count++;
   while (--count >= 0)
   {
      if (!(pWnd = ValidateHwndNoErr( win_array[count] )))
         continue;
      ASSERT(pWnd->spwndOwner == OwnerWnd);
 
      if (fShow)
      {
         if (pWnd->state & WNDS_HIDDENPOPUP)
         {
            /* In Windows, ShowOwnedPopups(TRUE) generates
             * WM_SHOWWINDOW messages with SW_PARENTOPENING,
             * regardless of the state of the owner
             */
            co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING);
            pWnd->state &= ~WNDS_HIDDENPOPUP;
            continue;
         }
      }
      else
      {
         if (pWnd->style & WS_VISIBLE)
         {
            /* In Windows, ShowOwnedPopups(FALSE) generates
             * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
             * regardless of the state of the owner
             */
            co_IntSendMessage(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
            pWnd->state |= WNDS_HIDDENPOPUP;
            continue;
         }
      }
   }
   ExFreePoolWithTag(win_array, USERTAG_WINDOWLIST);
   TRACE("Leave ShowOwnedPopups\n");
   return TRUE;
}

Referenced by co_WinPosMinMaximize(), co_WinPosShowWindow(), DefWndHandleSysCommand(), and NtUserCallTwoParam().

IntUnlinkWindow()

VOID FASTCALL IntUnlinkWindow

(

PWND

Wnd

)

Definition at line 1355 of file window.c.

{
    ASSERT(Wnd != Wnd->spwndNext);
    ASSERT(Wnd != Wnd->spwndPrev);
 
    if (Wnd->spwndNext)
        WndSetPrev(Wnd->spwndNext, Wnd->spwndPrev);
 
    if (Wnd->spwndPrev)
        WndSetNext(Wnd->spwndPrev, Wnd->spwndNext);
 
    if (Wnd->spwndParent && Wnd->spwndParent->spwndChild == Wnd)
        WndSetChild(Wnd->spwndParent, Wnd->spwndNext);
 
    WndSetPrev(Wnd, NULL);
    WndSetNext(Wnd, NULL);
}

Referenced by co_IntSetParent(), co_UserFreeWindow(), IntImeSetTopMost(), and IntLinkHwnd().

IntWantImeWindow()

BOOL FASTCALL IntWantImeWindow

(

_In_ PWND

pwndTarget

)

Definition at line 2024 of file ime.c.

{
    PDESKTOP rpdesk;
    PWINSTATION_OBJECT rpwinstaParent;
    PWND pwndNode, pwndParent = pwndTarget->spwndParent;
 
    if (gptiCurrent->TIF_flags & TIF_DISABLEIME)
        return FALSE;
 
    if (IS_WND_IMELIKE(pwndTarget))
        return FALSE;
 
    if (pwndTarget->fnid == FNID_DESKTOP || pwndTarget->fnid == FNID_MESSAGEWND)
        return FALSE;
 
    if (pwndTarget->state & WNDS_SERVERSIDEWINDOWPROC)
        return FALSE;
 
    rpdesk = pwndTarget->head.rpdesk;
    if (!rpdesk)
        return FALSE;
 
    rpwinstaParent = rpdesk->rpwinstaParent;
    if (!rpwinstaParent || (rpwinstaParent->Flags & WSS_NOIO))
        return FALSE;
 
    for (pwndNode = pwndParent; pwndNode; pwndNode = pwndNode->spwndParent)
    {
        if (rpdesk != pwndNode->head.rpdesk)
            break;
 
        if (pwndNode == rpdesk->spwndMessage)
            return FALSE;
    }
 
    return TRUE;
}

Referenced by co_UserCreateWindowEx().

IntWinListChildren()

HWND *FASTCALL IntWinListChildren

(

PWND

Window

)

Definition at line 275 of file window.c.

{
    PWND Child;
    HWND *List;
    UINT Index, NumChildren = 0;
 
    if (!Window) return NULL;
 
    for (Child = Window->spwndChild; Child; Child = Child->spwndNext)
    {
        ++NumChildren;
    }
 
    List = ExAllocatePoolWithTag(PagedPool, (NumChildren + 1) * sizeof(HWND), USERTAG_WINDOWLIST);
    if(!List)
    {
        ERR("Failed to allocate memory for children array\n");
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    Index = 0;
    for (Child = Window->spwndChild; Child; Child = Child->spwndNext)
    {
        List[Index++] = UserHMGetHandle(Child);
    }
    List[Index] = NULL;
 
    return List;
}

Referenced by co_IntPaintWindows(), co_IntSendActivateMessages(), co_IntSendMessageTimeout(), co_UserFreeWindow(), co_WinPosSearchChildren(), IntChildWindowFromPointEx(), IntClientShutdown(), IntDeactivateWindow(), IntFindWindow(), IntRealChildWindowFromPoint(), IntSendDestroyMsg(), NtUserBuildHwndList(), NtUserFindWindowEx(), NtUserMessageCall(), SpiNotifyNCMetricsChanged(), UserPostMessage(), UserRegisterUserApiHook(), UserSendNotifyMessage(), and WinPosDoOwnedPopups().

IntWinListOwnedPopups()

HWND *FASTCALL IntWinListOwnedPopups

(

PWND

Window

)

Definition at line 316 of file window.c.

{
    PWND Child, Desktop;
    HWND *List;
    UINT Index, NumOwned = 0;
 
    Desktop = co_GetDesktopWindow(Window);
    if (!Desktop)
        return NULL;
 
    for (Child = Desktop->spwndChild; Child; Child = Child->spwndNext)
    {
        if (Child->spwndOwner == Window && !IntWndIsDefaultIme(Child))
            ++NumOwned;
    }
 
    List = ExAllocatePoolWithTag(PagedPool, (NumOwned + 1) * sizeof(HWND), USERTAG_WINDOWLIST);
    if (!List)
    {
        ERR("Failed to allocate memory for children array\n");
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }
 
    Index = 0;
    for (Child = Desktop->spwndChild; Child; Child = Child->spwndNext)
    {
        if (Child->spwndOwner == Window && !IntWndIsDefaultIme(Child))
            List[Index++] = UserHMGetHandle(Child);
    }
    List[Index] = NULL;
 
    return List;
}

Referenced by IntDestroyOwnedWindows(), and IntShowOwnedPopups().

ReplaceWndPtr()

static VOID ReplaceWndPtr ( _Inout_ PWND *  ppwnd, _In_opt_ PWND  pwndNew  )

inlinestatic

Definition at line 130 of file window.h.

{
    /* First reference the new one */
    if (pwndNew != NULL)
    {
        UserReferenceObject(pwndNew);
    }
 
    /* Then dereference the previous one */
    if (*ppwnd != NULL)
    {
        UserDereferenceObject(*ppwnd);
    }
 
    /* And set */
    *ppwnd = pwndNew;
}

Referenced by WndSetChild(), WndSetLastActive(), WndSetNext(), WndSetOwner(), WndSetParent(), and WndSetPrev().

UserUpdateUiState()

BOOL FASTCALL UserUpdateUiState	(	PWND	Wnd,
		WPARAM	wParam
	)

Definition at line 40 of file window.c.

{
    WORD Action = LOWORD(wParam);
    WORD Flags = HIWORD(wParam);
 
    if (Flags & ~(UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    switch (Action)
    {
        case UIS_INITIALIZE:
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
 
        case UIS_SET:
            if (Flags & UISF_HIDEFOCUS)
                Wnd->HideFocus = TRUE;
            if (Flags & UISF_HIDEACCEL)
                Wnd->HideAccel = TRUE;
            break;
 
        case UIS_CLEAR:
            if (Flags & UISF_HIDEFOCUS)
                Wnd->HideFocus = FALSE;
            if (Flags & UISF_HIDEACCEL)
                Wnd->HideAccel = FALSE;
            break;
    }
 
    return TRUE;
}

Referenced by NtUserCallTwoParam().

ValidateHwndNoErr()

PWND FASTCALL ValidateHwndNoErr

(

HWND

hWnd

)

Definition at line 108 of file window.c.

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

VerifyWnd()

PWND FASTCALL VerifyWnd

(

PWND

pWnd

)

Definition at line 88 of file window.c.

{
    ULONG Error;
 
    if (!pWnd ||
        (pWnd->state & WNDS_DESTROYED) ||
        (pWnd->state2 & WNDS2_INDESTROY))
    {
        return NULL;
    }
 
    Error = EngGetLastError();
 
    if (UserObjectInDestroy(UserHMGetHandle(pWnd)))
        pWnd = NULL;
 
    EngSetLastError(Error);
    return pWnd;
}

Referenced by ActivateOtherWindowMin(), co_IntMakeWindowActive(), co_IntSetActiveWindow(), co_IntSetForegroundMessageQueue(), co_WinPosShowWindow(), IntActivateWindow(), IntDispatchMessage(), IntSendParentNotify(), MENU_TrackMenu(), UserSetActiveWindow(), and VIS_ComputeVisibleRegion().

WndSetChild()

static VOID WndSetChild ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndChild  )

inlinestatic

Definition at line 164 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndChild, pwndChild);
}

Referenced by co_UserFreeWindow(), IntLinkWindow(), and IntUnlinkWindow().

WndSetLastActive()

static VOID WndSetLastActive ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndLastActive  )

inlinestatic

Definition at line 185 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndLastActive, pwndLastActive);
}

Referenced by co_IntMakeWindowActive(), co_UserDestroyWindow(), co_UserFreeWindow(), and IntCreateWindow().

WndSetNext()

static VOID WndSetNext ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndNext  )

inlinestatic

Definition at line 171 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndNext, pwndNext);
}

Referenced by IntLinkWindow(), and IntUnlinkWindow().

WndSetOwner()

static VOID WndSetOwner ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndOwner  )

inlinestatic

Definition at line 150 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndOwner, pwndOwner);
}

Referenced by co_UserFreeWindow(), IntCreateWindow(), IntDestroyOwnedWindows(), IntImeCanDestroyDefIME(), IntImeSetFutureOwner(), IntSetOwner(), and NtUserSetImeOwnerWindow().

WndSetParent()

static VOID WndSetParent ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndParent  )

inlinestatic

Definition at line 157 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndParent, pwndParent);
}

Referenced by co_IntSetParent(), co_UserFreeWindow(), and IntCreateWindow().

WndSetPrev()

static VOID WndSetPrev ( _Inout_ PWND  pwnd, _In_opt_ PWND  pwndPrev  )

inlinestatic

Definition at line 178 of file window.h.

{
    ReplaceWndPtr(&pwnd->spwndPrev, pwndPrev);
}

Referenced by IntLinkWindow(), and IntUnlinkWindow().

Variable Documentation

AtomFlashWndState

ATOM AtomFlashWndState

extern

Definition at line 22 of file ntuser.c.

Referenced by InitUserAtoms(), and IntFlashWindowEx().

AtomLayer

ATOM AtomLayer

extern

Definition at line 21 of file ntuser.c.

Referenced by GetLayeredStatus(), InitUserAtoms(), IntSetLayeredWindowAttributes(), NtUserGetLayeredWindowAttributes(), and SetLayeredStatus().

AtomMessage

ATOM AtomMessage

extern

Definition at line 19 of file ntuser.c.

Referenced by InitUserAtoms().

AtomWndObj

ATOM AtomWndObj

extern

Definition at line 20 of file ntuser.c.

Referenced by EngCreateWnd(), EngDeleteWnd(), InitUserAtoms(), IntEngWindowChanged(), and UserGethWnd().

g_bWindowSnapEnabled

BOOL g_bWindowSnapEnabled

extern

Definition at line 20 of file sysparams.c.

Referenced by DefWndDoSizeMove(), IntDefWindowProc(), IsSnapEnabled(), SpiGetSet(), and SpiUpdatePerUserSystemParameters().

gfIMEShowStatus

BOOL gfIMEShowStatus

extern

Definition at line 24 of file ime.c.

Referenced by IntBroadcastImeShowStatusChange(), IntNotifyImeShowStatus(), and NtUserCallNoParam().

gpwlCache

PWINDOWLIST gpwlCache

extern

Definition at line 19 of file window.c.

Referenced by IntBuildHwndList(), IntFreeHwndList(), and UserProcessDestroy().

gpwlList

PWINDOWLIST gpwlList

extern

Definition at line 18 of file window.c.

Referenced by ExitThreadCallback(), IntBuildHwndList(), and IntFreeHwndList().