ReactOS  0.4.14-dev-98-gb0d4763
window.c File Reference
#include <win32k.h>
Include dependency graph for window.c:

Go to the source code of this file.

Classes

struct  HEADCOMBO
 
struct  _WND2CBOX
 
struct  LB_DESCR
 
struct  _WND2LB
 

Macros

#define IS_DEFAULT(x)   ((x) == CW_USEDEFAULT || (x) == (SHORT)0x8000)
 
#define CBF_BUTTONDOWN   0x0002
 
#define GWLP_CONSOLE_LEADER_PID   0
 
#define GWLP_CONSOLE_LEADER_TID   4
 

Typedefs

typedef struct HEADCOMBOLPHEADCOMBO
 
typedef struct _WND2CBOX WND2CBOX
 
typedef struct _WND2CBOXPWND2CBOX
 
typedef struct _WND2LB WND2LB
 
typedef struct _WND2LBPWND2LB
 

Functions

 DBG_DEFAULT_CHANNEL (UserWnd)
 
BOOL FASTCALL UserUpdateUiState (PWND Wnd, WPARAM wParam)
 
PWND FASTCALL IntGetWindowObject (HWND hWnd)
 
PWND FASTCALL VerifyWnd (PWND pWnd)
 
PWND FASTCALL ValidateHwndNoErr (HWND hWnd)
 
PWND FASTCALL UserGetWindowObject (HWND hWnd)
 
ULONG FASTCALL IntSetStyle (PWND pwnd, ULONG set_bits, ULONG clear_bits)
 
BOOL FASTCALL IntIsWindow (HWND hWnd)
 
BOOL FASTCALL IntIsWindowVisible (PWND Wnd)
 
PWND FASTCALL IntGetParent (PWND Wnd)
 
BOOL FASTCALL IntEnableWindow (HWND hWnd, BOOL bEnable)
 
HWND *FASTCALL IntWinListChildren (PWND Window)
 
HWND *FASTCALL IntWinListOwnedPopups (PWND Window)
 
PWND FASTCALL IntGetNonChildAncestor (PWND pWnd)
 
BOOL FASTCALL IntIsTopLevelWindow (PWND pWnd)
 
BOOL FASTCALL IntValidateOwnerDepth (PWND Wnd, PWND Owner)
 
HWND FASTCALL IntGetWindow (HWND hWnd, UINT uCmd)
 
DWORD FASTCALL IntGetWindowContextHelpId (PWND pWnd)
 
VOID FASTCALL IntRemoveTrackMouseEvent (PDESKTOP pDesk)
 
static void IntSendDestroyMsg (HWND hWnd)
 
static VOID UserFreeWindowInfo (PTHREADINFO ti, PWND Wnd)
 
LRESULT co_UserFreeWindow (PWND Window, PPROCESSINFO ProcessData, PTHREADINFO ThreadData, BOOLEAN SendMessages)
 
WNDPROC FASTCALL IntGetWindowProc (PWND pWnd, BOOL Ansi)
 
static WNDPROC IntSetWindowProc (PWND pWnd, WNDPROC NewWndProc, BOOL Ansi)
 
BOOL FASTCALL IntIsChildWindow (PWND Parent, PWND BaseWindow)
 
VOID FASTCALL IntLinkWindow (PWND Wnd, PWND WndInsertAfter)
 
VOID FASTCALL IntLinkHwnd (PWND Wnd, HWND hWndPrev)
 
VOID FASTCALL IntProcessOwnerSwap (PWND Wnd, PWND WndNewOwner, PWND WndOldOwner)
 
HWND FASTCALL IntSetOwner (HWND hWnd, HWND hWndNewOwner)
 
PWND FASTCALL co_IntSetParent (PWND Wnd, PWND WndNewParent)
 
HWND FASTCALL co_UserSetParent (HWND hWndChild, HWND hWndNewParent)
 
VOID FASTCALL IntUnlinkWindow (PWND Wnd)
 
NTSTATUS APIENTRY NtUserBuildHwndList (HDESK hDesktop, HWND hwndParent, BOOLEAN bChildren, ULONG dwThreadId, ULONG lParam, HWND *pWnd, ULONG *pBufSize)
 
static void IntSendParentNotify (PWND pWindow, UINT msg)
 
void FASTCALL IntFixWindowCoordinates (CREATESTRUCTW *Cs, PWND ParentWindow, DWORD *dwShowMode)
 
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)
 
NTSTATUS NTAPI ProbeAndCaptureLargeString (OUT PLARGE_STRING plstrSafe, IN PLARGE_STRING plstrUnsafe)
 
HWND NTAPI NtUserCreateWindowEx (DWORD dwExStyle, PLARGE_STRING plstrClassName, PLARGE_STRING plstrClsVersion, PLARGE_STRING plstrWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam, DWORD dwFlags, PVOID acbiBuffer)
 
BOOLEAN co_UserDestroyWindow (PVOID Object)
 
BOOLEAN APIENTRY NtUserDestroyWindow (HWND Wnd)
 
static HWND FASTCALL IntFindWindow (PWND Parent, PWND ChildAfter, RTL_ATOM ClassAtom, PUNICODE_STRING WindowName)
 
HWND APIENTRY NtUserFindWindowEx (HWND hwndParent, HWND hwndChildAfter, PUNICODE_STRING ucClassName, PUNICODE_STRING ucWindowName, DWORD dwUnknown)
 
PWND FASTCALL UserGetAncestor (PWND Wnd, UINT Type)
 
HWND APIENTRY NtUserGetAncestor (HWND hWnd, UINT Type)
 
BOOL APIENTRY NtUserGetComboBoxInfo (HWND hWnd, PCOMBOBOXINFO pcbi)
 
DWORD APIENTRY NtUserGetListBoxInfo (HWND hWnd)
 
HWND APIENTRY NtUserSetParent (HWND hWndChild, HWND hWndNewParent)
 
HWND FASTCALL UserGetShellWindow (VOID)
 
BOOL APIENTRY NtUserSetShellWindowEx (HWND hwndShell, HWND hwndListView)
 
static BOOL FASTCALL IntCheckFrameEdge (ULONG Style, ULONG ExStyle)
 
static LONG_PTR co_IntSetWindowLongPtr (HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi, ULONG Size, BOOL bAlter)
 
LONG FASTCALL co_UserSetWindowLong (HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
 
LONG_PTR FASTCALL co_UserSetWindowLongPtr (HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi)
 
LONG APIENTRY NtUserSetWindowLong (HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
 
DWORD APIENTRY NtUserAlterWindowStyle (HWND hWnd, DWORD Index, LONG NewValue)
 
WORD APIENTRY NtUserSetWindowWord (HWND hWnd, INT Index, WORD NewValue)
 
DWORD_PTR APIENTRY NtUserQueryWindow (HWND hWnd, DWORD Index)
 
UINT APIENTRY NtUserRegisterWindowMessage (PUNICODE_STRING MessageNameUnsafe)
 
BOOL APIENTRY NtUserSetWindowFNID (HWND hWnd, WORD fnID)
 
BOOL APIENTRY DefSetText (PWND Wnd, PCWSTR WindowText)
 
BOOL APIENTRY NtUserDefSetText (HWND hWnd, PLARGE_STRING WindowText)
 
INT APIENTRY NtUserInternalGetWindowText (HWND hWnd, LPWSTR lpString, INT nMaxCount)
 
BOOL FASTCALL IntShowOwnedPopups (PWND OwnerWnd, BOOL fShow)
 

Variables

INT gNestedWindowLimit = 50
 

Macro Definition Documentation

◆ CBF_BUTTONDOWN

#define CBF_BUTTONDOWN   0x0002

Definition at line 3267 of file window.c.

◆ GWLP_CONSOLE_LEADER_PID

#define GWLP_CONSOLE_LEADER_PID   0

◆ GWLP_CONSOLE_LEADER_TID

#define GWLP_CONSOLE_LEADER_TID   4

◆ IS_DEFAULT

#define IS_DEFAULT (   x)    ((x) == CW_USEDEFAULT || (x) == (SHORT)0x8000)

Typedef Documentation

◆ LPHEADCOMBO

◆ PWND2CBOX

◆ PWND2LB

typedef struct _WND2LB * PWND2LB

◆ WND2CBOX

◆ WND2LB

Function Documentation

◆ co_IntSetParent()

PWND FASTCALL co_IntSetParent ( PWND  Wnd,
PWND  WndNewParent 
)

Definition at line 1109 of file window.c.

1110 {
1111  PWND WndOldParent, pWndExam;
1112  BOOL WasVisible;
1113  POINT pt;
1114  int swFlags = SWP_NOSIZE|SWP_NOZORDER;
1115 
1116  ASSERT(Wnd);
1117  ASSERT(WndNewParent);
1118  ASSERT_REFS_CO(Wnd);
1119  ASSERT_REFS_CO(WndNewParent);
1120 
1121  if (Wnd == Wnd->head.rpdesk->spwndMessage)
1122  {
1124  return( NULL);
1125  }
1126 
1127  /* Some applications try to set a child as a parent */
1128  if (IntIsChildWindow(Wnd, WndNewParent))
1129  {
1130  TRACE("IntSetParent try to set a child as a parent.\n");
1132  return NULL;
1133  }
1134 
1135  pWndExam = WndNewParent; // Load parent Window to examine.
1136  // Now test for set parent to parent hit.
1137  while (pWndExam)
1138  {
1139  if (Wnd == pWndExam)
1140  {
1141  TRACE("IntSetParent Failed Test for set parent to parent!\n");
1143  return NULL;
1144  }
1145  pWndExam = pWndExam->spwndParent;
1146  }
1147 
1148  /*
1149  * Windows hides the window first, then shows it again
1150  * including the WM_SHOWWINDOW messages and all
1151  */
1152  WasVisible = co_WinPosShowWindow(Wnd, SW_HIDE);
1153 
1154  /* Window must belong to current process */
1155  if (Wnd->head.pti->ppi != PsGetCurrentProcessWin32Process())
1156  {
1157  ERR("IntSetParent Window must belong to current process!\n");
1158  return NULL;
1159  }
1160 
1161  WndOldParent = Wnd->spwndParent;
1162 
1163  if ( WndOldParent &&
1164  WndOldParent->ExStyle & WS_EX_LAYOUTRTL)
1165  pt.x = Wnd->rcWindow.right;
1166  else
1167  pt.x = Wnd->rcWindow.left;
1168  pt.y = Wnd->rcWindow.top;
1169 
1170  IntScreenToClient(WndOldParent, &pt);
1171 
1172  if (WndOldParent) UserReferenceObject(WndOldParent); /* Caller must deref */
1173 
1174  if (WndNewParent != WndOldParent)
1175  {
1176  /* Unlink the window from the siblings list */
1177  IntUnlinkWindow(Wnd);
1178  Wnd->ExStyle2 &= ~WS_EX2_LINKED;
1179 
1180  /* Set the new parent */
1181  Wnd->spwndParent = WndNewParent;
1182 
1183  if ( Wnd->style & WS_CHILD &&
1184  Wnd->spwndOwner &&
1185  Wnd->spwndOwner->ExStyle & WS_EX_TOPMOST )
1186  {
1187  ERR("SetParent Top Most from Pop up!\n");
1188  Wnd->ExStyle |= WS_EX_TOPMOST;
1189  }
1190 
1191  /* Link the window with its new siblings */
1192  IntLinkHwnd( Wnd,
1193  ((0 == (Wnd->ExStyle & WS_EX_TOPMOST) &&
1194  UserIsDesktopWindow(WndNewParent) ) ? HWND_TOP : HWND_TOPMOST ) );
1195  }
1196 
1197  if ( WndNewParent == co_GetDesktopWindow(Wnd) &&
1198  !(Wnd->style & WS_CLIPSIBLINGS) )
1199  {
1200  Wnd->style |= WS_CLIPSIBLINGS;
1201  DceResetActiveDCEs(Wnd);
1202  }
1203 
1204  /* if parent belongs to a different thread and the window isn't */
1205  /* top-level, attach the two threads */
1206  if ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
1207  {
1208  if ( Wnd->spwndParent != co_GetDesktopWindow(Wnd))
1209  {
1210  if (WndOldParent && (Wnd->head.pti != WndOldParent->head.pti))
1211  {
1212  //ERR("SetParent Old out.\n");
1213  UserAttachThreadInput(Wnd->head.pti, WndOldParent->head.pti, FALSE);
1214  }
1215  }
1216  if ( WndNewParent != co_GetDesktopWindow(Wnd))
1217  {
1218  if (Wnd->head.pti != WndNewParent->head.pti)
1219  {
1220  //ERR("SetParent New in.\n");
1221  UserAttachThreadInput(Wnd->head.pti, WndNewParent->head.pti, TRUE);
1222  }
1223  }
1224  }
1225 
1226  if (UserIsMessageWindow(WndOldParent) || UserIsMessageWindow(WndNewParent))
1227  swFlags |= SWP_NOACTIVATE;
1228 
1229  IntNotifyWinEvent(EVENT_OBJECT_PARENTCHANGE, Wnd ,OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
1230  /*
1231  * SetParent additionally needs to make hwnd the top window
1232  * in the z-order and send the expected WM_WINDOWPOSCHANGING and
1233  * WM_WINDOWPOSCHANGED notification messages.
1234  */
1235  //ERR("IntSetParent SetWindowPos 1\n");
1236  co_WinPosSetWindowPos( Wnd,
1237  (0 == (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOP : HWND_TOPMOST),
1238  pt.x, pt.y, 0, 0, swFlags);
1239  //ERR("IntSetParent SetWindowPos 2 X %d Y %d\n",pt.x, pt.y);
1240  if (WasVisible) co_WinPosShowWindow(Wnd, SW_SHOWNORMAL);
1241 
1242  return WndOldParent;
1243 }
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
DWORD ExStyle
Definition: ntuser.h:668
#define TRUE
Definition: types.h:120
struct _DESKTOP * rpdesk
Definition: ntuser.h:189
VOID FASTCALL IntUnlinkWindow(PWND Wnd)
Definition: window.c:1306
DWORD ExStyle2
Definition: ntuser.h:709
NTSTATUS FASTCALL UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
Definition: input.c:479
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
#define WS_EX2_LINKED
Definition: ntuser.h:644
#define pt(x, y)
Definition: drawing.c:79
#define SW_HIDE
Definition: winuser.h:762
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:13
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1720
#define OBJID_WINDOW
Definition: winable.h:15
LONG top
Definition: windef.h:292
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
#define HWND_TOPMOST
Definition: winuser.h:1194
#define HWND_TOP
Definition: winuser.h:1193
#define WS_CHILD
Definition: pedump.c:617
LONG left
Definition: windef.h:291
#define SWP_NOZORDER
Definition: winuser.h:1232
LONG right
Definition: windef.h:293
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:937
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
unsigned int BOOL
Definition: ntddk_ex.h:94
#define CHILDID_SELF
Definition: winable.h:14
struct _WND * spwndOwner
Definition: ntuser.h:679
THRDESKHEAD head
Definition: ntuser.h:659
smooth NULL
Definition: ftsmooth.c:416
PWND FASTCALL co_GetDesktopWindow(PWND pWnd)
Definition: desktop.c:1330
#define WEF_SETBYWNDPTI
Definition: ntuser.h:213
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2464
#define TRACE(s)
Definition: solgame.cpp:4
#define SWP_NOACTIVATE
Definition: winuser.h:1227
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:223
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:815
#define WS_EX_TOPMOST
Definition: pedump.c:647
BOOL FASTCALL IntScreenToClient(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:212
RECT rcWindow
Definition: ntuser.h:680
#define SWP_NOSIZE
Definition: winuser.h:1230
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
#define SW_SHOWNORMAL
Definition: winuser.h:764
#define WS_POPUP
Definition: pedump.c:616
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
struct _WND * spwndParent
Definition: ntuser.h:677
BOOL FASTCALL IntIsChildWindow(PWND Parent, PWND BaseWindow)
Definition: window.c:882
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:697
DWORD style
Definition: ntuser.h:670

Referenced by co_UserSetParent().

◆ co_IntSetWindowLongPtr()

static LONG_PTR co_IntSetWindowLongPtr ( HWND  hWnd,
DWORD  Index,
LONG_PTR  NewValue,
BOOL  Ansi,
ULONG  Size,
BOOL  bAlter 
)
static

Definition at line 3635 of file window.c.

3636 {
3637  PWND Window, Parent;
3638  PWINSTATION_OBJECT WindowStation;
3639  LONG_PTR OldValue;
3641 
3642  if (!(Window = UserGetWindowObject(hWnd)))
3643  {
3644  return( 0);
3645  }
3646 
3647  if ((INT)Index >= 0)
3648  {
3649  if ((Index + Size) > Window->cbwndExtra)
3650  {
3652  return( 0);
3653  }
3654 
3655 #ifdef _WIN64
3656  if (Size == sizeof(LONG))
3657  {
3658  OldValue = *((LONG *)((PCHAR)(Window + 1) + Index));
3659  *((LONG*)((PCHAR)(Window + 1) + Index)) = (LONG)NewValue;
3660  }
3661  else
3662 #endif
3663  {
3664  OldValue = *((LONG_PTR *)((PCHAR)(Window + 1) + Index));
3665  /*
3666  if ( Index == DWLP_DLGPROC && Wnd->state & WNDS_DIALOGWINDOW)
3667  {
3668  OldValue = (LONG_PTR)IntSetWindowProc( Wnd, (WNDPROC)NewValue, Ansi);
3669  if (!OldValue) return 0;
3670  }
3671  */
3672  *((LONG_PTR*)((PCHAR)(Window + 1) + Index)) = NewValue;
3673  }
3674 
3675  }
3676  else
3677  {
3678 #ifdef _WIN64
3679  if (Size == sizeof(LONG))
3680  {
3681  if ((Index != GWL_STYLE) &&
3682  (Index != GWL_EXSTYLE) &&
3683  (Index != GWL_ID) &&
3684  (Index != GWL_USERDATA))
3685  {
3686  ERR("NtUserSetWindowLong(): Index requires pointer size: %lu\n", Index);
3688  return 0;
3689  }
3690  }
3691 #endif
3692 
3693  switch (Index)
3694  {
3695  case GWL_EXSTYLE: // LONG
3696  OldValue = (LONG) Window->ExStyle;
3697  Style.styleOld = OldValue;
3698  Style.styleNew = NewValue;
3699 
3700  co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_EXSTYLE, (LPARAM) &Style);
3701 
3702  /*
3703  * Remove extended window style bit WS_EX_TOPMOST for shell windows.
3704  */
3705  WindowStation = Window->head.pti->rpdesk->rpwinstaParent;
3706  if(WindowStation)
3707  {
3708  if (hWnd == WindowStation->ShellWindow || hWnd == WindowStation->ShellListView)
3709  Style.styleNew &= ~WS_EX_TOPMOST;
3710  }
3711  /* WS_EX_WINDOWEDGE depends on some other styles */
3712  if (IntCheckFrameEdge(Window->style, NewValue))
3713  Style.styleNew |= WS_EX_WINDOWEDGE;
3714  else
3715  Style.styleNew &= ~WS_EX_WINDOWEDGE;
3716 
3717  if (!(Window->ExStyle & WS_EX_LAYERED))
3718  {
3720  }
3721 
3722  Window->ExStyle = (DWORD)Style.styleNew;
3723 
3724  co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_EXSTYLE, (LPARAM) &Style);
3725  break;
3726 
3727  case GWL_STYLE: // LONG
3728  OldValue = (LONG) Window->style;
3729  Style.styleOld = OldValue;
3730  Style.styleNew = NewValue;
3731 
3732  if (!bAlter)
3733  co_IntSendMessage(hWnd, WM_STYLECHANGING, GWL_STYLE, (LPARAM) &Style);
3734 
3735  /* WS_CLIPSIBLINGS can't be reset on top-level windows */
3736  if (UserIsDesktopWindow(Window->spwndParent)) Style.styleNew |= WS_CLIPSIBLINGS;
3737  /* WS_MINIMIZE can't be reset */
3738  if (OldValue & WS_MINIMIZE) Style.styleNew |= WS_MINIMIZE;
3739  /* Fixes wine FIXME: changing WS_DLGFRAME | WS_THICKFRAME is supposed to change WS_EX_WINDOWEDGE too */
3740  if (IntCheckFrameEdge(NewValue, Window->ExStyle))
3741  Window->ExStyle |= WS_EX_WINDOWEDGE;
3742  else
3743  Window->ExStyle &= ~WS_EX_WINDOWEDGE;
3744 
3745  if ((OldValue & (WS_CHILD | WS_POPUP)) == WS_CHILD)
3746  {
3747  if ((NewValue & (WS_CHILD | WS_POPUP)) != WS_CHILD)
3748  {
3750  ERR("IDMenu going null! %d\n",Window->IDMenu);
3751  Window->IDMenu = 0; // Window->spmenu = 0;
3752  }
3753  }
3754  else
3755  {
3756  if ((NewValue & (WS_CHILD | WS_POPUP)) == WS_CHILD)
3757  {
3758  PMENU pMenu = UserGetMenuObject(UlongToHandle(Window->IDMenu));
3759  Window->state &= ~WNDS_HASMENU;
3760  if (pMenu)
3761  {
3762  ERR("IDMenu released 0x%p\n",pMenu);
3763  // ROS may not hold a lock after setting menu to window. But it should!
3764  //IntReleaseMenuObject(pMenu);
3765  }
3766  }
3767  }
3768 
3769  if ((Style.styleOld ^ Style.styleNew) & WS_VISIBLE)
3770  {
3771  if (Style.styleOld & WS_VISIBLE) Window->head.pti->cVisWindows--;
3772  if (Style.styleNew & WS_VISIBLE) Window->head.pti->cVisWindows++;
3774  }
3775  Window->style = (DWORD)Style.styleNew;
3776 
3777  if (!bAlter)
3778  co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_STYLE, (LPARAM) &Style);
3779  break;
3780 
3781  case GWLP_WNDPROC: // LONG_PTR
3782  {
3783  if ( Window->head.pti->ppi != PsGetCurrentProcessWin32Process() ||
3784  Window->fnid & FNID_FREED)
3785  {
3787  return( 0);
3788  }
3789  OldValue = (LONG_PTR)IntSetWindowProc(Window,
3790  (WNDPROC)NewValue,
3791  Ansi);
3792  break;
3793  }
3794 
3795  case GWLP_HINSTANCE: // LONG_PTR
3796  OldValue = (LONG_PTR) Window->hModule;
3797  Window->hModule = (HINSTANCE) NewValue;
3798  break;
3799 
3800  case GWLP_HWNDPARENT: // LONG_PTR
3801  Parent = Window->spwndParent;
3802  if (Parent && (Parent->head.h == IntGetDesktopWindow()))
3803  OldValue = (LONG_PTR) IntSetOwner(Window->head.h, (HWND) NewValue);
3804  else
3805  OldValue = (LONG_PTR) co_UserSetParent(Window->head.h, (HWND) NewValue);
3806  break;
3807 
3808  case GWLP_ID: // LONG
3809  OldValue = (LONG) Window->IDMenu;
3810  Window->IDMenu = (UINT) NewValue;
3811  break;
3812 
3813  case GWLP_USERDATA: // LONG or LONG_PTR
3814  OldValue = Window->dwUserData;
3815  Window->dwUserData = NewValue;
3816  break;
3817 
3818  default:
3819  ERR("NtUserSetWindowLong(): Unsupported index %lu\n", Index);
3821  OldValue = 0;
3822  break;
3823  }
3824  }
3825 
3826  return( OldValue);
3827 }
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
signed char * PCHAR
Definition: retypes.h:7
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
#define LONG_PTR
Definition: treelist.c:79
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
#define GWL_ID
Definition: winuser.h:853
HWND hWnd
Definition: settings.c:17
#define GWL_EXSTYLE
Definition: winuser.h:845
#define GWL_USERDATA
Definition: winuser.h:855
static WNDPROC IntSetWindowProc(PWND pWnd, WNDPROC NewWndProc, BOOL Ansi)
Definition: window.c:795
#define WS_CHILD
Definition: pedump.c:617
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:722
HWND FASTCALL IntSetOwner(HWND hWnd, HWND hWndNewOwner)
Definition: window.c:1061
#define DWORD
Definition: nt_native.h:44
int32_t INT
Definition: typedefs.h:56
HWND FASTCALL co_UserSetParent(HWND hWndChild, HWND hWndNewParent)
Definition: window.c:1246
FORCEINLINE PMENU UserGetMenuObject(HMENU hMenu)
Definition: userfuncs.h:3
Definition: window.c:29
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
#define WS_MINIMIZE
Definition: pedump.c:622
long LONG
Definition: pedump.c:60
#define GWLP_USERDATA
Definition: treelist.c:63
LONG_PTR LPARAM
Definition: windef.h:208
const DWORD Style
Definition: appswitch.c:71
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define UlongToHandle(ul)
Definition: basetsd.h:97
#define WS_EX_LAYERED
Definition: winuser.h:389
static const UCHAR Index[8]
Definition: usbohci.c:18
int Window
Definition: x11stubs.h:26
#define FNID_FREED
Definition: ntuser.h:861
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:815
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
#define WS_EX_TOPMOST
Definition: pedump.c:647
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define GWLP_WNDPROC
Definition: treelist.c:66
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2880
#define ERR(fmt,...)
Definition: debug.h:109
#define GWL_STYLE
Definition: winuser.h:846
Definition: ntuser.h:657
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1338
static BOOL FASTCALL IntCheckFrameEdge(ULONG Style, ULONG ExStyle)
Definition: window.c:3624
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define WS_POPUP
Definition: pedump.c:616
unsigned int UINT
Definition: ndis.h:50
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define GWLP_HINSTANCE
Definition: winuser.h:850
BOOL FASTCALL SetLayeredStatus(PWND pWnd, BYTE set)
Definition: layered.c:34
#define WNDS_HASMENU
Definition: ntuser.h:573
#define WS_VISIBLE
Definition: pedump.c:620
HANDLE ShellListView
Definition: winsta.h:21
#define GWLP_ID
Definition: winuser.h:854
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
HANDLE ShellWindow
Definition: winsta.h:20
#define GWLP_HWNDPARENT
Definition: winuser.h:852

Referenced by co_UserSetWindowLong(), co_UserSetWindowLongPtr(), NtUserAlterWindowStyle(), and NtUserSetWindowLong().

◆ co_UserCreateWindowEx()

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

Definition at line 1969 of file window.c.

1974 {
1975  ULONG style;
1976  PWND Window = NULL, ParentWindow = NULL, OwnerWindow;
1977  HWND hWnd, hWndParent, hWndOwner, hwndInsertAfter;
1978  PWINSTATION_OBJECT WinSta;
1979  PCLS Class = NULL;
1980  SIZE Size;
1981  POINT MaxSize, MaxPos, MinTrack, MaxTrack;
1982  CBT_CREATEWNDW * pCbtCreate;
1983  LRESULT Result;
1984  USER_REFERENCE_ENTRY ParentRef, Ref;
1985  PTHREADINFO pti;
1986  DWORD dwShowMode = SW_SHOW;
1987  CREATESTRUCTW *pCsw = NULL;
1988  PVOID pszClass = NULL, pszName = NULL;
1989  PWND ret = NULL;
1990 
1991  /* Get the current window station and reference it */
1992  pti = GetW32ThreadInfo();
1993  if (pti == NULL || pti->rpdesk == NULL)
1994  {
1995  ERR("Thread is not attached to a desktop! Cannot create window!\n");
1996  return NULL; // There is nothing to cleanup.
1997  }
1998  WinSta = pti->rpdesk->rpwinstaParent;
2000 
2001  pCsw = NULL;
2002  pCbtCreate = NULL;
2003 
2004  /* Get the class and reference it */
2005  Class = IntGetAndReferenceClass(ClassName, Cs->hInstance, FALSE);
2006  if(!Class)
2007  {
2009  ERR("Failed to find class %wZ\n", ClassName);
2010  goto cleanup;
2011  }
2012 
2013  /* Now find the parent and the owner window */
2014  hWndParent = pti->rpdesk->pDeskInfo->spwnd->head.h;
2015  hWndOwner = NULL;
2016 
2017  if (Cs->hwndParent == HWND_MESSAGE)
2018  {
2019  Cs->hwndParent = hWndParent = pti->rpdesk->spwndMessage->head.h;
2020  }
2021  else if (Cs->hwndParent)
2022  {
2023  if ((Cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
2024  hWndOwner = Cs->hwndParent;
2025  else
2026  hWndParent = Cs->hwndParent;
2027  }
2028  else if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
2029  {
2030  ERR("Cannot create a child window without a parent!\n");
2032  goto cleanup; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
2033  }
2035  (IS_INTRESOURCE(Cs->lpszClass) ||
2036  Cs->lpszClass != (LPCWSTR)MAKEINTATOM(gpsi->atomSysClass[ICLS_HWNDMESSAGE]) ||
2037  _wcsicmp(Cs->lpszClass, L"Message") != 0))
2038  {
2039  if (pti->ppi->dwLayout & LAYOUT_RTL)
2040  {
2041  Cs->dwExStyle |= WS_EX_LAYOUTRTL;
2042  }
2043  }
2044 
2045  ParentWindow = hWndParent ? UserGetWindowObject(hWndParent): NULL;
2046  OwnerWindow = hWndOwner ? UserGetWindowObject(hWndOwner): NULL;
2047 
2048  if (hWndParent && !ParentWindow)
2049  {
2050  ERR("Got invalid parent window handle\n");
2051  goto cleanup;
2052  }
2053  else if (hWndOwner && !OwnerWindow)
2054  {
2055  ERR("Got invalid owner window handle\n");
2056  ParentWindow = NULL;
2057  goto cleanup;
2058  }
2059 
2060  if(OwnerWindow)
2061  {
2062  if (IntIsDesktopWindow(OwnerWindow)) OwnerWindow = NULL;
2063  else if (ParentWindow && !IntIsDesktopWindow(ParentWindow))
2064  {
2065  ERR("an owned window must be created as top-level\n");
2067  goto cleanup;
2068  }
2069  else /* owner must be a top-level window */
2070  {
2071  while ((OwnerWindow->style & (WS_POPUP|WS_CHILD)) == WS_CHILD && !IntIsDesktopWindow(OwnerWindow->spwndParent))
2072  OwnerWindow = OwnerWindow->spwndParent;
2073  }
2074  }
2075 
2076  /* Fix the position and the size of the window */
2077  if (ParentWindow)
2078  {
2079  UserRefObjectCo(ParentWindow, &ParentRef);
2080  IntFixWindowCoordinates(Cs, ParentWindow, &dwShowMode);
2081  }
2082 
2083  /* Allocate and initialize the new window */
2084  Window = IntCreateWindow(Cs,
2085  WindowName,
2086  Class,
2087  ParentWindow,
2088  OwnerWindow,
2089  acbiBuffer,
2090  NULL,
2091  dwVer );
2092  if(!Window)
2093  {
2094  ERR("IntCreateWindow failed!\n");
2095  goto cleanup;
2096  }
2097 
2099  hwndInsertAfter = HWND_TOP;
2100 
2101  UserRefObjectCo(Window, &Ref);
2103  ObDereferenceObject(WinSta);
2104 
2106  if ( ISITHOOKED(WH_CBT) || (pti->rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CBT)) )
2107  {
2108  // Allocate the calling structures Justin Case this goes Global.
2111  if (!pCsw || !pCbtCreate)
2112  {
2113  ERR("UserHeapAlloc() failed!\n");
2114  goto cleanup;
2115  }
2116 
2117  /* Fill the new CREATESTRUCTW */
2118  RtlCopyMemory(pCsw, Cs, sizeof(CREATESTRUCTW));
2119  pCsw->style = Window->style; /* HCBT_CREATEWND needs the real window style */
2120 
2121  // Based on the assumption this is from "unicode source" user32, ReactOS, answer is yes.
2122  if (!IS_ATOM(ClassName->Buffer))
2123  {
2124  if (Window->state & WNDS_ANSICREATOR)
2125  {
2127  AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(ClassName)+sizeof(CHAR);
2128  pszClass = UserHeapAlloc(AnsiString.MaximumLength);
2129  if (!pszClass)
2130  {
2131  ERR("UserHeapAlloc() failed!\n");
2132  goto cleanup;
2133  }
2134  RtlZeroMemory(pszClass, AnsiString.MaximumLength);
2135  AnsiString.Buffer = (PCHAR)pszClass;
2137  }
2138  else
2139  {
2141  UnicodeString.MaximumLength = ClassName->Length + sizeof(UNICODE_NULL);
2142  pszClass = UserHeapAlloc(UnicodeString.MaximumLength);
2143  if (!pszClass)
2144  {
2145  ERR("UserHeapAlloc() failed!\n");
2146  goto cleanup;
2147  }
2148  RtlZeroMemory(pszClass, UnicodeString.MaximumLength);
2149  UnicodeString.Buffer = (PWSTR)pszClass;
2150  RtlCopyUnicodeString(&UnicodeString, ClassName);
2151  }
2152  pCsw->lpszClass = UserHeapAddressToUser(pszClass);
2153  }
2154  if (WindowName->Length)
2155  {
2157  Name.Buffer = WindowName->Buffer;
2158  Name.Length = (USHORT)min(WindowName->Length, MAXUSHORT); // FIXME: LARGE_STRING truncated
2159  Name.MaximumLength = (USHORT)min(WindowName->MaximumLength, MAXUSHORT);
2160 
2161  if (Window->state & WNDS_ANSICREATOR)
2162  {
2164  AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(&Name) + sizeof(CHAR);
2165  pszName = UserHeapAlloc(AnsiString.MaximumLength);
2166  if (!pszName)
2167  {
2168  ERR("UserHeapAlloc() failed!\n");
2169  goto cleanup;
2170  }
2171  RtlZeroMemory(pszName, AnsiString.MaximumLength);
2172  AnsiString.Buffer = (PCHAR)pszName;
2174  }
2175  else
2176  {
2178  UnicodeString.MaximumLength = Name.Length + sizeof(UNICODE_NULL);
2179  pszName = UserHeapAlloc(UnicodeString.MaximumLength);
2180  if (!pszName)
2181  {
2182  ERR("UserHeapAlloc() failed!\n");
2183  goto cleanup;
2184  }
2185  RtlZeroMemory(pszName, UnicodeString.MaximumLength);
2186  UnicodeString.Buffer = (PWSTR)pszName;
2188  }
2189  pCsw->lpszName = UserHeapAddressToUser(pszName);
2190  }
2191 
2192  pCbtCreate->lpcs = pCsw;
2193  pCbtCreate->hwndInsertAfter = hwndInsertAfter;
2194 
2197  if (Result != 0)
2198  {
2199  ERR("WH_CBT HCBT_CREATEWND hook failed! 0x%x\n", Result);
2200  goto cleanup;
2201  }
2202  // Write back changes.
2203  Cs->cx = pCsw->cx;
2204  Cs->cy = pCsw->cy;
2205  Cs->x = pCsw->x;
2206  Cs->y = pCsw->y;
2207  hwndInsertAfter = pCbtCreate->hwndInsertAfter;
2208  }
2209 
2210  /* NCCREATE and WM_NCCALCSIZE need the original values */
2211  Cs->lpszName = (LPCWSTR) WindowName;
2212  Cs->lpszClass = (LPCWSTR) ClassName;
2213 
2214  if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
2215  {
2216  if (ParentWindow != co_GetDesktopWindow(Window))
2217  {
2218  Cs->x += ParentWindow->rcClient.left;
2219  Cs->y += ParentWindow->rcClient.top;
2220  }
2221  }
2222 
2223  /* Send the WM_GETMINMAXINFO message */
2224  Size.cx = Cs->cx;
2225  Size.cy = Cs->cy;
2226 
2227  if ((Cs->style & WS_THICKFRAME) || !(Cs->style & (WS_POPUP | WS_CHILD)))
2228  {
2229  co_WinPosGetMinMaxInfo(Window, &MaxSize, &MaxPos, &MinTrack, &MaxTrack);
2230  if (Size.cx > MaxTrack.x) Size.cx = MaxTrack.x;
2231  if (Size.cy > MaxTrack.y) Size.cy = MaxTrack.y;
2232  if (Size.cx < MinTrack.x) Size.cx = MinTrack.x;
2233  if (Size.cy < MinTrack.y) Size.cy = MinTrack.y;
2234  }
2235 
2236  Window->rcWindow.left = Cs->x;
2237  Window->rcWindow.top = Cs->y;
2238  Window->rcWindow.right = Cs->x + Size.cx;
2239  Window->rcWindow.bottom = Cs->y + Size.cy;
2240  /*
2241  if (0 != (Window->style & WS_CHILD) && ParentWindow)
2242  {
2243  ERR("co_UserCreateWindowEx(): Offset rcWindow\n");
2244  RECTL_vOffsetRect(&Window->rcWindow,
2245  ParentWindow->rcClient.left,
2246  ParentWindow->rcClient.top);
2247  }
2248  */
2249  /* correct child window coordinates if mirroring on parent is enabled */
2250  if (ParentWindow != NULL)
2251  {
2252  if ( ((Cs->style & WS_CHILD) == WS_CHILD) &&
2253  ((ParentWindow->ExStyle & WS_EX_LAYOUTRTL) == WS_EX_LAYOUTRTL))
2254  {
2255  Window->rcWindow.right = ParentWindow->rcClient.right - (Window->rcWindow.left - ParentWindow->rcClient.left);
2256  Window->rcWindow.left = Window->rcWindow.right - Size.cx;
2257  }
2258  }
2259 
2260  Window->rcClient = Window->rcWindow;
2261 
2262  /* Link the window */
2263  if (NULL != ParentWindow)
2264  {
2265  /* Link the window into the siblings list */
2266  if ((Cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
2268  else
2269  IntLinkHwnd(Window, hwndInsertAfter);
2270  }
2271 
2272  if (!(Window->state2 & WNDS2_WIN31COMPAT))
2273  {
2274  if (Class->style & CS_PARENTDC && !(ParentWindow->style & WS_CLIPCHILDREN))
2275  Window->style &= ~(WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
2276  }
2277 
2278  if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2279  {
2280  if ( !IntIsTopLevelWindow(Window) )
2281  {
2282  if (pti != Window->spwndParent->head.pti)
2283  {
2284  //ERR("CreateWindow Parent in.\n");
2285  UserAttachThreadInput(pti, Window->spwndParent->head.pti, TRUE);
2286  }
2287  }
2288  }
2289 
2290  /* Send the NCCREATE message */
2292  if (!Result)
2293  {
2294  ERR("co_UserCreateWindowEx(): NCCREATE message failed\n");
2295  goto cleanup;
2296  }
2297 
2298  /* Send the WM_NCCALCSIZE message */
2299  {
2300  // RECT rc;
2301  MaxPos.x = Window->rcWindow.left;
2302  MaxPos.y = Window->rcWindow.top;
2303 
2304  Result = co_WinPosGetNonClientSize(Window, &Window->rcWindow, &Window->rcClient);
2305  //rc = Window->rcWindow;
2306  //Result = co_IntSendMessageNoWait(Window->head.h, WM_NCCALCSIZE, FALSE, (LPARAM)&rc);
2307  //Window->rcClient = rc;
2308 
2309  RECTL_vOffsetRect(&Window->rcWindow, MaxPos.x - Window->rcWindow.left,
2310  MaxPos.y - Window->rcWindow.top);
2311  }
2312 
2313  /* Send the WM_CREATE message. */
2315  if (Result == (LRESULT)-1)
2316  {
2317  ERR("co_UserCreateWindowEx(): WM_CREATE message failed\n");
2318  goto cleanup;
2319  }
2320 
2321  /* Send the EVENT_OBJECT_CREATE event */
2322  IntNotifyWinEvent(EVENT_OBJECT_CREATE, Window, OBJID_WINDOW, CHILDID_SELF, 0);
2323 
2324  /* By setting the flag below it can be examined to determine if the window
2325  was created successfully and a valid pwnd was passed back to caller since
2326  from here the function has to succeed. */
2328 
2329  /* Send the WM_SIZE and WM_MOVE messages. */
2330  if (!(Window->state & WNDS_SENDSIZEMOVEMSGS))
2331  {
2333  }
2334 
2335  /* Show or maybe minimize or maximize the window. */
2336 
2338  if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2339  {
2340  RECTL NewPos;
2341  UINT SwFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
2342 
2343  SwFlag = co_WinPosMinMaximize(Window, SwFlag, &NewPos);
2344  SwFlag |= SWP_NOZORDER|SWP_FRAMECHANGED; /* Frame always gets changed */
2345  if (!(style & WS_VISIBLE) || (style & WS_CHILD) || UserGetActiveWindow()) SwFlag |= SWP_NOACTIVATE;
2346  co_WinPosSetWindowPos(Window, 0, NewPos.left, NewPos.top,
2347  NewPos.right, NewPos.bottom, SwFlag);
2348  }
2349 
2350  /* Send the WM_PARENTNOTIFY message */
2352 
2353  /* Notify the shell that a new window was created */
2354  if (UserIsDesktopWindow(Window->spwndParent) &&
2355  Window->spwndOwner == NULL &&
2356  (Window->style & WS_VISIBLE) &&
2357  (!(Window->ExStyle & WS_EX_TOOLWINDOW) ||
2358  (Window->ExStyle & WS_EX_APPWINDOW)))
2359  {
2361  }
2362 
2363  /* Initialize and show the window's scrollbars */
2364  if (Window->style & WS_VSCROLL)
2365  {
2367  }
2368  if (Window->style & WS_HSCROLL)
2369  {
2371  }
2372 
2373  /* Show the new window */
2374  if (Cs->style & WS_VISIBLE)
2375  {
2376  if (Window->style & WS_MAXIMIZE)
2377  dwShowMode = SW_SHOW;
2378  else if (Window->style & WS_MINIMIZE)
2379  dwShowMode = SW_SHOWMINIMIZED;
2380 
2381  co_WinPosShowWindow(Window, dwShowMode);
2382 
2383  if (Window->ExStyle & WS_EX_MDICHILD)
2384  {
2385  ASSERT(ParentWindow);
2386  if(!ParentWindow)
2387  goto cleanup;
2388  co_IntSendMessage(UserHMGetHandle(ParentWindow), WM_MDIREFRESHMENU, 0, 0);
2389  /* ShowWindow won't activate child windows */
2391  }
2392  }
2393 
2394  if (Class->atomClassName == gaGuiConsoleWndClass)
2395  {
2396  /* Count only console windows manually */
2398  }
2399 
2400  TRACE("co_UserCreateWindowEx(): Created window %p\n", hWnd);
2401  ret = Window;
2402 
2403 cleanup:
2404  if (!ret)
2405  {
2406  TRACE("co_UserCreateWindowEx(): Error Created window!\n");
2407  /* If the window was created, the class will be dereferenced by co_UserDestroyWindow */
2408  if (Window)
2410  else if (Class)
2411  IntDereferenceClass(Class, pti->pDeskInfo, pti->ppi);
2412  }
2413 
2414  if (pCsw) ExFreePoolWithTag(pCsw, TAG_HOOK);
2415  if (pCbtCreate) ExFreePoolWithTag(pCbtCreate, TAG_HOOK);
2416  if (pszName) UserHeapFree(pszName);
2417  if (pszClass) UserHeapFree(pszClass);
2418 
2419  if (Window)
2420  {
2422  }
2423  if (ParentWindow) UserDerefObjectCo(ParentWindow);
2424 
2425  // See CORE-13717, not setting error on success.
2426  if (ret)
2428 
2429  return ret;
2430 }
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_THICKFRAME
Definition: pedump.c:630
#define HOOKID_TO_FLAG(HookId)
Definition: hook.h:5
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
NTSYSAPI DWORD WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING *)
#define HCBT_CREATEWND
Definition: winuser.h:58
POBJECT_TYPE ExWindowStationObjectType
Definition: win32k.c:25
*BytesInUnicodeString PWCH UnicodeString
Definition: rtlfuncs.h:1980
long y
Definition: polytest.cpp:48
#define LAYOUT_RTL
Definition: wingdi.h:1370
#define ERROR_SUCCESS
Definition: deptool.c:10
NTSTATUS FASTCALL UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
Definition: input.c:479
#define TAG_HOOK
Definition: tags.h:5
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
long x
Definition: polytest.cpp:48
PVOID Buffer
Definition: ntuser.h:97
#define SB_VERT
Definition: winuser.h:553
HWND FASTCALL UserGetActiveWindow(VOID)
Definition: focus.c:1311
uint16_t * PWSTR
Definition: typedefs.h:54
LPCREATESTRUCTW lpcs
Definition: winuser.h:2949
#define SB_HORZ
Definition: winuser.h:552
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1720
#define OBJID_WINDOW
Definition: winable.h:15
HWND hWnd
Definition: settings.c:17
#define ICLS_DESKTOP
Definition: ntuser.h:890
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1240
long bottom
Definition: polytest.cpp:53
static __inline BOOL UserHeapFree(PVOID lpMem)
Definition: usrheap.h:42
DWORD FASTCALL co_UserShowScrollBar(PWND, int, BOOL, BOOL)
Definition: scrollbar.c:859
#define HWND_TOP
Definition: winuser.h:1193
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
UINT_PTR WPARAM
Definition: windef.h:207
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:577
#define WS_CHILD
Definition: pedump.c:617
#define HWND_MESSAGE
Definition: winuser.h:1196
#define SWP_NOZORDER
Definition: winuser.h:1232
static __inline PVOID UserHeapAlloc(SIZE_T Bytes)
Definition: usrheap.h:34
#define SW_SHOWMINIMIZED
Definition: winuser.h:765
#define WS_CLIPCHILDREN
Definition: pedump.c:619
ATOM gaGuiConsoleWndClass
Definition: ntuser.c:27
#define WM_NCCREATE
Definition: winuser.h:1665
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
struct _DESKTOP * rpdesk
Definition: win32.h:91
PSERVERINFO gpsi
Definition: main.c:27
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
DWORD dwLayout
Definition: win32.h:270
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:781
PPROCESSINFO ppi
Definition: win32.h:87
HWND hwndInsertAfter
Definition: winuser.h:2950
long right
Definition: polytest.cpp:53
Definition: window.c:29
#define WS_EX_MDICHILD
Definition: winuser.h:394
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:937
#define UNICODE_NULL
#define WS_MINIMIZE
Definition: pedump.c:622
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
long top
Definition: polytest.cpp:53
struct NameRec_ * Name
Definition: cdprocs.h:464
#define CHILDID_SELF
Definition: winable.h:14
Definition: object.h:3
smooth NULL
Definition: ftsmooth.c:416
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
Definition: ntuser.h:533
LONG_PTR LPARAM
Definition: windef.h:208
PWND FASTCALL co_GetDesktopWindow(PWND pWnd)
Definition: desktop.c:1330
#define WH_CBT
Definition: winuser.h:35
NTSTATUS NTAPI ObReferenceObjectByPointer(IN PVOID Object, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode)
Definition: obref.c:383
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
#define SW_SHOW
Definition: winuser.h:769
PWND FASTCALL IntCreateWindow(CREATESTRUCTW *Cs, PLARGE_STRING WindowName, PCLS Class, PWND ParentWindow, PWND OwnerWindow, PVOID acbiBuffer, PDESKTOP pdeskCreated, DWORD dwVer)
Definition: window.c:1612
long left
Definition: polytest.cpp:53
VOID FASTCALL co_IntUserManualGuiCheck(BOOL Create)
Definition: guicheck.c:77
#define PCHAR
Definition: match.c:90
UINT FASTCALL co_WinPosGetMinMaxInfo(PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
Definition: winpos.c:931
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2464
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2644
HINSTANCE hInstance
Definition: winuser.h:2930
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define ERROR_TLW_WITH_WSCHILD
Definition: winerror.h:887
#define HWND_BOTTOM
Definition: winuser.h:1191
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
ULONG Length
Definition: ntuser.h:94
#define SWP_NOACTIVATE
Definition: winuser.h:1227
#define ISITHOOKED(HookId)
Definition: hook.h:6
PCLS IntGetAndReferenceClass(PUNICODE_STRING ClassName, HINSTANCE hInstance, BOOL bDesktopThread)
Definition: class.c:1407
void FASTCALL co_WinPosSendSizeMove(PWND Wnd)
Definition: winpos.c:2280
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WNDS2_WMCREATEMSGPROCESSED
Definition: ntuser.h:638
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define SW_MINIMIZE
Definition: winuser.h:770
int Window
Definition: x11stubs.h:26
#define WS_HSCROLL
Definition: pedump.c:628
BOOL FASTCALL IntIsTopLevelWindow(PWND pWnd)
Definition: window.c:331
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1103
int ret
static const WCHAR L[]
Definition: oid.c:1250
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
LPCWSTR lpszName
Definition: winuser.h:2938
#define SWP_FRAMECHANGED
Definition: winuser.h:1225
static __inline PVOID UserHeapAddressToUser(PVOID lpMem)
Definition: usrheap.h:92
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define SWP_NOSIZE
Definition: winuser.h:1230
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
#define IntIsDesktopWindow(WndObj)
Definition: window.h:24
#define WM_MDIREFRESHMENU
Definition: winuser.h:1808
unsigned short USHORT
Definition: pedump.c:61
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:617
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define min(a, b)
Definition: monoChain.cc:55
#define WS_POPUP
Definition: pedump.c:616
unsigned int UINT
Definition: ndis.h:50
#define WS_VSCROLL
Definition: pedump.c:627
#define SWP_SHOWWINDOW
Definition: winuser.h:1233
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1656
#define MAXUSHORT
Definition: typedefs.h:81
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2314
VOID IntDereferenceClass(IN OUT PCLS Class, IN PDESKTOPINFO Desktop, IN PPROCESSINFO pi)
Definition: class.c:792
#define WM_CREATE
Definition: winuser.h:1590
LPCWSTR lpszClass
Definition: winuser.h:2939
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:124
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
char * cleanup(char *str)
Definition: wpickclick.c:99
#define SWP_NOMOVE
Definition: winuser.h:1229
#define IS_ATOM(x)
Definition: class.h:3
#define WS_EX_APPWINDOW
Definition: winuser.h:383
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
LONG_PTR LRESULT
Definition: windef.h:209
struct _DESKTOPINFO * pDeskInfo
Definition: win32.h:92
Arabic default style
Definition: afstyles.h:93
#define WS_VISIBLE
Definition: pedump.c:620
#define WNDS_ANSICREATOR
Definition: ntuser.h:602
#define SW_MAXIMIZE
Definition: winuser.h:766
#define CHAR(Char)
static void IntSendParentNotify(PWND pWindow, UINT msg)
Definition: window.c:1503
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
void FASTCALL IntFixWindowCoordinates(CREATESTRUCTW *Cs, PWND ParentWindow, DWORD *dwShowMode)
Definition: window.c:1522
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define CS_PARENTDC
Definition: winuser.h:651
#define MAKEINTATOM(i)
Definition: winbase.h:1423
ULONG MaximumLength
Definition: ntuser.h:95
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1013
LRESULT FASTCALL co_WinPosGetNonClientSize(PWND Window, RECT *WindowRect, RECT *ClientRect)
Definition: winpos.c:2265
#define WS_MAXIMIZE
Definition: pedump.c:623
#define ERROR_CANNOT_FIND_WND_CLASS
Definition: winerror.h:888

Referenced by MENU_InitPopup(), and NtUserCreateWindowEx().

◆ co_UserDestroyWindow()

BOOLEAN co_UserDestroyWindow ( PVOID  Object)

Definition at line 2644 of file window.c.

2645 {
2646  HWND hWnd;
2647  PWND pwndTemp;
2648  PTHREADINFO ti;
2649  MSG msg;
2650  PWND Window = Object;
2651 
2652  ASSERT_REFS_CO(Window); // FIXME: Temp HACK?
2653 
2654  hWnd = Window->head.h;
2656 
2657  TRACE("co_UserDestroyWindow(Window = 0x%p, hWnd = 0x%p)\n", Window, hWnd);
2658 
2659  /* Check for owner thread */
2660  if ( Window->head.pti != PsGetCurrentThreadWin32Thread())
2661  {
2662  /* Check if we are destroying the desktop window */
2663  if (! ((Window->head.rpdesk->dwDTFlags & DF_DESTROYED) && Window == Window->head.rpdesk->pDeskInfo->spwnd))
2664  {
2666  return FALSE;
2667  }
2668  }
2669 
2670  /* If window was created successfully and it is hooked */
2671  if ((Window->state2 & WNDS2_WMCREATEMSGPROCESSED))
2672  {
2674  {
2675  ERR("Destroy Window WH_CBT Call Hook return!\n");
2676  return FALSE;
2677  }
2678  }
2679 
2680  if (Window->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME])
2681  {
2682  if ((Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2683  {
2684  if (Window->spwndOwner)
2685  {
2686  //ERR("DestroyWindow Owner out.\n");
2687  UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE);
2688  }
2689  }
2690  }
2691 
2692  /* Inform the parent */
2693  if (Window->style & WS_CHILD)
2694  {
2696  }
2697 
2698  if (!Window->spwndOwner && !IntGetParent(Window))
2699  {
2701  }
2702 
2703  /* Hide the window */
2704  if (Window->style & WS_VISIBLE)
2705  {
2706  if (Window->style & WS_CHILD)
2707  {
2708  /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
2710  }
2711  else
2712  {
2714  }
2715  }
2716 
2717  /* Adjust last active */
2718  if ((pwndTemp = Window->spwndOwner))
2719  {
2720  while (pwndTemp->spwndOwner)
2721  pwndTemp = pwndTemp->spwndOwner;
2722 
2723  if (pwndTemp->spwndLastActive == Window)
2724  pwndTemp->spwndLastActive = Window->spwndOwner;
2725  }
2726 
2727  if (Window->spwndParent && IntIsWindow(UserHMGetHandle(Window)))
2728  {
2729  if ((Window->style & (WS_POPUP | WS_CHILD)) == WS_CHILD)
2730  {
2732  {
2733  //ERR("DestroyWindow Parent out.\n");
2734  UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE);
2735  }
2736  }
2737  }
2738 
2739  if (Window->head.pti->MessageQueue->spwndActive == Window)
2740  Window->head.pti->MessageQueue->spwndActive = NULL;
2741  if (Window->head.pti->MessageQueue->spwndFocus == Window)
2742  Window->head.pti->MessageQueue->spwndFocus = NULL;
2743  if (Window->head.pti->MessageQueue->spwndActivePrev == Window)
2744  Window->head.pti->MessageQueue->spwndActivePrev = NULL;
2745  if (Window->head.pti->MessageQueue->spwndCapture == Window)
2746  Window->head.pti->MessageQueue->spwndCapture = NULL;
2747 
2748  /*
2749  * Check if this window is the Shell's Desktop Window. If so set hShellWindow to NULL
2750  */
2751 
2752  if ((ti != NULL) && (ti->pDeskInfo != NULL))
2753  {
2754  if (ti->pDeskInfo->hShellWindow == hWnd)
2755  {
2756  ERR("Destroying the ShellWindow!\n");
2757  ti->pDeskInfo->hShellWindow = NULL;
2758  }
2759  }
2760 
2762 
2764  {
2765  return TRUE;
2766  }
2767 
2768  /* Recursively destroy owned windows */
2769  if (!(Window->style & WS_CHILD))
2770  {
2771  HWND* List;
2772  HWND* phWnd;
2773  PWND pWnd;
2774 
2776  if (List)
2777  {
2778  for (phWnd = List; *phWnd; ++phWnd)
2779  {
2780  pWnd = ValidateHwndNoErr(*phWnd);
2781  if (pWnd == NULL)
2782  continue;
2783  ASSERT(pWnd->spwndOwner == Window);
2784  ASSERT(pWnd != Window);
2785 
2786  pWnd->spwndOwner = NULL;
2788  {
2790  UserRefObjectCo(pWnd, &Ref); // Temp HACK?
2791  co_UserDestroyWindow(pWnd);
2792  UserDerefObjectCo(pWnd); // Temp HACK?
2793  }
2794  else
2795  {
2796  ERR("IntWndBelongsToThread(0x%p) is FALSE, ignoring.\n", pWnd);
2797  }
2798  }
2799 
2801  }
2802  }
2803 
2804  /* Generate mouse move message for the next window */
2805  msg.message = WM_MOUSEMOVE;
2806  msg.wParam = UserGetMouseButtonsState();
2807  msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2808  msg.pt = gpsi->ptCursor;
2810 
2811  IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Window, OBJID_WINDOW, CHILDID_SELF, 0);
2812 
2813  /* Send destroy messages */
2815 
2817  {
2818  return TRUE;
2819  }
2820 
2821  /* Destroy the window storage */
2823 
2824  return TRUE;
2825 }
#define TRUE
Definition: types.h:120
VOID FASTCALL co_MsqInsertMouseMessage(MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: msgqueue.c:580
LRESULT co_UserFreeWindow(PWND Window, PPROCESSINFO ProcessData, PTHREADINFO ThreadData, BOOLEAN SendMessages)
Definition: window.c:546
PWND FASTCALL ValidateHwndNoErr(HWND hWnd)
Definition: window.c:96
NTSTATUS FASTCALL UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
Definition: input.c:479
#define IntWndBelongsToThread(WndObj, W32Thread)
Definition: window.h:31
#define SW_HIDE
Definition: winuser.h:762
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:13
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1827
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
#define MAKELPARAM(l, h)
Definition: winuser.h:3947
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1720
#define OBJID_WINDOW
Definition: winable.h:15
HWND hWnd
Definition: settings.c:17
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
HWND *FASTCALL IntWinListOwnedPopups(PWND Window)
Definition: window.c:287
UINT_PTR WPARAM
Definition: windef.h:207
#define WS_CHILD
Definition: pedump.c:617
#define SWP_NOZORDER
Definition: winuser.h:1232
PSERVERINFO gpsi
Definition: main.c:27
WORD FASTCALL UserGetMouseButtonsState(VOID)
Definition: mouse.c:22
#define SWP_HIDEWINDOW
Definition: winuser.h:1226
Definition: window.c:29
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
#define WOC_DELETE
Definition: winddi.h:1269
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
#define HCBT_DESTROYWND
Definition: winuser.h:59
#define CHILDID_SELF
Definition: winable.h:14
struct _WND * spwndOwner
Definition: ntuser.h:679
Definition: object.h:3
smooth NULL
Definition: ftsmooth.c:416
#define WH_CBT
Definition: winuser.h:35
#define WM_DESTROY
Definition: winuser.h:1591
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2464
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2644
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define TRACE(s)
Definition: solgame.cpp:4
static void IntSendDestroyMsg(HWND hWnd)
Definition: window.c:433
LIST_ENTRY List
Definition: psmgr.c:57
#define SWP_NOACTIVATE
Definition: winuser.h:1227
#define WNDS2_WMCREATEMSGPROCESSED
Definition: ntuser.h:638
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:157
static IUnknown Object
Definition: main.c:512
BOOL FASTCALL IntIsTopLevelWindow(PWND pWnd)
Definition: window.c:331
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1103
#define ICLS_IME
Definition: ntuser.h:888
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1241
#define SWP_NOSIZE
Definition: winuser.h:1230
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
struct _WND * spwndLastActive
Definition: ntuser.h:703
#define DF_DESTROYED
Definition: desktop.h:50
PWND FASTCALL IntGetParent(PWND Wnd)
Definition: window.c:185
#define WS_POPUP
Definition: pedump.c:616
#define WM_MOUSEMOVE
Definition: winuser.h:1757
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1656
#define msg(x)
Definition: auth_time.c:54
#define SWP_NOMOVE
Definition: winuser.h:1229
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define USERTAG_WINDOWLIST
Definition: tags.h:297
struct _DESKTOPINFO * pDeskInfo
Definition: win32.h:92
#define WS_VISIBLE
Definition: pedump.c:620
static void IntSendParentNotify(PWND pWindow, UINT msg)
Definition: window.c:1503
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1013

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

◆ co_UserFreeWindow()

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

Definition at line 546 of file window.c.

550 {
551  HWND *Children;
552  HWND *ChildHandle;
553  PWND Child;
554  PMENU Menu;
555  BOOLEAN BelongsToThreadData;
556 
557  ASSERT(Window);
558 
559  if(Window->state2 & WNDS2_INDESTROY)
560  {
561  TRACE("Tried to call co_UserFreeWindow() twice\n");
562  return 0;
563  }
564  Window->state2 |= WNDS2_INDESTROY;
565  Window->style &= ~WS_VISIBLE;
566  Window->head.pti->cVisWindows--;
567 
568 
569  /* remove the window already at this point from the thread window list so we
570  don't get into trouble when destroying the thread windows while we're still
571  in co_UserFreeWindow() */
572  RemoveEntryList(&Window->ThreadListEntry);
573 
574  BelongsToThreadData = IntWndBelongsToThread(Window, ThreadData);
575 
577 
578  /* free child windows */
579  Children = IntWinListChildren(Window);
580  if (Children)
581  {
582  for (ChildHandle = Children; *ChildHandle; ++ChildHandle)
583  {
584  if ((Child = IntGetWindowObject(*ChildHandle)))
585  {
587  {
588  /* send WM_DESTROY messages to windows not belonging to the same thread */
590  }
591  else
592  co_UserFreeWindow(Child, ProcessData, ThreadData, SendMessages);
593 
595  }
596  }
598  }
599 
600  if (SendMessages)
601  {
602  /*
603  * Clear the update region to make sure no WM_PAINT messages will be
604  * generated for this window while processing the WM_NCDESTROY.
605  */
609  if (BelongsToThreadData)
611  }
612 
614 
616 
617  /* Unregister hot keys */
619 
620  /* flush the message queue */
622 
623  /* from now on no messages can be sent to this window anymore */
624  Window->state |= WNDS_DESTROYED;
625  Window->fnid |= FNID_FREED;
626 
627  /* don't remove the WINDOWSTATUS_DESTROYING bit */
628 
629  /* reset shell window handles */
630  if (ThreadData->rpdesk)
631  {
632  if (Window->head.h == ThreadData->rpdesk->rpwinstaParent->ShellWindow)
633  ThreadData->rpdesk->rpwinstaParent->ShellWindow = NULL;
634 
635  if (Window->head.h == ThreadData->rpdesk->rpwinstaParent->ShellListView)
636  ThreadData->rpdesk->rpwinstaParent->ShellListView = NULL;
637  }
638 
639  /* Fixes dialog test_focus breakage due to r66237. */
640  if (ThreadData->MessageQueue->spwndFocus == Window)
641  ThreadData->MessageQueue->spwndFocus = NULL;
642 
643  if (ThreadData->MessageQueue->spwndActive == Window)
644  ThreadData->MessageQueue->spwndActive = NULL;
645 
646  if (ThreadData->MessageQueue->spwndCapture == Window)
647  {
649  }
650 
652  if ( Window->hrgnUpdate != NULL || Window->state & WNDS_INTERNALPAINT )
653  {
654  MsqDecPaintCountQueue(Window->head.pti);
655  if (Window->hrgnUpdate > HRGN_WINDOW && GreIsHandleValid(Window->hrgnUpdate))
656  {
658  GreDeleteObject(Window->hrgnUpdate);
659  }
660  Window->hrgnUpdate = NULL;
661  Window->state &= ~WNDS_INTERNALPAINT;
662  }
663 
665  {
667  }
668 
669  if ( ((Window->style & (WS_CHILD|WS_POPUP)) != WS_CHILD) &&
670  Window->IDMenu &&
671  (Menu = UserGetMenuObject((HMENU)Window->IDMenu)))
672  {
673  TRACE("UFW: IDMenu %p\n",Window->IDMenu);
674  IntDestroyMenuObject(Menu, TRUE);
675  Window->IDMenu = 0;
676  }
677 
678  if (Window->SystemMenu
679  && (Menu = UserGetMenuObject(Window->SystemMenu)))
680  {
681  IntDestroyMenuObject(Menu, TRUE);
682  Window->SystemMenu = (HMENU)0;
683  }
684 
685  DceFreeWindowDCE(Window); /* Always do this to catch orphaned DCs */
686 
688 
689  if (Window->PropListItems)
690  {
692  TRACE("Window->PropListItems %lu\n",Window->PropListItems);
693  ASSERT(Window->PropListItems==0);
694  }
695 
698 
700 
701  if (Window->pcls->atomClassName == gaGuiConsoleWndClass)
702  {
703  /* Count only console windows manually */
705  }
706 
707  /* dereference the class */
708  NT_ASSERT(Window->head.pti != NULL);
710  Window->head.pti->pDeskInfo,
711  Window->head.pti->ppi);
712  Window->pcls = NULL;
713 
714  if (Window->hrgnClip)
715  {
717  GreDeleteObject(Window->hrgnClip);
718  Window->hrgnClip = NULL;
719  }
720  Window->head.pti->cWindows--;
721 
722 // ASSERT(Window != NULL);
723  UserFreeWindowInfo(Window->head.pti, Window);
724 
727 
728  return 0;
729 }
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1203
#define RDW_NOCHILDREN
Definition: winuser.h:1208
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:683
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1155
#define TRUE
Definition: types.h:120
LRESULT co_UserFreeWindow(PWND Window, PPROCESSINFO ProcessData, PTHREADINFO ThreadData, BOOLEAN SendMessages)
Definition: window.c:546
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1143
VOID FASTCALL IntUnlinkWindow(PWND Wnd)
Definition: window.c:1306
BOOL FASTCALL IntReleaseCapture(VOID)
Definition: focus.c:1412
#define IntWndBelongsToThread(WndObj, W32Thread)
Definition: window.h:31
#define WNDS_SENDNCPAINT
Definition: ntuser.h:584
BOOL FASTCALL IntDestroyMenuObject(PMENU Menu, BOOL bRecurse)
Definition: menu.c:317
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
#define WS_CHILD
Definition: pedump.c:617
ATOM gaGuiConsoleWndClass
Definition: ntuser.c:27
PWND FASTCALL IntGetWindowObject(HWND hWnd)
Definition: window.c:51
FORCEINLINE PMENU UserGetMenuObject(HMENU hMenu)
Definition: userfuncs.h:3
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
BOOL FASTCALL DestroyTimersForWindow(PTHREADINFO pti, PWND Window)
Definition: timer.c:522
Definition: window.c:29
void FASTCALL DceFreeWindowDCE(PWND)
Definition: windc.c:685
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define HRGN_WINDOW
Definition: ntuser.h:329
VOID FASTCALL UserClipboardFreeWindow(PWND pWindow)
Definition: clipboard.c:411
VOID FASTCALL co_IntUserManualGuiCheck(BOOL Create)
Definition: guicheck.c:77
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define TRACE(s)
Definition: solgame.cpp:4
BOOL IntDeRegisterShellHookWindow(HWND hWnd)
Definition: desktop.c:1748
VOID FASTCALL UserRemoveWindowProps(_In_ PWND Window)
Definition: prop.c:115
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2478
#define WM_NCDESTROY
Definition: winuser.h:1666
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID FASTCALL MsqDecPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:508
#define FNID_FREED
Definition: ntuser.h:861
#define RDW_VALIDATE
Definition: winuser.h:1204
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
#define RDW_NOERASE
Definition: winuser.h:1201
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:255
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define RDW_NOFRAME
Definition: winuser.h:1202
Definition: ntuser.h:657
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:876
BOOL FASTCALL IntDestroyScrollBars(PWND)
Definition: scrollbar.c:806
#define WS_POPUP
Definition: pedump.c:616
#define WNDS_INTERNALPAINT
Definition: ntuser.h:585
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:582
VOID IntDereferenceClass(IN OUT PCLS Class, IN PDESKTOPINFO Desktop, IN PPROCESSINFO pi)
Definition: class.c:792
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE Child
Definition: acpixf.h:722
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define USERTAG_WINDOWLIST
Definition: tags.h:297
#define WS_VISIBLE
Definition: pedump.c:620
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define WNDS_DESTROYED
Definition: ntuser.h:604
VOID APIENTRY MsqRemoveWindowMessagesFromQueue(PWND Window)
Definition: msgqueue.c:798
#define WNDS2_INDESTROY
Definition: ntuser.h:616
VOID FASTCALL UnregisterWindowHotKeys(PWND pWnd)
Definition: hotkey.c:91
static VOID UserFreeWindowInfo(PTHREADINFO ti, PWND Wnd)
Definition: window.c:513
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:697
#define NT_ASSERT
Definition: rtlfuncs.h:3312
BOOL FASTCALL UserMarkObjectDestroy(PVOID Object)
Definition: object.c:587

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

◆ co_UserSetParent()

HWND FASTCALL co_UserSetParent ( HWND  hWndChild,
HWND  hWndNewParent 
)

Definition at line 1246 of file window.c.

1247 {
1248  PWND Wnd = NULL, WndParent = NULL, WndOldParent;
1249  HWND hWndOldParent = NULL;
1250  USER_REFERENCE_ENTRY Ref, ParentRef;
1251 
1252  if (IntIsBroadcastHwnd(hWndChild) || IntIsBroadcastHwnd(hWndNewParent))
1253  {
1255  return( NULL);
1256  }
1257 
1258  if (hWndChild == IntGetDesktopWindow())
1259  {
1260  ERR("UserSetParent Access Denied!\n");
1262  return( NULL);
1263  }
1264 
1265  if (hWndNewParent)
1266  {
1267  if (!(WndParent = UserGetWindowObject(hWndNewParent)))
1268  {
1269  ERR("UserSetParent Bad New Parent!\n");
1270  return( NULL);
1271  }
1272  }
1273  else
1274  {
1275  if (!(WndParent = UserGetWindowObject(IntGetDesktopWindow())))
1276  {
1277  return( NULL);
1278  }
1279  }
1280 
1281  if (!(Wnd = UserGetWindowObject(hWndChild)))
1282  {
1283  ERR("UserSetParent Bad Child!\n");
1284  return( NULL);
1285  }
1286 
1287  UserRefObjectCo(Wnd, &Ref);
1288  UserRefObjectCo(WndParent, &ParentRef);
1289  //ERR("Enter co_IntSetParent\n");
1290  WndOldParent = co_IntSetParent(Wnd, WndParent);
1291  //ERR("Leave co_IntSetParent\n");
1292  UserDerefObjectCo(WndParent);
1293  UserDerefObjectCo(Wnd);
1294 
1295  if (WndOldParent)
1296  {
1297  hWndOldParent = WndOldParent->head.h;
1298  UserDereferenceObject(WndOldParent);
1299  }
1300 
1301  return( hWndOldParent);
1302 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
Definition: object.h:3
smooth NULL
Definition: ftsmooth.c:416
#define IntIsBroadcastHwnd(hWnd)
Definition: window.h:27
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1338
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
PWND FASTCALL co_IntSetParent(PWND Wnd, PWND WndNewParent)
Definition: window.c:1109
HWND hWndChild[NUM_TABS]
Definition: main.h:75
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27

Referenced by co_IntSetWindowLongPtr(), and NtUserSetParent().

◆ co_UserSetWindowLong()

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

Definition at line 3830 of file window.c.

3831 {
3832  return (LONG)co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG), FALSE);
3833 }
HWND hWnd
Definition: settings.c:17
static LONG_PTR co_IntSetWindowLongPtr(HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi, ULONG Size, BOOL bAlter)
Definition: window.c:3635
long LONG
Definition: pedump.c:60
static const UCHAR Index[8]
Definition: usbohci.c:18

Referenced by DesktopWindowProc(), and NtUserSetWindowWord().

◆ co_UserSetWindowLongPtr()

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

Definition at line 3836 of file window.c.

3837 {
3838  return co_IntSetWindowLongPtr(hWnd, Index, NewValue, Ansi, sizeof(LONG_PTR), FALSE);
3839 }
HWND hWnd
Definition: settings.c:17
static LONG_PTR co_IntSetWindowLongPtr(HWND hWnd, DWORD Index, LONG_PTR NewValue, BOOL Ansi, ULONG Size, BOOL bAlter)
Definition: window.c:3635
static const UCHAR Index[8]
Definition: usbohci.c:18
__int3264 LONG_PTR
Definition: mstsclib_h.h:276

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserWnd  )

◆ DefSetText()

BOOL APIENTRY DefSetText ( PWND  Wnd,
PCWSTR  WindowText 
)

Definition at line 4164 of file window.c.

4165 {
4167  BOOL Ret = FALSE;
4168 
4169  RtlInitUnicodeString(&UnicodeString, WindowText);
4170 
4171  if (UnicodeString.Length != 0)
4172  {
4173  if (Wnd->strName.MaximumLength > 0 &&
4174  UnicodeString.Length <= Wnd->strName.MaximumLength - sizeof(UNICODE_NULL))
4175  {
4176  ASSERT(Wnd->strName.Buffer != NULL);
4177 
4178  Wnd->strName.Length = UnicodeString.Length;
4179  Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
4181  UnicodeString.Buffer,
4182  UnicodeString.Length);
4183  }
4184  else
4185  {
4186  PWCHAR buf;
4187  Wnd->strName.MaximumLength = Wnd->strName.Length = 0;
4188  buf = Wnd->strName.Buffer;
4189  Wnd->strName.Buffer = NULL;
4190  if (buf != NULL)
4191  {
4192  DesktopHeapFree(Wnd->head.rpdesk, buf);
4193  }
4194 
4196  UnicodeString.Length + sizeof(UNICODE_NULL));
4197  if (Wnd->strName.Buffer != NULL)
4198  {
4199  Wnd->strName.Buffer[UnicodeString.Length / sizeof(WCHAR)] = L'\0';
4201  UnicodeString.Buffer,
4202  UnicodeString.Length);
4203  Wnd->strName.MaximumLength = UnicodeString.Length + sizeof(UNICODE_NULL);
4204  Wnd->strName.Length = UnicodeString.Length;
4205  }
4206  else
4207  {
4209  goto Exit;
4210  }
4211  }
4212  }
4213  else
4214  {
4215  Wnd->strName.Length = 0;
4216  if (Wnd->strName.Buffer != NULL)
4217  Wnd->strName.Buffer[0] = L'\0';
4218  }
4219 
4220  // FIXME: HAX! Windows does not do this in here!
4221  // In User32, these are called after: NotifyWinEvent EVENT_OBJECT_NAMECHANGE than
4222  // RepaintButton, StaticRepaint, NtUserCallHwndLock HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK, etc.
4223  /* Send shell notifications */
4224  if (!Wnd->spwndOwner && !IntGetParent(Wnd))
4225  {
4226  co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM) UserHMGetHandle(Wnd), FALSE); // FIXME Flashing?
4227  }
4228 
4229  Ret = TRUE;
4230 Exit:
4232  return Ret;
4233 }
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
*BytesInUnicodeString PWCH UnicodeString
Definition: rtlfuncs.h:1980
struct _DESKTOP * rpdesk
Definition: ntuser.h:189
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
UINT_PTR WPARAM
Definition: windef.h:207
uint16_t * PWCHAR
Definition: typedefs.h:54
static __inline PVOID DesktopHeapAlloc(IN PDESKTOP Desktop, IN SIZE_T Bytes)
Definition: desktop.h:230
#define UNICODE_NULL
unsigned int BOOL
Definition: ntddk_ex.h:94
struct _WND * spwndOwner
Definition: ntuser.h:679
THRDESKHEAD head
Definition: ntuser.h:659
smooth NULL
Definition: ftsmooth.c:416
LARGE_UNICODE_STRING strName
Definition: ntuser.h:700
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
__wchar_t WCHAR
Definition: xmlstorage.h:180
static void Exit(void)
Definition: sock.c:1331
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
static const WCHAR L[]
Definition: oid.c:1250
PWND FASTCALL IntGetParent(PWND Wnd)
Definition: window.c:185
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1656
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
static __inline BOOL DesktopHeapFree(IN PDESKTOP Desktop, IN PVOID lpMem)
Definition: desktop.h:239
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27

◆ IntCheckFrameEdge()

static BOOL FASTCALL IntCheckFrameEdge ( ULONG  Style,
ULONG  ExStyle 
)
static

Definition at line 3624 of file window.c.

3625 {
3627  return TRUE;
3628  else if (!(ExStyle & WS_EX_STATICEDGE) && (Style & (WS_DLGFRAME | WS_THICKFRAME)))
3629  return TRUE;
3630  else
3631  return FALSE;
3632 }
#define WS_THICKFRAME
Definition: pedump.c:630
#define TRUE
Definition: types.h:120
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
const DWORD Style
Definition: appswitch.c:71
#define WS_EX_STATICEDGE
Definition: winuser.h:403
const DWORD ExStyle
Definition: appswitch.c:72

Referenced by co_IntSetWindowLongPtr().

◆ IntCreateWindow()

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

Definition at line 1612 of file window.c.

1620 {
1621  PWND pWnd = NULL;
1622  HWND hWnd;
1623  PTHREADINFO pti = NULL;
1624  BOOL MenuChanged;
1625  BOOL bUnicodeWindow;
1626 
1627  pti = pdeskCreated ? gptiDesktopThread : GetW32ThreadInfo();
1628 
1629  if (!(Cs->dwExStyle & WS_EX_LAYOUTRTL))
1630  { // Need both here for wine win.c test_CreateWindow.
1631  //if (Cs->hwndParent && ParentWindow)
1632  if (ParentWindow) // It breaks more tests..... WIP.
1633  {
1634  if ( (Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD &&
1635  ParentWindow->ExStyle & WS_EX_LAYOUTRTL &&
1636  !(ParentWindow->ExStyle & WS_EX_NOINHERITLAYOUT) )
1637  Cs->dwExStyle |= WS_EX_LAYOUTRTL;
1638  }
1639  else
1640  { /*
1641  * Note from MSDN <http://msdn.microsoft.com/en-us/library/aa913269.aspx>:
1642  *
1643  * Dialog boxes and message boxes do not inherit layout, so you must
1644  * set the layout explicitly.
1645  */
1646  if ( Class->fnid != FNID_DIALOG )
1647  {
1648  if (pti->ppi->dwLayout & LAYOUT_RTL)
1649  {
1650  Cs->dwExStyle |= WS_EX_LAYOUTRTL;
1651  }
1652  }
1653  }
1654  }
1655 
1656  /* Automatically add WS_EX_WINDOWEDGE */
1657  if ((Cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
1658  ((!(Cs->dwExStyle & WS_EX_STATICEDGE)) &&
1659  (Cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
1660  Cs->dwExStyle |= WS_EX_WINDOWEDGE;
1661  else
1662  Cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
1663 
1664  /* Is it a unicode window? */
1665  bUnicodeWindow =!(Cs->dwExStyle & WS_EX_SETANSICREATOR);
1667 
1668  /* Allocate the new window */
1670  pdeskCreated ? pdeskCreated : pti->rpdesk,
1671  pti,
1672  (PHANDLE)&hWnd,
1673  TYPE_WINDOW,
1674  sizeof(WND) + Class->cbwndExtra);
1675 
1676  if (!pWnd)
1677  {
1678  goto AllocError;
1679  }
1680 
1681  TRACE("Created window object with handle %p\n", hWnd);
1682 
1683  if (pdeskCreated && pdeskCreated->DesktopWindow == NULL )
1684  { /* HACK: Helper for win32csr/desktopbg.c */
1685  /* If there is no desktop window yet, we must be creating it */
1686  TRACE("CreateWindow setting desktop.\n");
1687  pdeskCreated->DesktopWindow = hWnd;
1688  pdeskCreated->pDeskInfo->spwnd = pWnd;
1689  }
1690 
1691  /*
1692  * Fill out the structure describing it.
1693  */
1694  /* Remember, pWnd->head is setup in object.c ... */
1695  pWnd->spwndParent = ParentWindow;
1696  pWnd->spwndOwner = OwnerWindow;
1697  pWnd->fnid = 0;
1698  pWnd->spwndLastActive = pWnd;
1699  // Ramp up compatible version sets.
1700  if ( dwVer >= WINVER_WIN31 )
1701  {
1702  pWnd->state2 |= WNDS2_WIN31COMPAT;
1703  if ( dwVer >= WINVER_WINNT4 )
1704  {
1705  pWnd->state2 |= WNDS2_WIN40COMPAT;
1706  if ( dwVer >= WINVER_WIN2K )
1707  {
1708  pWnd->state2 |= WNDS2_WIN50COMPAT;
1709  }
1710  }
1711  }
1712  pWnd->pcls = Class;
1713  pWnd->hModule = Cs->hInstance;
1714  pWnd->style = Cs->style & ~WS_VISIBLE;
1715  pWnd->ExStyle = Cs->dwExStyle;
1716  pWnd->cbwndExtra = pWnd->pcls->cbwndExtra;
1717  pWnd->pActCtx = acbiBuffer;
1718  pWnd->InternalPos.MaxPos.x = pWnd->InternalPos.MaxPos.y = -1;
1719  pWnd->InternalPos.IconPos.x = pWnd->InternalPos.IconPos.y = -1;
1720 
1721  if (pWnd->spwndParent != NULL && Cs->hwndParent != 0)
1722  {
1723  pWnd->HideFocus = pWnd->spwndParent->HideFocus;
1724  pWnd->HideAccel = pWnd->spwndParent->HideAccel;
1725  }
1726 
1727  pWnd->head.pti->cWindows++;
1728 
1729  if (Class->spicn && !Class->spicnSm)
1730  {
1731  HICON IconSmHandle = NULL;
1732  if((Class->spicn->CURSORF_flags & (CURSORF_LRSHARED | CURSORF_FROMRESOURCE))
1734  {
1735  IconSmHandle = co_IntCopyImage(
1736  UserHMGetHandle(Class->spicn),
1737  IMAGE_ICON,
1741  }
1742  if (!IconSmHandle)
1743  {
1744  /* Retry without copying from resource */
1745  IconSmHandle = co_IntCopyImage(
1746  UserHMGetHandle(Class->spicn),
1747  IMAGE_ICON,
1750  0);
1751  }
1752 
1753  if (IconSmHandle)
1754  {
1755  Class->spicnSm = UserGetCurIconObject(IconSmHandle);
1756  Class->CSF_flags |= CSF_CACHEDSMICON;
1757  }
1758  }
1759 
1760  if (pWnd->pcls->CSF_flags & CSF_SERVERSIDEPROC)
1762 
1763  /* BugBoy Comments: Comment below say that System classes are always created
1764  as UNICODE. In windows, creating a window with the ANSI version of CreateWindow
1765  sets the window to ansi as verified by testing with IsUnicodeWindow API.
1766 
1767  No where can I see in code or through testing does the window change back
1768  to ANSI after being created as UNICODE in ROS. I didnt do more testing to
1769  see what problems this would cause. */
1770 
1771  // Set WndProc from Class.
1772  pWnd->lpfnWndProc = pWnd->pcls->lpfnWndProc;
1773 
1774  // GetWindowProc, test for non server side default classes and set WndProc.
1775  if ( pWnd->pcls->fnid <= FNID_GHOST && pWnd->pcls->fnid >= FNID_BUTTON )
1776  {
1777  if (bUnicodeWindow)
1778  {
1779  if (GETPFNCLIENTA(pWnd->pcls->fnid) == pWnd->lpfnWndProc)
1780  pWnd->lpfnWndProc = GETPFNCLIENTW(pWnd->pcls->fnid);
1781  }
1782  else
1783  {
1784  if (GETPFNCLIENTW(pWnd->pcls->fnid) == pWnd->lpfnWndProc)
1785  pWnd->lpfnWndProc = GETPFNCLIENTA(pWnd->pcls->fnid);
1786  }
1787  }
1788 
1789  // If not an Unicode caller, set Ansi creator bit.
1790  if (!bUnicodeWindow) pWnd->state |= WNDS_ANSICREATOR;
1791 
1792  // Clone Class Ansi/Unicode proc type.
1793  if (pWnd->pcls->CSF_flags & CSF_ANSIPROC)
1794  {
1795  pWnd->state |= WNDS_ANSIWINDOWPROC;
1796  pWnd->Unicode = FALSE;
1797  }
1798  else
1799  { /*
1800  * It seems there can be both an Ansi creator and Unicode Class Window
1801  * WndProc, unless the following overriding conditions occur:
1802  */
1803  if ( !bUnicodeWindow &&
1804  ( Class->atomClassName == gpsi->atomSysClass[ICLS_BUTTON] ||
1805  Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOBOX] ||
1806  Class->atomClassName == gpsi->atomSysClass[ICLS_COMBOLBOX] ||
1807  Class->atomClassName == gpsi->atomSysClass[ICLS_DIALOG] ||
1808  Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT] ||
1809  Class->atomClassName == gpsi->atomSysClass[ICLS_IME] ||
1810  Class->atomClassName == gpsi->atomSysClass[ICLS_LISTBOX] ||
1811  Class->atomClassName == gpsi->atomSysClass[ICLS_MDICLIENT] ||
1812  Class->atomClassName == gpsi->atomSysClass[ICLS_STATIC] ) )
1813  { // Override Class and set the window Ansi WndProc.
1814  pWnd->state |= WNDS_ANSIWINDOWPROC;
1815  pWnd->Unicode = FALSE;
1816  }
1817  else
1818  { // Set the window Unicode WndProc.
1819  pWnd->state &= ~WNDS_ANSIWINDOWPROC;
1820  pWnd->Unicode = TRUE;
1821  }
1822  }
1823 
1824  /* BugBoy Comments: if the window being created is a edit control, ATOM 0xCxxx,
1825  then my testing shows that windows (2k and XP) creates a CallProc for it immediately
1826  Dont understand why it does this. */
1827  if (Class->atomClassName == gpsi->atomSysClass[ICLS_EDIT])
1828  {
1829  PCALLPROCDATA CallProc;
1830  CallProc = CreateCallProc(pWnd->head.rpdesk, pWnd->lpfnWndProc, pWnd->Unicode , pWnd->head.pti->ppi);
1831 
1832  if (!CallProc)
1833  {
1835  ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %p\n", hWnd);
1836  }
1837  else
1838  {
1839  UserAddCallProcToClass(pWnd->pcls, CallProc);
1840  }
1841  }
1842 
1844  pWnd->PropListItems = 0;
1845 
1846  if ( WindowName->Buffer != NULL && WindowName->Length > 0 )
1847  {
1848  pWnd->strName.Buffer = DesktopHeapAlloc(pWnd->head.rpdesk,
1849  WindowName->Length + sizeof(UNICODE_NULL));
1850  if (pWnd->strName.Buffer == NULL)
1851  {
1852  goto AllocError;
1853  }
1854 
1855  RtlCopyMemory(pWnd->strName.Buffer, WindowName->Buffer, WindowName->Length);
1856  pWnd->strName.Buffer[WindowName->Length / sizeof(WCHAR)] = L'\0';
1857  pWnd->strName.Length = WindowName->Length;
1858  pWnd->strName.MaximumLength = WindowName->Length + sizeof(UNICODE_NULL);
1859  }
1860 
1861  /* Correct the window style. */
1862  if ((pWnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1863  {
1864  pWnd->style |= WS_CLIPSIBLINGS;
1865  if (!(pWnd->style & WS_POPUP))
1866  {
1867  pWnd->style |= WS_CAPTION;
1868  }
1869  }
1870 
1871  /* WS_EX_WINDOWEDGE depends on some other styles */
1872  if (pWnd->ExStyle & WS_EX_DLGMODALFRAME)
1873  pWnd->ExStyle |= WS_EX_WINDOWEDGE;
1874  else if (pWnd->style & (WS_DLGFRAME | WS_THICKFRAME))
1875  {
1876  if (!((pWnd->ExStyle & WS_EX_STATICEDGE) &&
1877  (pWnd->style & (WS_CHILD | WS_POPUP))))
1878  pWnd->ExStyle |= WS_EX_WINDOWEDGE;
1879  }
1880  else
1881  pWnd->ExStyle &= ~WS_EX_WINDOWEDGE;
1882 
1883  if (!(pWnd->style & (WS_CHILD | WS_POPUP)))
1884  pWnd->state |= WNDS_SENDSIZEMOVEMSGS;
1885 
1886  /* Set the window menu */
1887  if ((Cs->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1888  {
1889  if (Cs->hMenu)
1890  {
1891  IntSetMenu(pWnd, Cs->hMenu, &MenuChanged);
1892  }
1893  else if (pWnd->pcls->lpszMenuName) // Take it from the parent.
1894  {
1895  UNICODE_STRING MenuName;
1896  HMENU hMenu;
1897 
1898  if (IS_INTRESOURCE(pWnd->pcls->lpszMenuName))
1899  {
1900  MenuName.Length = 0;
1901  MenuName.MaximumLength = 0;
1902  MenuName.Buffer = pWnd->pcls->lpszMenuName;
1903  }
1904  else
1905  {
1906  RtlInitUnicodeString( &MenuName, pWnd->pcls->lpszMenuName);
1907  }
1908  hMenu = co_IntCallLoadMenu( pWnd->pcls->hModule, &MenuName);
1909  if (hMenu) IntSetMenu(pWnd, hMenu, &MenuChanged);
1910  }
1911  }
1912  else // Not a child
1913  pWnd->IDMenu = (UINT_PTR)Cs->hMenu;
1914 
1915 
1916  if ( ParentWindow &&
1917  ParentWindow != ParentWindow->head.rpdesk->spwndMessage &&
1918  ParentWindow != ParentWindow->head.rpdesk->pDeskInfo->spwnd )
1919  {
1920  PWND Owner = IntGetNonChildAncestor(ParentWindow);
1921 
1922  if (!IntValidateOwnerDepth(pWnd, Owner))
1923  {
1925  goto Error;
1926  }
1927  if ( pWnd->spwndOwner &&
1928  pWnd->spwndOwner->ExStyle & WS_EX_TOPMOST )
1929  {
1930  pWnd->ExStyle |= WS_EX_TOPMOST;
1931  }
1932  if ( pWnd->spwndOwner &&
1933  Class->atomClassName != gpsi->atomSysClass[ICLS_IME] &&
1934  pti != pWnd->spwndOwner->head.pti)
1935  {
1936  //ERR("CreateWindow Owner in.\n");
1937  UserAttachThreadInput(pti, pWnd->spwndOwner->head.pti, TRUE);
1938  }
1939  }
1940 
1941  /* Insert the window into the thread's window list. */
1943 
1944  /* Handle "CS_CLASSDC", it is tested first. */
1945  if ( (pWnd->pcls->style & CS_CLASSDC) && !(pWnd->pcls->pdce) )
1946  { /* One DCE per class to have CLASS. */
1947  pWnd->pcls->pdce = DceAllocDCE( pWnd, DCE_CLASS_DC );
1948  }
1949  else if ( pWnd->pcls->style & CS_OWNDC)
1950  { /* Allocate a DCE for this window. */
1951  DceAllocDCE(pWnd, DCE_WINDOW_DC);
1952  }
1953 
1954  return pWnd;
1955 
1956 AllocError:
1957  ERR("IntCreateWindow Allocation Error.\n");
1959 Error:
1960  if(pWnd)
1961  UserDereferenceObject(pWnd);
1962  return NULL;
1963 }
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static const WCHAR Class[]
Definition: cfgmgr.c:39
unsigned __int3264 UINT_PTR
Definition: activex.cpp:275
#define WS_THICKFRAME
Definition: pedump.c:630
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
DWORD ExStyle
Definition: ntuser.h:668
static HICON
Definition: imagelist.c:84
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
UINT HideFocus
Definition: ntuser.h:722
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define IMAGE_ICON
Definition: winuser.h:212
#define ICLS_MDICLIENT
Definition: ntuser.h:879
LIST_ENTRY ThreadListEntry
Definition: ntuser.h:728
struct _DESKTOP * rpdesk
Definition: ntuser.h:189
#define LAYOUT_RTL
Definition: wingdi.h:1370
ULONG PropListItems
Definition: ntuser.h:688
NTSTATUS FASTCALL UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
Definition: input.c:479
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon)
Definition: cursoricon.c:200
USHORT MaximumLength
Definition: env_spec_w32.h:370
PVOID Buffer
Definition: ntuser.h:97
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:867
#define CURSORF_FROMRESOURCE
Definition: ntuser.h:1148
LIST_ENTRY WindowListHead
Definition: win32.h:149
HINSTANCE hModule
Definition: ntuser.h:672
WNDPROC lpfnWndProc
Definition: ntuser.h:682
BOOL FASTCALL IntValidateOwnerDepth(PWND Wnd, PWND Owner)
Definition: window.c:339
HINSTANCE hModule
Definition: ntuser.h:552
#define WINVER_WIN2K
Definition: window.h:55
#define ICLS_EDIT
Definition: ntuser.h:874
LIST_ENTRY PropListHead
Definition: ntuser.h:687
HWND hWnd
Definition: settings.c:17
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
struct _WND WND
#define WS_DLGFRAME
Definition: pedump.c:626
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define SM_CYSMICON
Definition: winuser.h:1003
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:577
#define WS_CHILD
Definition: pedump.c:617
#define CS_OWNDC
Definition: winuser.h:650
#define InsertTailList(ListHead, Entry)
struct _DESKTOP * rpdesk
Definition: win32.h:91
PSERVERINFO gpsi
Definition: main.c:27
#define WINVER_WINNT4
Definition: window.h:56
#define ICLS_DIALOG
Definition: ntuser.h:891
PVOID FASTCALL UserCreateObject(PUSER_HANDLE_TABLE ht, PDESKTOP pDesktop, PTHREADINFO pti, HANDLE *h, HANDLE_TYPE type, ULONG size)
Definition: object.c:535
DWORD dwLayout
Definition: win32.h:270
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:781
PPROCESSINFO ppi
Definition: win32.h:87
PCALLPROCDATA CreateCallProc(IN PDESKTOP Desktop, IN WNDPROC WndProc, IN BOOL Unicode, IN PPROCESSINFO pi)
Definition: callproc.c:29
WNDPROC lpfnWndProc
Definition: ntuser.h:549
PTHREADINFO gptiDesktopThread
Definition: desktop.c:37
ULONG cbwndExtra
Definition: ntuser.h:702
#define ICLS_LISTBOX
Definition: ntuser.h:876
DWORD CSF_flags
Definition: ntuser.h:541
#define CSF_CACHEDSMICON
Definition: ntuser.h:530
UINT style
Definition: ntuser.h:548
static __inline PVOID DesktopHeapAlloc(IN PDESKTOP Desktop, IN SIZE_T Bytes)
Definition: desktop.h:230
#define UNICODE_NULL
DWORD fnid
Definition: ntuser.h:673
unsigned int BOOL
Definition: ntddk_ex.h:94
#define CURSORF_LRSHARED
Definition: ntuser.h:1150
HMENU APIENTRY co_IntCallLoadMenu(HINSTANCE hModule, PUNICODE_STRING pMenuName)
Definition: callback.c:889
#define FNID_DIALOG
Definition: ntuser.h:831
struct _WND * spwndOwner
Definition: ntuser.h:679
THRDESKHEAD head
Definition: ntuser.h:659
smooth NULL
Definition: ftsmooth.c:416
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
PVOID pdce
Definition: ntuser.h:540
LARGE_UNICODE_STRING strName
Definition: ntuser.h:700
#define ICLS_STATIC
Definition: ntuser.h:875
UINT HideAccel
Definition: ntuser.h:723
HANDLE FASTCALL co_IntCopyImage(HANDLE hnd, UINT type, INT desiredx, INT desiredy, UINT flags)
Definition: callback.c:974
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:180
HINSTANCE hInstance
Definition: winuser.h:2930
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define WS_CAPTION
Definition: pedump.c:624
UINT_PTR IDMenu
Definition: ntuser.h:695
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
ULONG Length
Definition: ntuser.h:94
DWORD fnid
Definition: ntuser.h:538
#define WS_EX_NOINHERITLAYOUT
Definition: winuser.h:396
BOOL Error
Definition: chkdsk.c:66
#define SM_CXSMICON
Definition: winuser.h:1002
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:524
#define WNDS2_WIN50COMPAT
Definition: ntuser.h:619
static const WCHAR L[]
Definition: oid.c:1250
#define ICLS_IME
Definition: ntuser.h:888
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:865
#define WS_EX_TOPMOST
Definition: pedump.c:647
#define CSF_ANSIPROC
Definition: ntuser.h:525
#define ICLS_COMBOLBOX
Definition: ntuser.h:880
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:36
INT cbwndExtra
Definition: ntuser.h:551
VOID UserAddCallProcToClass(IN OUT PCLS Class, IN PCALLPROCDATA CallProc)
Definition: class.c:400
PWSTR lpszMenuName
Definition: ntuser.h:556
#define CS_CLASSDC
Definition: winuser.h:645
#define WS_EX_SETANSICREATOR
Definition: undocuser.h:28
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
#define FNID_GHOST
Definition: ntuser.h:837
#define LR_COPYFROMRESOURCE
Definition: winuser.h:1089
struct _WND * PWND
struct _WND * spwndLastActive
Definition: ntuser.h:703
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:592
#define FNID_BUTTON
Definition: ntuser.h:828
DWORD state
Definition: ntuser.h:665
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:617
#define WS_POPUP
Definition: pedump.c:616
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1557
#define WINVER_WIN31
Definition: window.h:57
PWND FASTCALL IntGetNonChildAncestor(PWND pWnd)
Definition: window.c:323
struct _WND * spwndParent
Definition: ntuser.h:677
DWORD state2
Definition: ntuser.h:666
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define ICLS_BUTTON
Definition: ntuser.h:873
PVOID pActCtx
Definition: ntuser.h:706
#define WNDS2_WIN40COMPAT
Definition: ntuser.h:618
struct _WND::@4119 InternalPos
PDCE FASTCALL DceAllocDCE(PWND Window, DCE_TYPE Type)
Definition: windc.c:85
#define WS_VISIBLE
Definition: pedump.c:620
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
#define WNDS_ANSICREATOR
Definition: ntuser.h:602
BOOL FASTCALL IntSetMenu(PWND Wnd, HMENU Menu, BOOL *Changed)
Definition: menu.c:5456
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:591
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define WS_EX_STATICEDGE
Definition: winuser.h:403
UINT Unicode
Definition: ntuser.h:720
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1013
PCLS pcls
Definition: ntuser.h:684
DWORD style
Definition: ntuser.h:670
#define ICLS_COMBOBOX
Definition: ntuser.h:878

Referenced by co_UserCreateWindowEx(), and IntCreateDesktop().

◆ IntEnableWindow()

BOOL FASTCALL IntEnableWindow ( HWND  hWnd,
BOOL  bEnable 
)

Definition at line 201 of file window.c.

202 {
203  BOOL Update;
204  PWND pWnd;
205  UINT bIsDisabled;
206 
207  if(!(pWnd = UserGetWindowObject(hWnd)))
208  {
209  return FALSE;
210  }
211 
212  /* check if updating is needed */
213  bIsDisabled = !!(pWnd->style & WS_DISABLED);
214  Update = bIsDisabled;
215 
216  if (bEnable)
217  {
218  IntSetStyle( pWnd, 0, WS_DISABLED );
219  }
220  else
221  {
222  Update = !bIsDisabled;
223 
225 
226  /* Remove keyboard focus from that window if it had focus */
227  if (hWnd == IntGetThreadFocusWindow())
228  {
229  TRACE("IntEnableWindow SF NULL\n");
231  }
232  IntSetStyle( pWnd, WS_DISABLED, 0 );
233  }
234 
235  if (Update)
236  {
237  IntNotifyWinEvent(EVENT_OBJECT_STATECHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, 0);
239  }
240  // Return nonzero if it was disabled, or zero if it wasn't:
241  return bIsDisabled;
242 }
#define WS_DISABLED
Definition: pedump.c:621
HWND FASTCALL IntGetThreadFocusWindow(VOID)
Definition: focus.c:39
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1196
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
#define OBJID_WINDOW
Definition: winable.h:15
HWND hWnd
Definition: settings.c:17
#define WM_ENABLE
Definition: winuser.h:1597
unsigned int BOOL
Definition: ntddk_ex.h:94
#define CHILDID_SELF
Definition: winable.h:14
smooth NULL
Definition: ftsmooth.c:416
LONG_PTR LPARAM
Definition: windef.h:208
#define TRACE(s)
Definition: solgame.cpp:4
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
#define WM_CANCELMODE
Definition: winuser.h:1617
Definition: ntuser.h:657
_In_ BOOL bEnable
Definition: winddi.h:3426
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
unsigned int UINT
Definition: ndis.h:50
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:124
DWORD style
Definition: ntuser.h:670

Referenced by NtUserCallTwoParam(), and NtUserEnableScrollBar().

◆ IntFindWindow()

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

Definition at line 2861 of file window.c.

2865 {
2866  BOOL CheckWindowName;
2867  HWND *List, *phWnd;
2868  HWND Ret = NULL;
2869  UNICODE_STRING CurrentWindowName;
2870 
2871  ASSERT(Parent);
2872 
2873  CheckWindowName = WindowName->Buffer != 0;
2874 
2875  if((List = IntWinListChildren(Parent)))
2876  {
2877  phWnd = List;
2878  if(ChildAfter)
2879  {
2880  /* skip handles before and including ChildAfter */
2881  while(*phWnd && (*(phWnd++) != ChildAfter->head.h))
2882  ;
2883  }
2884 
2885  /* search children */
2886  while(*phWnd)
2887  {
2888  PWND Child;
2889  if(!(Child = UserGetWindowObject(*(phWnd++))))
2890  {
2891  continue;
2892  }
2893 
2894  /* Do not send WM_GETTEXT messages in the kernel mode version!
2895  The user mode version however calls GetWindowText() which will
2896  send WM_GETTEXT messages to windows belonging to its processes */
2897  if (!ClassAtom || Child->pcls->atomNVClassName == ClassAtom)
2898  {
2899  // FIXME: LARGE_STRING truncated
2900  CurrentWindowName.Buffer = Child->strName.Buffer;
2901  CurrentWindowName.Length = (USHORT)min(Child->strName.Length, MAXUSHORT);
2902  CurrentWindowName.MaximumLength = (USHORT)min(Child->strName.MaximumLength, MAXUSHORT);
2903  if(!CheckWindowName ||
2904  (Child->strName.Length < 0xFFFF &&
2905  !RtlCompareUnicodeString(WindowName, &CurrentWindowName, TRUE)))
2906  {
2907  Ret = Child->head.h;
2908  break;
2909  }
2910  }
2911  }
2913  }
2914 
2915  return Ret;
2916 }
#define TRUE
Definition: types.h:120
USHORT MaximumLength
Definition: env_spec_w32.h:370
UINT32 Length
Definition: actbl.h:109
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:722
unsigned int BOOL
Definition: ntddk_ex.h:94
THRDESKHEAD head
Definition: ntuser.h:659
smooth NULL
Definition: ftsmooth.c:416
LIST_ENTRY List
Definition: psmgr.c:57
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:255
Definition: ntuser.h:657
unsigned short USHORT
Definition: pedump.c:61
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define min(a, b)
Definition: monoChain.cc:55
#define MAXUSHORT
Definition: typedefs.h:81
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE ACPI_HANDLE Child
Definition: acpixf.h:722
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define USERTAG_WINDOWLIST
Definition: tags.h:297

Referenced by NtUserFindWindowEx().

◆ IntFixWindowCoordinates()

void FASTCALL IntFixWindowCoordinates ( CREATESTRUCTW Cs,
PWND  ParentWindow,
DWORD dwShowMode 
)

Definition at line 1522 of file window.c.

1523 {
1524 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == (SHORT)0x8000)
1525 
1526  /* default positioning for overlapped windows */
1527  if(!(Cs->style & (WS_POPUP | WS_CHILD)))
1528  {
1529  PMONITOR pMonitor;
1530  PRTL_USER_PROCESS_PARAMETERS ProcessParams;
1531 
1532  pMonitor = UserGetPrimaryMonitor();
1533 
1534  /* Check if we don't have a monitor attached yet */
1535  if(pMonitor == NULL)
1536  {
1537  Cs->x = Cs->y = 0;
1538  Cs->cx = 800;
1539  Cs->cy = 600;
1540  return;
1541  }
1542 
1543  ProcessParams = PsGetCurrentProcess()->Peb->ProcessParameters;
1544 
1545  if (IS_DEFAULT(Cs->x))
1546  {
1547  if (!IS_DEFAULT(Cs->y)) *dwShowMode = Cs->y;
1548 
1549  if(ProcessParams->WindowFlags & STARTF_USEPOSITION)
1550  {
1551  Cs->x = ProcessParams->StartingX;
1552  Cs->y = ProcessParams->StartingY;
1553  }
1554  else
1555  {
1558  if (Cs->x > ((pMonitor->rcWork.right - pMonitor->rcWork.left) / 4) ||
1559  Cs->y > ((pMonitor->rcWork.bottom - pMonitor->rcWork.top) / 4))
1560  {
1561  /* reset counter and position */
1562  Cs->x = 0;
1563  Cs->y = 0;
1564  pMonitor->cWndStack = 0;
1565  }
1566  pMonitor->cWndStack++;
1567  }
1568  }
1569 
1570  if (IS_DEFAULT(Cs->cx))
1571  {
1572  if (ProcessParams->WindowFlags & STARTF_USEPOSITION)
1573  {
1574  Cs->cx = ProcessParams->CountX;
1575  Cs->cy = ProcessParams->CountY;
1576  }
1577  else
1578  {
1579  Cs->cx = (pMonitor->rcWork.right - pMonitor->rcWork.left) * 3 / 4;
1580  Cs->cy = (pMonitor->rcWork.bottom - pMonitor->rcWork.top) * 3 / 4;
1581  }
1582  }
1583  /* neither x nor cx are default. Check the y values .
1584  * In the trace we see Outlook and Outlook Express using
1585  * cy set to CW_USEDEFAULT when opening the address book.
1586  */
1587  else if (IS_DEFAULT(Cs->cy))
1588  {
1589  TRACE("Strange use of CW_USEDEFAULT in nHeight\n");
1590  Cs->cy = (pMonitor->rcWork.bottom - pMonitor->rcWork.top) * 3 / 4;
1591  }
1592  }
1593  else
1594  {
1595  /* if CW_USEDEFAULT is set for non-overlapped windows, both values are set to zero */
1596  if(IS_DEFAULT(Cs->x))
1597  {
1598  Cs->x = 0;
1599  Cs->y = 0;
1600  }
1601  if(IS_DEFAULT(Cs->cx))
1602  {
1603  Cs->cx = 0;
1604  Cs->cy = 0;
1605  }
1606  }
1607 
1608 #undef IS_DEFAULT
1609 }
#define SM_CYSIZE
Definition: winuser.h:982
LONG top
Definition: windef.h:292
#define STARTF_USEPOSITION
Definition: winbase.h:474
#define WS_CHILD
Definition: pedump.c:617
LONG left
Definition: windef.h:291
#define SM_CYFRAME
Definition: winuser.h:986
#define SM_CXFRAME
Definition: winuser.h:984
LONG right
Definition: windef.h:293
SHORT cWndStack
Definition: monitor.h:22
RECT rcWork
Definition: monitor.h:19
#define PsGetCurrentProcess
Definition: psfuncs.h:17
smooth NULL
Definition: ftsmooth.c:416
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:180
#define TRACE(s)
Definition: solgame.cpp:4
#define WS_POPUP
Definition: pedump.c:616
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
#define SM_CXSIZE
Definition: winuser.h:981
LONG bottom
Definition: windef.h:294
#define IS_DEFAULT(x)

Referenced by co_UserCreateWindowEx().

◆ IntGetNonChildAncestor()

PWND FASTCALL IntGetNonChildAncestor ( PWND  pWnd)

Definition at line 323 of file window.c.

324 {
325  while(pWnd && (pWnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
326  pWnd = pWnd->spwndParent;
327  return pWnd;
328 }
#define WS_CHILD
Definition: pedump.c:617
#define WS_POPUP
Definition: pedump.c:616
struct _WND * spwndParent
Definition: ntuser.h:677
DWORD style
Definition: ntuser.h:670

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

◆ IntGetParent()

PWND FASTCALL IntGetParent ( PWND  Wnd)

Definition at line 185 of file window.c.

186 {
187  if (Wnd->style & WS_POPUP)
188  {
189  return Wnd->spwndOwner;
190  }
191  else if (Wnd->style & WS_CHILD)
192  {
193  return Wnd->spwndParent;
194  }
195 
196  return NULL;
197 }
#define WS_CHILD
Definition: pedump.c:617
struct _WND * spwndOwner
Definition: ntuser.h:679
smooth NULL
Definition: ftsmooth.c:416
#define WS_POPUP
Definition: pedump.c:616
struct _WND * spwndParent
Definition: ntuser.h:677
DWORD style
Definition: ntuser.h:670

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 353 of file window.c.

355 {
356  PWND Wnd, FoundWnd;
357  HWND Ret = NULL;
358 
359  Wnd = ValidateHwndNoErr(hWnd);
360  if (!Wnd)
361  return NULL;
362 
363  FoundWnd = NULL;
364  switch (uCmd)
365  {
366  case GW_OWNER:
367  if (Wnd->spwndOwner != NULL)
368  FoundWnd = Wnd->spwndOwner;
369  break;
370 
371  case GW_HWNDFIRST:
372  if(Wnd->spwndParent != NULL)
373  {
374  FoundWnd = Wnd->spwndParent;
375  if (FoundWnd->spwndChild != NULL)
376  FoundWnd = FoundWnd->spwndChild;
377  }
378  break;
379  case GW_HWNDNEXT:
380  if (Wnd->spwndNext != NULL)
381  FoundWnd = Wnd->spwndNext;
382  break;
383 
384  case GW_HWNDPREV:
385  if (Wnd->spwndPrev != NULL)
386  FoundWnd = Wnd->spwndPrev;
387  break;
388 
389  case GW_CHILD:
390  if (Wnd->spwndChild != NULL)
391  FoundWnd = Wnd->spwndChild;
392  break;
393 
394  case GW_HWNDLAST:
395  FoundWnd = Wnd;
396  while ( FoundWnd->spwndNext != NULL)
397  FoundWnd = FoundWnd->spwndNext;
398  break;
399 
400  default:
401  Wnd = NULL;
402  break;
403  }
404 
405  if (FoundWnd != NULL)
406  Ret = UserHMGetHandle(FoundWnd);
407  return Ret;
408 }
#define GW_HWNDNEXT
Definition: winuser.h:756
PWND FASTCALL ValidateHwndNoErr(HWND hWnd)
Definition: window.c:96
#define GW_CHILD
Definition: winuser.h:758
HWND hWnd
Definition: settings.c:17
struct _WND * spwndOwner
Definition: ntuser.h:679
smooth NULL
Definition: ftsmooth.c:416
struct _WND * spwndNext
Definition: ntuser.h:675
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define GW_HWNDLAST
Definition: winuser.h:760
#define GW_HWNDFIRST
Definition: winuser.h:759
Definition: ntuser.h:657
#define GW_OWNER
Definition: winuser.h:761
struct _WND * spwndParent
Definition: ntuser.h:677
struct _WND * spwndChild
Definition: ntuser.h:678
#define GW_HWNDPREV
Definition: winuser.h:757
struct _WND * spwndPrev
Definition: ntuser.h:676

Referenced by WinPosFixupFlags().

◆ IntGetWindowContextHelpId()

DWORD FASTCALL IntGetWindowContextHelpId ( PWND  pWnd)

Definition at line 410 of file window.c.

411 {
412  DWORD HelpId;
413 
414  do
415  {
417  if (!HelpId) break;
418  pWnd = IntGetParent(pWnd);
419  }
420  while (pWnd && pWnd->fnid != FNID_DESKTOP);
421  return HelpId;
422 }
#define TRUE
Definition: types.h:120
ATOM atomContextHelpIdProp
Definition: ntuser.h:1020
#define DWORD
Definition: nt_native.h:44
PSERVERINFO gpsi
Definition: main.c:27
DWORD fnid
Definition: ntuser.h:673
#define FNID_DESKTOP
Definition: ntuser.h:824
HANDLE FASTCALL UserGetProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
Definition: prop.c:46
unsigned long DWORD
Definition: ntddk_ex.h:95
uint32_t DWORD_PTR
Definition: typedefs.h:63
PWND FASTCALL IntGetParent(PWND Wnd)
Definition: window.c:185

Referenced by IntDefWindowProc().

◆ IntGetWindowObject()

PWND FASTCALL IntGetWindowObject ( HWND  hWnd)

Definition at line 51 of file window.c.

52 {
53  PWND Window;
54 
55  if (!hWnd) return NULL;
56 
58  if (Window)
59  Window->head.cLockObj++;
60 
61  return Window;
62 }
HWND hWnd
Definition: settings.c:17
Definition: window.c:29
smooth NULL
Definition: ftsmooth.c:416
int Window
Definition: x11stubs.h:26
Definition: ntuser.h:657
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103

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

◆ IntGetWindowProc()

WNDPROC FASTCALL IntGetWindowProc ( PWND  pWnd,
BOOL  Ansi 
)

Definition at line 735 of file window.c.

737 {
738  INT i;
739  PCLS Class;
740  WNDPROC gcpd, Ret = 0;
741 
743 
744  Class = pWnd->pcls;
745 
746  if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
747  {
748  for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
749  {
750  if (GETPFNSERVER(i) == pWnd->lpfnWndProc)
751  {
752  if (Ansi)
753  Ret = GETPFNCLIENTA(i);
754  else
755  Ret = GETPFNCLIENTW(i);
756  }
757  }
758  return Ret;
759  }
760 
761  if (Class->fnid == FNID_EDIT)
762  Ret = pWnd->lpfnWndProc;
763  else
764  {
765  Ret = pWnd->lpfnWndProc;
766 
767  if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
768  {
769  if (Ansi)
770  {
771  if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc)
772  Ret = GETPFNCLIENTA(Class->fnid);
773  }
774  else
775  {
776  if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc)
777  Ret = GETPFNCLIENTW(Class->fnid);
778  }
779  }
780  if ( Ret != pWnd->lpfnWndProc)
781  return Ret;
782  }
783  if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) )
784  return Ret;
785 
786  gcpd = (WNDPROC)UserGetCPD(
787  pWnd,
789  (ULONG_PTR)Ret);
790 
791  return (gcpd ? gcpd : Ret);
792 }
static const WCHAR Class[]
Definition: cfgmgr.c:39
#define FNID_EDIT
Definition: ntuser.h:832
#define TRUE
Definition: types.h:120
#define GETPFNSERVER(fnid)
Definition: ntuser.h:870
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:867
WNDPROC lpfnWndProc
Definition: ntuser.h:682
ULONG_PTR FASTCALL UserGetCPD(PVOID pvClsWnd, GETCPD Flags, ULONG_PTR ProcIn)
Definition: callproc.c:107
int32_t INT
Definition: typedefs.h:56
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: ntuser.h:533
#define FNID_SWITCH
Definition: ntuser.h:827
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:865
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2880
#define FNID_GHOST
Definition: ntuser.h:837
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:592
#define FNID_BUTTON
Definition: ntuser.h:828
DWORD state
Definition: ntuser.h:665
BOOL FASTCALL UserIsEnteredExclusive(VOID)
Definition: ntuser.c:231
#define ULONG_PTR
Definition: config.h:101
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:591
#define FNID_FIRST
Definition: ntuser.h:820
PCLS pcls
Definition: ntuser.h:684

Referenced by IntSetWindowProc().

◆ IntIsChildWindow()

BOOL FASTCALL IntIsChildWindow ( PWND  Parent,
PWND  BaseWindow 
)

Definition at line 882 of file window.c.

883 {
885  do
886  {
887  if ( Window == NULL || (Window->style & (WS_POPUP|WS_CHILD)) != WS_CHILD )
888  return FALSE;
889 
890  Window = Window->spwndParent;
891  }
892  while(Parent != Window);
893  return TRUE;
894 }
#define TRUE
Definition: types.h:120
#define WS_CHILD
Definition: pedump.c:617
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:722
Definition: window.c:29
smooth NULL
Definition: ftsmooth.c:416
Definition: ntuser.h:657
#define WS_POPUP
Definition: pedump.c:616
struct tagBaseWindow BaseWindow

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

◆ IntIsTopLevelWindow()

BOOL FASTCALL IntIsTopLevelWindow ( PWND  pWnd)

Definition at line 331 of file window.c.

332 {
333  if ( pWnd->spwndParent &&
334  pWnd->spwndParent == co_GetDesktopWindow(pWnd) ) return TRUE;
335  return FALSE;
336 }
#define TRUE
Definition: types.h:120
PWND FASTCALL co_GetDesktopWindow(PWND pWnd)
Definition: desktop.c:1330
struct _WND * spwndParent
Definition: ntuser.h:677

Referenced by co_UserCreateWindowEx(), and co_UserDestroyWindow().

◆ IntIsWindow()

BOOL FASTCALL IntIsWindow ( HWND  hWnd)

Definition at line 157 of file window.c.

158 {
159  PWND Window;
160 
161  if (!(Window = UserGetWindowObject(hWnd)))
162  {
163  return FALSE;
164  }
165 
166  return TRUE;
167 }
#define TRUE
Definition: types.h:120
HWND hWnd
Definition: settings.c:17
Definition: window.c:29
int Window
Definition: x11stubs.h:26
Definition: ntuser.h:657
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103

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 170 of file window.c.

171 {
172  PWND Temp = Wnd;
173  for (;;)
174  {
175  if (!Temp) return TRUE;
176  if (!(Temp->style & WS_VISIBLE)) break;
177  if (Temp->style & WS_MINIMIZE && Temp != Wnd) break;
178  if (Temp->fnid == FNID_DESKTOP) return TRUE;
179  Temp = Temp->spwndParent;
180  }
181  return FALSE;
182 }
#define TRUE
Definition: types.h:120
#define WS_MINIMIZE
Definition: pedump.c:622
DWORD fnid
Definition: ntuser.h:673
#define FNID_DESKTOP
Definition: ntuser.h:824
Definition: ntuser.h:657
struct _WND * spwndParent
Definition: ntuser.h:677
#define WS_VISIBLE
Definition: pedump.c:620
DWORD style
Definition: ntuser.h:670

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

◆ IntLinkHwnd()

VOID FASTCALL IntLinkHwnd ( PWND  Wnd,
HWND  hWndPrev 
)

Definition at line 937 of file window.c.

938 {
939  if (hWndPrev == HWND_NOTOPMOST)
940  {
941  if (!(Wnd->ExStyle & WS_EX_TOPMOST) && (Wnd->ExStyle2 & WS_EX2_LINKED))
942  return; /* nothing to do */
943  Wnd->ExStyle &= ~WS_EX_TOPMOST;
944  hWndPrev = HWND_TOP; /* fallback to the HWND_TOP case */
945  }
946 
947  IntUnlinkWindow(Wnd); /* unlink it from the previous location */
948 
949  if (hWndPrev == HWND_BOTTOM)
950  {
951  /* Link in the bottom of the list */
952  PWND WndInsertAfter;
953 
954  WndInsertAfter = Wnd->spwndParent->spwndChild;
955  while (WndInsertAfter && WndInsertAfter->spwndNext)
956  {
957  WndInsertAfter = WndInsertAfter->spwndNext;
958  }
959 
960  IntLinkWindow(Wnd, WndInsertAfter);
961  Wnd->ExStyle &= ~WS_EX_TOPMOST;
962  }
963  else if (hWndPrev == HWND_TOPMOST)
964  {
965  /* Link in the top of the list */
966  IntLinkWindow(Wnd, NULL);
967  Wnd->ExStyle |= WS_EX_TOPMOST;
968  }
969  else if (hWndPrev == HWND_TOP)
970  {
971  /* Link it after the last topmost window */
972  PWND WndInsertBefore;
973 
974  WndInsertBefore = Wnd->spwndParent->spwndChild;
975 
976  if (!(Wnd->ExStyle & WS_EX_TOPMOST)) /* put it above the first non-topmost window */
977  {
978  while (WndInsertBefore != NULL && WndInsertBefore->spwndNext != NULL)
979  {
980  if (!(WndInsertBefore->ExStyle & WS_EX_TOPMOST))
981  break;
982 
983  if (WndInsertBefore == Wnd->spwndOwner) /* keep it above owner */
984  {
985  Wnd->ExStyle |= WS_EX_TOPMOST;
986  break;
987  }
988  WndInsertBefore = WndInsertBefore->spwndNext;
989  }
990  }
991 
992  IntLinkWindow(Wnd, WndInsertBefore ? WndInsertBefore->spwndPrev : NULL);
993  }
994  else
995  {
996  /* Link it after hWndPrev */
997  PWND WndInsertAfter;
998 
999  WndInsertAfter = UserGetWindowObject(hWndPrev);
1000  /* Are we called with an erroneous handle */
1001  if (WndInsertAfter == NULL)
1002  {
1003  /* Link in a default position */
1004  IntLinkHwnd(Wnd, HWND_TOP);
1005  return;
1006  }
1007 
1008  if (Wnd == WndInsertAfter)
1009  ERR("IntLinkHwnd -- Trying to link window 0x%p to itself!!\n", Wnd);
1010  IntLinkWindow(Wnd, WndInsertAfter);
1011 
1012  /* Fix the WS_EX_TOPMOST flag */
1013  if (!(WndInsertAfter->ExStyle & WS_EX_TOPMOST))
1014  {
1015  Wnd->ExStyle &= ~WS_EX_TOPMOST;
1016  }
1017  else
1018  {
1019  if (WndInsertAfter->spwndNext &&
1020  (WndInsertAfter->spwndNext->ExStyle & WS_EX_TOPMOST))
1021  {
1022  Wnd->ExStyle |= WS_EX_TOPMOST;
1023  }
1024  }
1025  }
1026  Wnd->ExStyle2 |= WS_EX2_LINKED;
1027 }
DWORD ExStyle
Definition: ntuser.h:668
VOID FASTCALL IntUnlinkWindow(PWND Wnd)
Definition: window.c:1306
DWORD ExStyle2
Definition: ntuser.h:709
#define WS_EX2_LINKED
Definition: ntuser.h:644
#define HWND_TOPMOST
Definition: winuser.h:1194
#define HWND_TOP
Definition: winuser.h:1193
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:937
struct _WND * spwndOwner
Definition: ntuser.h:679
smooth NULL
Definition: ftsmooth.c:416
struct _WND * spwndNext
Definition: ntuser.h:675
#define HWND_BOTTOM
Definition: winuser.h:1191
#define WS_EX_TOPMOST
Definition: pedump.c:647
#define ERR(fmt,...)
Definition: debug.h:109
Definition: ntuser.h:657
VOID FASTCALL IntLinkWindow(PWND Wnd, PWND WndInsertAfter)
Definition: window.c:899
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
struct _WND * spwndParent
Definition: ntuser.h:677
#define HWND_NOTOPMOST
Definition: winuser.h:1192
struct _WND * spwndPrev
Definition: ntuser.h:676

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

◆ IntLinkWindow()

VOID FASTCALL IntLinkWindow ( PWND  Wnd,
PWND  WndInsertAfter 
)

Definition at line 899 of file window.c.

903 {
904  if (Wnd == WndInsertAfter)
905  {
906  ERR("IntLinkWindow -- Trying to link window 0x%p to itself!!\n", Wnd);
907  return;
908  }
909 
910  Wnd->spwndPrev = WndInsertAfter;
911  if (Wnd->spwndPrev)
912  {
913  /* Link after WndInsertAfter */
914  ASSERT(Wnd != WndInsertAfter->spwndNext);
915  Wnd->spwndNext = WndInsertAfter->spwndNext;
916  if (Wnd->spwndNext)
917  Wnd->spwndNext->spwndPrev = Wnd;
918 
919  ASSERT(Wnd != Wnd->spwndPrev);
920  Wnd->spwndPrev->spwndNext = Wnd;
921  }
922  else
923  {
924  /* Link at the top */
925  ASSERT(Wnd != Wnd->spwndParent->spwndChild);
926  Wnd->spwndNext = Wnd->spwndParent->spwndChild;
927  if (Wnd->spwndNext)
928  Wnd->spwndNext->spwndPrev = Wnd;
929 
930  Wnd->spwndParent->spwndChild = Wnd;
931  }
932 }
struct _WND * spwndNext
Definition: ntuser.h:675
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ERR(fmt,...)
Definition: debug.h:109
struct _WND * spwndParent
Definition: ntuser.h:677
struct _WND * spwndPrev
Definition: ntuser.h:676

Referenced by IntLinkHwnd().

◆ IntProcessOwnerSwap()

VOID FASTCALL IntProcessOwnerSwap ( PWND  Wnd,
PWND  WndNewOwner,
PWND  WndOldOwner 
)

Definition at line 1030 of file window.c.

1031 {
1032  if (WndOldOwner)
1033  {
1034  if (Wnd->head.pti != WndOldOwner->head.pti)
1035  {
1036  if (!WndNewOwner ||
1037  Wnd->head.pti == WndNewOwner->head.pti ||
1038  WndOldOwner->head.pti != WndNewOwner->head.pti )
1039  {
1040  //ERR("ProcessOwnerSwap Old out.\n");
1041  UserAttachThreadInput(Wnd->head.pti, WndOldOwner->head.pti, FALSE);
1042  }
1043  }
1044  }
1045  if (WndNewOwner)
1046  {
1047  if (Wnd->head.pti != WndNewOwner->head.pti)
1048  {
1049  if (!WndOldOwner ||
1050  WndOldOwner->head.pti != WndNewOwner->head.pti )
1051  {
1052  //ERR("ProcessOwnerSwap New in.\n");
1053  UserAttachThreadInput(Wnd->head.pti, WndNewOwner->head.pti, TRUE);
1054  }
1055  }
1056  }
1057  // FIXME: System Tray checks.
1058 }
#define TRUE
Definition: types.h:120
NTSTATUS FASTCALL UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
Definition: input.c:479
THRDESKHEAD head
Definition: ntuser.h:659

Referenced by IntSetOwner().

◆ IntRemoveTrackMouseEvent()

VOID FASTCALL IntRemoveTrackMouseEvent ( PDESKTOP  pDesk)

Definition at line 345 of file mouse.c.

347 {
348  /* Generate a leave message */
349  if (pDesk->dwDTFlags & DF_TME_LEAVE)
350  {
351  UINT uMsg = (pDesk->htEx != HTCLIENT) ? WM_NCMOUSELEAVE : WM_MOUSELEAVE;
352  UserPostMessage(UserHMGetHandle(pDesk->spwndTrack), uMsg, 0, 0);
353  }
354  /* Kill the timer */
355  if (pDesk->dwDTFlags & DF_TME_HOVER)
357 
358  /* Reset state */
359  pDesk->dwDTFlags &= ~(DF_TME_LEAVE|DF_TME_HOVER);
360  pDesk->spwndTrack = NULL;
361 }
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1181
DWORD htEx
Definition: desktop.h:32
#define TRUE
Definition: types.h:120
PWND spwndTrack
Definition: desktop.h:31
#define ID_EVENT_SYSTIMER_MOUSEHOVER
Definition: timer.h:27
BOOL FASTCALL IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
Definition: timer.c:573
#define DF_TME_LEAVE
Definition: desktop.h:48
DWORD dwDTFlags
Definition: desktop.h:12
#define WM_MOUSELEAVE
Definition: commctrl.h:4946
smooth NULL
Definition: ftsmooth.c:416
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define DF_TME_HOVER
Definition: desktop.h:47
unsigned int UINT
Definition: ndis.h:50
#define WM_NCMOUSELEAVE
Definition: winuser.h:1824
#define HTCLIENT
Definition: winuser.h:2450

Referenced by IntSendDestroyMsg().

◆ IntSendDestroyMsg()

static void IntSendDestroyMsg ( HWND  hWnd)
static

Definition at line 433 of file window.c.

434 {
435  PTHREADINFO ti;
436  PWND Window;
437 
440 
441  if (Window)
442  {
443  /*
444  * Look whether the focus is within the tree of windows
445  * we will be destroying.
446  */
447  // Rule #1
448  if ( ti->MessageQueue->spwndActive == Window || // Fixes CORE-106 RegSvr32 exit and return focus to CMD.
449  (ti->MessageQueue->spwndActive == NULL && ti->MessageQueue == IntGetFocusMessageQueue()) )
450  {
452  }
453 
454  /* Fixes CMD properties closing and returning focus to CMD */
455  if (ti->MessageQueue->spwndFocus == Window)
456  {
457  if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
458  {
459  co_UserSetFocus(Window->spwndParent);
460  }
461  else
462  {
464  }
465  }
466 
467  if (ti->MessageQueue->CaretInfo.hWnd == UserHMGetHandle(Window))
468  {
469  co_IntDestroyCaret(ti);
470  }
471 
472  /* If the window being destroyed is currently tracked... */
473  if (ti->rpdesk->spwndTrack == Window)
474  {
476  }
477  }
478 
479  /* If the window being destroyed is the current clipboard owner... */
480  if (ti->ppi->prpwinsta != NULL && Window == ti->ppi->prpwinsta->spwndClipOwner)
481  {
482  /* ... make it release the clipboard */
484  }
485 
486  /* Send the WM_DESTROY to the window */
488 
489  /*
490  * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
491  * make sure that the window still exists when we come back.
492  */
493  if (IntIsWindow(hWnd))
494  {
495  HWND* pWndArray;
496  int i;
497 
498  if (!(pWndArray = IntWinListChildren( Window ))) return;
499 
500  for (i = 0; pWndArray[i]; i++)
501  {
502  if (IntIsWindow( pWndArray[i] )) IntSendDestroyMsg( pWndArray[i] );
503  }
505  }
506  else
507  {
508  TRACE("destroyed itself while in WM_DESTROY!\n");
509  }
510 }
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1196
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
HWND hWnd
Definition: settings.c:17
VOID FASTCALL UserClipboardRelease(PWND pWindow)
Definition: clipboard.c:374
#define WS_CHILD
Definition: pedump.c:617
struct _WINSTATION_OBJECT * prpwinsta
Definition: win32.h:257
VOID FASTCALL co_WinPosActivateOtherWindow(PWND Wnd)
Definition: winpos.c:395
PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue(VOID)
Definition: desktop.c:1271
struct _DESKTOP * rpdesk
Definition: win32.h:91
PPROCESSINFO ppi
Definition: win32.h:87
Definition: window.c:29
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BOOL FASTCALL co_IntDestroyCaret(PTHREADINFO Win32Thread)
Definition: caret.c:164
smooth NULL
Definition: ftsmooth.c:416
#define WM_DESTROY
Definition: winuser.h:1591
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define TRACE(s)
Definition: solgame.cpp:4
static void IntSendDestroyMsg(HWND hWnd)
Definition: window.c:433
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:157
int Window
Definition: x11stubs.h:26
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:255
Definition: ntuser.h:657
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:88
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define WS_POPUP
Definition: pedump.c:616
VOID FASTCALL IntRemoveTrackMouseEvent(PDESKTOP pDesk)
Definition: mouse.c:345
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define USERTAG_WINDOWLIST
Definition: tags.h:297

Referenced by co_UserDestroyWindow().

◆ IntSendParentNotify()

static void IntSendParentNotify ( PWND  pWindow,
UINT  msg 
)
static

Definition at line 1503 of file window.c.

1504 {
1505  if ( (pWindow->style & (WS_CHILD | WS_POPUP)) == WS_CHILD &&
1506  !(pWindow->ExStyle & WS_EX_NOPARENTNOTIFY))
1507  {
1508  if (VerifyWnd(pWindow->spwndParent) && !UserIsDesktopWindow(pWindow->spwndParent))
1509  {
1511  UserRefObjectCo(pWindow->spwndParent, &Ref);
1512  co_IntSendMessage( pWindow->spwndParent->head.h,
1514  MAKEWPARAM( msg, pWindow->IDMenu),
1515  (LPARAM)pWindow->head.h );
1516  UserDerefObjectCo(pWindow->spwndParent);
1517  }
1518  }
1519 }
DWORD ExStyle
Definition: ntuser.h:668
#define MAKEWPARAM(l, h)
Definition: winuser.h:3948
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
#define WS_CHILD
Definition: pedump.c:617
#define WM_PARENTNOTIFY
Definition: winuser.h:1785
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
THRDESKHEAD head
Definition: ntuser.h:659
Definition: object.h:3
LONG_PTR LPARAM
Definition: windef.h:208
UINT_PTR IDMenu
Definition: ntuser.h:695
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1281
#define WS_EX_NOPARENTNOTIFY
Definition: pedump.c:646
#define WS_POPUP
Definition: pedump.c:616
#define msg(x)
Definition: auth_time.c:54
struct _WND * spwndParent
Definition: ntuser.h:677
PWND FASTCALL VerifyWnd(PWND pWnd)
Definition: window.c:64
DWORD style
Definition: ntuser.h:670

Referenced by co_UserCreateWindowEx(), and co_UserDestroyWindow().

◆ IntSetOwner()

HWND FASTCALL IntSetOwner ( HWND  hWnd,
HWND  hWndNewOwner 
)

Definition at line 1061 of file window.c.

1062 {
1063  PWND Wnd, WndOldOwner, WndNewOwner;
1064  HWND ret;
1065 
1066  Wnd = IntGetWindowObject(hWnd);
1067  if(!Wnd)
1068  return NULL;
1069 
1070  WndOldOwner = Wnd->spwndOwner;
1071 
1072  ret = WndOldOwner ? UserHMGetHandle(WndOldOwner) : 0;
1073  WndNewOwner = UserGetWindowObject(hWndNewOwner);
1074 
1075  if (!WndNewOwner && hWndNewOwner)
1076  {
1078  ret = NULL;
1079  goto Error;
1080  }
1081 
1082  /* if parent belongs to a different thread and the window isn't */
1083  /* top-level, attach the two threads */
1084  IntProcessOwnerSwap(Wnd, WndNewOwner, WndOldOwner);
1085 
1086  if (IntValidateOwnerDepth(Wnd, WndNewOwner))
1087  {
1088  if (WndNewOwner)
1089  {
1090  Wnd->spwndOwner= WndNewOwner;
1091  }
1092  else
1093  {
1094  Wnd->spwndOwner = NULL;
1095  }
1096  }
1097  else
1098  {
1099  IntProcessOwnerSwap(Wnd, WndOldOwner, WndNewOwner);
1101  ret = NULL;
1102  }
1103 Error:
1104  UserDereferenceObject(Wnd);
1105  return ret;
1106 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
BOOL FASTCALL IntValidateOwnerDepth(PWND Wnd, PWND Owner)
Definition: window.c:339
HWND hWnd
Definition: settings.c:17
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
PWND FASTCALL IntGetWindowObject(HWND hWnd)
Definition: window.c:51
struct _WND * spwndOwner
Definition: ntuser.h:679
smooth NULL
Definition: ftsmooth.c:416
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
BOOL Error
Definition: chkdsk.c:66
int ret
Definition: ntuser.h:657
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
VOID FASTCALL IntProcessOwnerSwap(PWND Wnd, PWND WndNewOwner, PWND WndOldOwner)
Definition: window.c:1030

Referenced by co_IntSetWindowLongPtr().

◆ IntSetStyle()

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

Definition at line 124 of file window.c.

125 {
126  ULONG styleOld, styleNew;
127  styleOld = pwnd->style;
128  styleNew = (pwnd->style | set_bits) & ~clear_bits;
129  if (styleNew == styleOld) return styleNew;
130  pwnd->style = styleNew;
131  if ((styleOld ^ styleNew) & WS_VISIBLE) // State Change.
132  {
133  if (styleOld & WS_VISIBLE) pwnd->head.pti->cVisWindows--;
134  if (styleNew & WS_VISIBLE) pwnd->head.pti->cVisWindows++;
135  DceResetActiveDCEs( pwnd );
136  }
137  return styleOld;
138 }
THRDESKHEAD head
Definition: ntuser.h:659
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:815
unsigned int ULONG
Definition: retypes.h:1
#define WS_VISIBLE
Definition: pedump.c:620
DWORD style
Definition: ntuser.h:670

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

◆ IntSetWindowProc()

static WNDPROC IntSetWindowProc ( PWND  pWnd,
WNDPROC  NewWndProc,
BOOL  Ansi 
)
static

Definition at line 795 of file window.c.

798 {
799  INT i;
800  PCALLPROCDATA CallProc;
801  PCLS Class;
802  WNDPROC Ret, chWndProc = NULL;
803 
804  // Retrieve previous window proc.
805  Ret = IntGetWindowProc(pWnd, Ansi);
806 
807  Class = pWnd->pcls;
808 
809  if (IsCallProcHandle(NewWndProc))
810  {
811  CallProc = UserGetObject(gHandleTable, NewWndProc, TYPE_CALLPROC);
812  if (CallProc)
813  { // Reset new WndProc.
814  NewWndProc = CallProc->pfnClientPrevious;
815  // Reset Ansi from CallProc handle. This is expected with wine "deftest".
816  Ansi = !!(CallProc->wType & UserGetCPDU2A);
817  }
818  }
819  // Switch from Client Side call to Server Side call if match. Ref: "deftest".
820  for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
821  {
822  if (GETPFNCLIENTW(i) == NewWndProc)
823  {
824  chWndProc = GETPFNSERVER(i);
825  break;
826  }
827  if (GETPFNCLIENTA(i) == NewWndProc)
828  {
829  chWndProc = GETPFNSERVER(i);
830  break;
831  }
832  }
833  // If match, set/reset to Server Side and clear ansi.
834  if (chWndProc)
835  {
836  pWnd->lpfnWndProc = chWndProc;
837  pWnd->Unicode = TRUE;
838  pWnd->state &= ~WNDS_ANSIWINDOWPROC;
840  }
841  else
842  {
843  pWnd->Unicode = !Ansi;
844  // Handle the state change in here.
845  if (Ansi)
846  pWnd->state |= WNDS_ANSIWINDOWPROC;
847  else
848  pWnd->state &= ~WNDS_ANSIWINDOWPROC;
849 
850  if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
852 
853  if (!NewWndProc) NewWndProc = pWnd->lpfnWndProc;
854 
855  if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
856  {
857  if (Ansi)
858  {
859  if (GETPFNCLIENTW(Class->fnid) == NewWndProc)
860  chWndProc = GETPFNCLIENTA(Class->fnid);
861  }
862  else
863  {
864  if (GETPFNCLIENTA(Class->fnid) == NewWndProc)
865  chWndProc = GETPFNCLIENTW(Class->fnid);
866  }
867  }
868  // Now set the new window proc.
869  pWnd->lpfnWndProc = (chWndProc ? chWndProc : NewWndProc);
870  }
871  return Ret;
872 }
static const WCHAR Class[]
Definition: cfgmgr.c:39
#define TRUE
Definition: types.h:120
#define GETPFNSERVER(fnid)
Definition: ntuser.h:870
WNDPROC pfnClientPrevious
Definition: ntuser.h:520
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:867
WNDPROC lpfnWndProc
Definition: ntuser.h:682
int32_t INT
Definition: typedefs.h:56
GETCPD wType
Definition: ntuser.h:521
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
Definition: ntuser.h:533
#define FNID_SWITCH
Definition: ntuser.h:827
WNDPROC FASTCALL IntGetWindowProc(PWND pWnd, BOOL Ansi)
Definition: window.c:735
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:865
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2880
#define FNID_GHOST
Definition: ntuser.h:837
PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type)
Definition: object.c:462
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:592
#define FNID_BUTTON
Definition: ntuser.h:828
DWORD state
Definition: ntuser.h:665
static __inline BOOL IsCallProcHandle(IN WNDPROC lpWndProc)
Definition: class.h:13
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:591
#define FNID_FIRST
Definition: ntuser.h:820
UINT Unicode
Definition: ntuser.h:720
PCLS pcls
Definition: ntuser.h:684

Referenced by co_IntSetWindowLongPtr().

◆ IntShowOwnedPopups()

BOOL FASTCALL IntShowOwnedPopups ( PWND  OwnerWnd,
BOOL  fShow 
)

Definition at line 4442 of file window.c.

4443 {
4444  int count = 0;
4445  PWND pWnd;
4446  HWND *win_array;
4447 
4448 // ASSERT(OwnerWnd);
4449 
4450  TRACE("Enter ShowOwnedPopups Show: %s\n", (fShow ? "TRUE" : "FALSE"));
4451 
4452  /* NOTE: Popups are not children */
4453  win_array = IntWinListOwnedPopups(OwnerWnd);
4454 
4455  if (!win_array)
4456  return TRUE;
4457 
4458  while (win_array[count])
4459  count++;
4460  while (--count >= 0)
4461  {
4462  if (!(pWnd = ValidateHwndNoErr( win_array[count] )))
4463  continue;
4464  if (pWnd->spwndOwner != OwnerWnd)
4465  continue;
4466 
4467  if (fShow)
4468  {
4469  if (pWnd->