winpos.h File Reference

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

Go to the source code of this file.

Classes
struct	_CVR
struct	_SMWP

Macros
#define	GetSnapSetting(gspvmember)   (IsSnapEnabled() ? (gspv.gspvmember) : 0)

Typedefs
typedef struct _CVR	CVR
typedef struct _CVR *	PCVR
typedef struct _SMWP	SMWP
typedef struct _SMWP *	PSMWP

Functions
FORCEINLINE BOOL	IntPtInWindow (PWND pwnd, INT x, INT y)
FORCEINLINE BOOL	IntEqualRect (RECTL *lprc1, RECTL *lprc2)
BOOL FASTCALL	ActivateOtherWindowMin (PWND)
UINT FASTCALL	co_WinPosArrangeIconicWindows (PWND parent)
BOOL FASTCALL	IntGetClientOrigin (PWND Window, LPPOINT Point)
LRESULT FASTCALL	co_WinPosGetNonClientSize (PWND Window, RECTL *WindowRect, RECTL *ClientRect)
UINT FASTCALL	co_WinPosGetMinMaxInfo (PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
UINT FASTCALL	co_WinPosMinMaximize (PWND WindowObject, UINT ShowFlag, RECTL *NewPos)
BOOLEAN FASTCALL	co_WinPosSetWindowPos (PWND Wnd, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
BOOLEAN FASTCALL	co_WinPosShowWindow (PWND Window, INT Cmd)
void FASTCALL	co_WinPosSendSizeMove (PWND Window)
PWND APIENTRY	co_WinPosWindowFromPoint (IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
VOID FASTCALL	co_WinPosActivateOtherWindow (PWND)
PWND FASTCALL	IntRealChildWindowFromPoint (PWND, LONG, LONG)
BOOL FASTCALL	IntScreenToClient (PWND, LPPOINT)
BOOL FASTCALL	IntClientToScreen (PWND, LPPOINT)
BOOL FASTCALL	IntGetWindowRect (PWND, RECTL *)
BOOL	UserHasWindowEdge (DWORD, DWORD)
VOID	UserGetWindowBorders (DWORD, DWORD, SIZE *, BOOL)
UINT FASTCALL	IntGetWindowSnapEdge (PWND Wnd)
VOID FASTCALL	co_IntCalculateSnapPosition (PWND Wnd, UINT Edge, OUT RECT *Pos)
VOID FASTCALL	co_IntSnapWindow (PWND Wnd, UINT Edge)
VOID FASTCALL	IntSetSnapEdge (PWND Wnd, UINT Edge)
VOID FASTCALL	IntSetSnapInfo (PWND Wnd, UINT Edge, IN const RECT *Pos OPTIONAL)
FORCEINLINE BOOL	IsSnapEnabled (VOID)
FORCEINLINE VOID	co_IntUnsnapWindow (PWND Wnd)
FORCEINLINE BOOLEAN	IntIsWindowSnapped (PWND Wnd)
FORCEINLINE BOOLEAN	IntIsSnapAllowedForWindow (PWND Wnd)

Macro Definition Documentation

GetSnapSetting

#define GetSnapSetting

(

gspvmember

)

(IsSnapEnabled() ? (gspv.gspvmember) : 0)

Definition at line 80 of file winpos.h.

Typedef Documentation

CVR

typedef struct _CVR CVR

PCVR

typedef struct _CVR * PCVR

PSMWP

typedef struct _SMWP * PSMWP

SMWP

typedef struct _SMWP SMWP

Function Documentation

ActivateOtherWindowMin()

BOOL FASTCALL ActivateOtherWindowMin

(

PWND

Wnd

)

Definition at line 285 of file winpos.c.

{
    BOOL ActivePrev, FindTopWnd;
    PWND pWndTopMost, pWndChild, pWndSetActive, pWndTemp, pWndDesk;
    USER_REFERENCE_ENTRY Ref;
    PTHREADINFO pti = gptiCurrent;
 
    //ERR("AOWM 1 %p\n", UserHMGetHandle(Wnd));
    ActivePrev = (pti->MessageQueue->spwndActivePrev != NULL);
    FindTopWnd = TRUE;
 
    if ((pWndTopMost = IntGetLastTopMostWindow()))
       pWndChild = pWndTopMost->spwndNext;
    else
       pWndChild = Wnd->spwndParent->spwndChild;
 
    for (;;)
    {
       if ( ActivePrev )
          pWndSetActive = pti->MessageQueue->spwndActivePrev;
       else
          pWndSetActive = pWndChild;
 
       pWndTemp = NULL;
 
       while(pWndSetActive)
       {
          if ( VerifyWnd(pWndSetActive) &&
              !(pWndSetActive->ExStyle & WS_EX_NOACTIVATE) &&
               (pWndSetActive->style & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE &&
               (!(pWndSetActive->style & WS_ICONIC) /* FIXME MinMax pos? */ ) )
          {
             if (!(pWndSetActive->ExStyle & WS_EX_TOOLWINDOW) )
             {
                UserRefObjectCo(pWndSetActive, &Ref);
                //ERR("ActivateOtherWindowMin Set FG 1\n");
                co_IntSetForegroundWindow(pWndSetActive);
                UserDerefObjectCo(pWndSetActive);
                //ERR("AOWM 2 Exit Good %p\n", UserHMGetHandle(pWndSetActive));
                return TRUE;
             }
             if (!pWndTemp ) pWndTemp = pWndSetActive;
          }
          if ( ActivePrev )
          {
             ActivePrev = FALSE;
             pWndSetActive = pWndChild;
          }
          else
             pWndSetActive = pWndSetActive->spwndNext;
       }
 
       if ( !FindTopWnd ) break;
       FindTopWnd = FALSE;
 
       if ( pWndChild )
       {
          pWndChild = pWndChild->spwndParent->spwndChild;
          continue;
       }
 
       if (!(pWndDesk = IntGetThreadDesktopWindow(pti)))
       {
          pWndChild = NULL;
          continue;
       }
       pWndChild = pWndDesk->spwndChild;
    }
 
    if ((pWndSetActive = pWndTemp))
    {
       UserRefObjectCo(pWndSetActive, &Ref);
       //ERR("ActivateOtherWindowMin Set FG 2\n");
       co_IntSetForegroundWindow(pWndSetActive);
       UserDerefObjectCo(pWndSetActive);
       //ERR("AOWM 3 Exit Good %p\n", UserHMGetHandle(pWndSetActive));
       return TRUE;
    }
    //ERR("AOWM 4 Bad\n");
    return FALSE;
}

Referenced by co_WinPosShowWindow(), and UserSetActiveWindow().

co_IntCalculateSnapPosition()

VOID FASTCALL co_IntCalculateSnapPosition	(	PWND	Wnd,
		UINT	Edge,
		OUT RECT *	Pos
	)

Definition at line 3952 of file winpos.c.

{
    POINT maxs, mint, maxt;
    UINT width, height;
    UserSystemParametersInfo(SPI_GETWORKAREA, 0, Pos, 0); /* FIXME: MultiMon of PWND */
 
    co_WinPosGetMinMaxInfo(Wnd, &maxs, NULL, &mint, &maxt);
    width = Pos->right - Pos->left;
    width = min(min(max(width / 2, mint.x), maxt.x), width);
    height = Pos->bottom - Pos->top;
    height = min(max(height, mint.y), maxt.y);
 
    switch (Edge)
    {
    case HTTOP: /* Maximized (Calculate RECT snap preview for SC_MOVE) */
        height = min(Pos->bottom - Pos->top, maxs.y);
        break; 
    case HTLEFT:
        Pos->right = width;
        break;
    case HTRIGHT:
        Pos->left = Pos->right - width;
        break;
    default:
        ERR("Unexpected snap edge %#x\n", Edge);
    }
    Pos->bottom = Pos->top + height;
}

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and IntDefWindowProc().

co_IntSnapWindow()

VOID FASTCALL co_IntSnapWindow	(	PWND	Wnd,
		UINT	Edge
	)

Definition at line 3982 of file winpos.c.

{
    RECT newPos;
    BOOLEAN wasSnapped = IntIsWindowSnapped(Wnd);
    UINT normal = !(Wnd->style & (WS_MAXIMIZE | WS_MINIMIZE));
    USER_REFERENCE_ENTRY ref;
    BOOLEAN hasRef = FALSE;
 
    if (Edge == HTTOP)
    {
        co_IntSendMessage(UserHMGetHandle(Wnd), WM_SYSCOMMAND, SC_MAXIMIZE, 0);
        return;
    }
    else if (Edge != HTNOWHERE)
    {
        UserRefObjectCo(Wnd, &ref);
        hasRef = TRUE;
        co_IntCalculateSnapPosition(Wnd, Edge, &newPos);
        IntSetSnapInfo(Wnd, Edge, (wasSnapped || !normal) ? NULL : &Wnd->rcWindow);
    }
    else if (wasSnapped)
    {
        if (!normal)
        {
            IntSetSnapEdge(Wnd, HTNOWHERE);
            return;
        }
        newPos = Wnd->InternalPos.NormalRect; /* Copy RECT now before it is lost */
        IntSetSnapInfo(Wnd, HTNOWHERE, NULL);
    }
    else
    {
        return; /* Already unsnapped, do nothing */
    }
 
    TRACE("WindowSnap: %d->%d\n", IntGetWindowSnapEdge(Wnd), Edge);
    co_WinPosSetWindowPos(Wnd, HWND_TOP,
                          newPos.left,
                          newPos.top,
                          newPos.right - newPos.left,
                          newPos.bottom - newPos.top,
                          0);
    if (hasRef)
        UserDerefObjectCo(Wnd);
}

Referenced by co_IntUnsnapWindow(), DefWndDoSizeMove(), and IntDefWindowProc().

co_IntUnsnapWindow()

FORCEINLINE VOID co_IntUnsnapWindow

(

PWND

Wnd

)

Definition at line 89 of file winpos.h.

{
    co_IntSnapWindow(Wnd, HTNOWHERE);
}

Referenced by IntDefWindowProc().

co_WinPosActivateOtherWindow()

VOID FASTCALL co_WinPosActivateOtherWindow

(

PWND

Wnd

)

Definition at line 397 of file winpos.c.

{
   PWND WndTo = NULL;
   USER_REFERENCE_ENTRY Ref;
 
   ASSERT_REFS_CO(Wnd);
 
   if (IntIsDesktopWindow(Wnd))
   {
      //ERR("WinPosActivateOtherWindow Set Focus Msg Q No window!\n");
      IntSetFocusMessageQueue(NULL);
      return;
   }
 
   /* If this is popup window, try to activate the owner first. */
   if ((Wnd->style & WS_POPUP) && (WndTo = Wnd->spwndOwner))
   {
      TRACE("WPAOW Popup with Owner\n");
      WndTo = UserGetAncestor( WndTo, GA_ROOT );
      if (can_activate_window(WndTo)) goto done;
   }
 
   /* Pick a next top-level window. */
   /* FIXME: Search for non-tooltip windows first. */
   WndTo = Wnd;
   for (;;)
   {
      if (!(WndTo = WndTo->spwndNext))  break;
      if (can_activate_window( WndTo )) goto done;
   }
 
   /*
      Fixes wine win.c:test_SetParent last ShowWindow test after popup dies.
      Check for previous active window to bring to top.
   */
   if (Wnd)
   {
      WndTo = Wnd->head.pti->MessageQueue->spwndActivePrev;
      if (can_activate_window( WndTo )) goto done;
   }
 
   // Find any window to bring to top. Works Okay for wine since it does not see X11 windows.
   WndTo = UserGetDesktopWindow();
   if ((WndTo == NULL) || (WndTo->spwndChild == NULL))
   {
      //ERR("WinPosActivateOtherWindow No window!\n");
      return;
   }
   WndTo = WndTo->spwndChild;
   for (;;)
   {
      if (WndTo == Wnd)
      {
         WndTo = NULL;
         break;
      }
      if (can_activate_window( WndTo )) goto done;
      if (!(WndTo = WndTo->spwndNext))  break;
   }
 
done:
   if (WndTo) UserRefObjectCo(WndTo, &Ref);
 
   if (gpqForeground && (!gpqForeground->spwndActive || Wnd == gpqForeground->spwndActive))
   {
      /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
      //ERR("WinPosActivateOtherWindow Set FG 0x%p hWnd %p\n", WndTo, WndTo ? UserHMGetHandle(WndTo) : NULL);
      if (co_IntSetForegroundWindow(WndTo))
      {
         if (WndTo) UserDerefObjectCo(WndTo);
         return;
      }
   }
   //ERR("WinPosActivateOtherWindow Set Active  0x%p\n",WndTo);
   if (!UserSetActiveWindow(WndTo))  /* Ok for WndTo to be NULL here */
   {
      //ERR("WPAOW SA 1\n");
      UserSetActiveWindow(NULL);
   }
   if (WndTo) UserDerefObjectCo(WndTo);
}

Referenced by co_WinPosShowWindow(), IntForceMinimizeWindow(), IntSendDestroyMsg(), and UserSetActiveWindow().

co_WinPosArrangeIconicWindows()

UINT FASTCALL co_WinPosArrangeIconicWindows

(

PWND

parent

)

Definition at line 737 of file winpos.c.

{
   RECTL rectParent;
   PWND Child;
   INT x, y, xspacing, yspacing, sx, sy;
 
   ASSERT_REFS_CO(parent);
 
   IntGetClientRect( parent, &rectParent );
   // FIXME: Support Minimize Metrics gspv.mm.iArrange.
   // Default: ARW_BOTTOMLEFT
   x = rectParent.left;
   y = rectParent.bottom;
 
   xspacing = UserGetSystemMetrics(SM_CXMINIMIZED);
   yspacing = UserGetSystemMetrics(SM_CYMINIMIZED);
 
   Child = parent->spwndChild;
   while(Child)
   {
      if((Child->style & WS_MINIMIZE) != 0 )
      {
         USER_REFERENCE_ENTRY Ref;
         UserRefObjectCo(Child, &Ref);
 
         sx = x + UserGetSystemMetrics(SM_CXBORDER);
         sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
 
         Child->InternalPos.IconPos.x = sx;
         Child->InternalPos.IconPos.y = sy;
         Child->InternalPos.flags |= WPF_MININIT;
 
         co_WinPosSetWindowPos( Child, 0, sx, sy, xspacing, yspacing, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_ASYNCWINDOWPOS);
 
         UserDerefObjectCo(Child);
 
         if (x <= rectParent.right - xspacing)
            x += xspacing;
         else
         {
            x = rectParent.left;
            y -= yspacing;
         }
      }
      Child = Child->spwndNext;
   }
   return yspacing;
}

Referenced by NtUserCallHwndLock().

co_WinPosGetMinMaxInfo()

UINT FASTCALL co_WinPosGetMinMaxInfo	(	PWND	Window,
		POINT *	MaxSize,
		POINT *	MaxPos,
		POINT *	MinTrack,
		POINT *	MaxTrack
	)

Definition at line 940 of file winpos.c.

{
    MINMAXINFO MinMax;
    PMONITOR monitor;
    INT xinc, yinc;
    LONG style = Window->style;
    LONG adjustedStyle;
    LONG exstyle = Window->ExStyle;
    RECT rc;
    DWORD adjust;
 
    ASSERT_REFS_CO(Window);
 
    /* Compute default values */
 
    rc = Window->rcWindow;
    MinMax.ptReserved.x = rc.left;
    MinMax.ptReserved.y = rc.top;
 
    if ((style & WS_CAPTION) == WS_CAPTION)
        adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
    else
        adjustedStyle = style;
 
    if (Window->spwndParent)
        IntGetClientRect(Window->spwndParent, &rc);
 
    adjust = IntGetWindowBorders(adjustedStyle, exstyle);
 
    // Handle special case while maximized. CORE-15893
    if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
         adjust += 1;
 
    xinc = yinc = adjust;
 
    if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
    {
        xinc += UserGetSystemMetrics(SM_CXFRAME) - UserGetSystemMetrics(SM_CXDLGFRAME);
        yinc += UserGetSystemMetrics(SM_CYFRAME) - UserGetSystemMetrics(SM_CYDLGFRAME);
    }
 
    RECTL_vInflateRect( &rc,
                        xinc * UserGetSystemMetrics(SM_CXBORDER),
                        yinc * UserGetSystemMetrics(SM_CYBORDER) );
 
    xinc = -rc.left;
    yinc = -rc.top;
 
    MinMax.ptMaxSize.x = rc.right - rc.left;
    MinMax.ptMaxSize.y = rc.bottom - rc.top;
    if (style & (WS_DLGFRAME | WS_BORDER))
    {
        MinMax.ptMinTrackSize.x = UserGetSystemMetrics(SM_CXMINTRACK);
        MinMax.ptMinTrackSize.y = UserGetSystemMetrics(SM_CYMINTRACK);
    }
    else
    {
        MinMax.ptMinTrackSize.x = 2 * xinc;
        MinMax.ptMinTrackSize.y = 2 * yinc;
    }
    MinMax.ptMaxTrackSize.x = UserGetSystemMetrics(SM_CXMAXTRACK);
    MinMax.ptMaxTrackSize.y = UserGetSystemMetrics(SM_CYMAXTRACK);
    MinMax.ptMaxPosition.x = -xinc;
    MinMax.ptMaxPosition.y = -yinc;
 
    if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
 
    co_IntSendMessage(UserHMGetHandle(Window), WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
 
    /* if the app didn't change the values, adapt them for the current monitor */
    if ((monitor = UserGetPrimaryMonitor()))
    {
        RECT rc_work;
 
        rc_work = monitor->rcMonitor;
 
        if (style & WS_MAXIMIZEBOX)
        {
            if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
               rc_work = monitor->rcWork;
        }
 
        if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
            MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
        {
            MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
            MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
        }
        if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
        {
            MinMax.ptMaxPosition.x = rc_work.left - xinc;
            MinMax.ptMaxPosition.y = rc_work.top - yinc;
        }
        if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
            MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
        {
            Window->state |= WNDS_MAXIMIZESTOMONITOR;
        }
        else
            Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
    }
 
 
    MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
                                  MinMax.ptMinTrackSize.x);
    MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
                                  MinMax.ptMinTrackSize.y);
 
    if (MaxSize)
       *MaxSize = MinMax.ptMaxSize;
    if (MaxPos)
       *MaxPos = MinMax.ptMaxPosition;
    if (MinTrack)
       *MinTrack = MinMax.ptMinTrackSize;
    if (MaxTrack)
       *MaxTrack = MinMax.ptMaxTrackSize;
 
    return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
}

Referenced by co_IntCalculateSnapPosition(), co_UserCreateWindowEx(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and DefWndHandleWindowPosChanging().

co_WinPosGetNonClientSize()

LRESULT FASTCALL co_WinPosGetNonClientSize	(	PWND	Window,
		RECTL *	WindowRect,
		RECTL *	ClientRect
	)

co_WinPosMinMaximize()

UINT FASTCALL co_WinPosMinMaximize	(	PWND	WindowObject,
		UINT	ShowFlag,
		RECTL *	NewPos
	)

co_WinPosSendSizeMove()

void FASTCALL co_WinPosSendSizeMove

(

PWND

Window

)

Definition at line 2416 of file winpos.c.

{
    RECTL Rect;
    LPARAM lParam;
    WPARAM wParam = SIZE_RESTORED;
 
    IntGetClientRect(Wnd, &Rect);
    lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
 
    Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
 
    if (Wnd->style & WS_MAXIMIZE)
    {
        wParam = SIZE_MAXIMIZED;
    }
    else if (Wnd->style & WS_MINIMIZE)
    {
        wParam = SIZE_MINIMIZED;
        lParam = 0;
    }
 
    co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SIZE, wParam, lParam);
 
    if (UserIsDesktopWindow(Wnd->spwndParent))
       lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
    else
       lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
 
    co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_MOVE, 0, lParam);
 
    IntEngWindowChanged(Wnd, WOC_RGN_CLIENT);
}

Referenced by co_UserCreateWindowEx(), and co_WinPosShowWindow().

co_WinPosSetWindowPos()

BOOLEAN FASTCALL co_WinPosSetWindowPos	(	PWND	Wnd,
		HWND	WndInsertAfter,
		INT	x,
		INT	y,
		INT	cx,
		INT	cy,
		UINT	flags
	)

Definition at line 1792 of file winpos.c.

{
   WINDOWPOS WinPos;
   RECTL NewWindowRect;
   RECTL NewClientRect;
   RECTL valid_rects[2];
   PREGION VisBefore = NULL;
   PREGION VisBeforeJustClient = NULL;
   PREGION VisAfter = NULL;
   PREGION CopyRgn = NULL;
   ULONG WvrFlags = 0;
   RECTL OldWindowRect, OldClientRect;
   int RgnType;
   HDC Dc;
   RECTL CopyRect;
   PWND Ancestor;
   BOOL bPointerInWindow, PosChanged = FALSE;
   PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
   ASSERT_REFS_CO(Window);
 
   TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
         Window, WndInsertAfter, x, y, cx, cy, flags);
#if DBG
   dump_winpos_flags(flags);
#endif
 
   /* FIXME: Get current active window from active queue. Why? since r2915. */
 
   bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
 
   WinPos.hwnd = UserHMGetHandle(Window);
   WinPos.hwndInsertAfter = WndInsertAfter;
   WinPos.x = x;
   WinPos.y = y;
   WinPos.cx = cx;
   WinPos.cy = cy;
   WinPos.flags = flags;
 
   if ( flags & SWP_ASYNCWINDOWPOS )
   {
      LRESULT lRes;
      PWINDOWPOS ppos = ExAllocatePoolWithTag(PagedPool, sizeof(WINDOWPOS), USERTAG_SWP);
      if ( ppos )
      {
         WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
         *ppos = WinPos;
         /* Yes it's a pointer inside Win32k! */
         lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
         /* We handle this the same way as Event Hooks and Hooks. */
         if ( !lRes )
         {
            ExFreePoolWithTag(ppos, USERTAG_SWP);
            return FALSE;
         }
         return TRUE;
      }
      return FALSE;
   }
 
   co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
 
   /* Does the window still exist? */
   if (!IntIsWindow(WinPos.hwnd))
   {
      TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
      EngSetLastError(ERROR_INVALID_WINDOW_HANDLE);
      return FALSE;
   }
 
   /* Fix up the flags. */
   if (!WinPosFixupFlags(&WinPos, Window))
   {
      // See Note.
      return TRUE;
   }
 
   Ancestor = UserGetAncestor(Window, GA_PARENT);
   if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
         Ancestor && UserHMGetHandle(Ancestor) == IntGetDesktopWindow() )
   {
      WinPos.hwndInsertAfter = WinPosDoOwnedPopups(Window, WinPos.hwndInsertAfter);
   }
 
   if (!(WinPos.flags & SWP_NOREDRAW))
   {
      /* Compute the visible region before the window position is changed */
      if (!(WinPos.flags & SWP_SHOWWINDOW) &&
           (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
                             SWP_HIDEWINDOW | SWP_FRAMECHANGED)) !=
            (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER))
      {
         VisBefore = VIS_ComputeVisibleRegion(Window, FALSE, FALSE,
                                              (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
 
         if ( VisBefore != NULL &&
              REGION_Complexity(VisBefore) == NULLREGION )
         {
            REGION_Delete(VisBefore);
            VisBefore = NULL;
         }
         else if(VisBefore)
         {
            REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
         }
 
         /* Calculate the non client area for resizes, as this is used in the copy region */
         if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
         {
             VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
                 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
 
             if ( VisBeforeJustClient != NULL &&
                 REGION_Complexity(VisBeforeJustClient) == NULLREGION )
             {
                 REGION_Delete(VisBeforeJustClient);
                 VisBeforeJustClient = NULL;
             }
             else if(VisBeforeJustClient)
             {
                 REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
             }
         }
      }
   }
 
   if (Window->hrgnNewFrame)
   {
       SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
       Window->hrgnNewFrame = NULL;
   }
 
   WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
 
//   ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
//      valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
//      valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
 
   /* Validate link windows. (also take into account shell window in hwndShellWindow) */
   if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
   {
      IntLinkHwnd(Window, WinPos.hwndInsertAfter);
   }
 
   OldWindowRect = Window->rcWindow;
   OldClientRect = Window->rcClient;
 
   if (NewClientRect.left != OldClientRect.left ||
       NewClientRect.top  != OldClientRect.top)
   {
      // Move child window if their parent is moved. Keep Child window relative to Parent...
      WinPosInternalMoveWindow(Window,
                               NewClientRect.left - OldClientRect.left,
                               NewClientRect.top - OldClientRect.top);
      PosChanged = TRUE;
   }
 
   Window->rcWindow = NewWindowRect;
   Window->rcClient = NewClientRect;
 
   /* erase parent when hiding or resizing child */
   if (WinPos.flags & SWP_HIDEWINDOW)
   {
      /* Clear the update region */
      co_UserRedrawWindow( Window,
                           NULL,
                           0,
                           RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_ALLCHILDREN);
 
      if (UserIsDesktopWindow(Window->spwndParent))
         co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (WPARAM)UserHMGetHandle(Window), 0);
 
      Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
      Window->head.pti->cVisWindows--;
      IntNotifyWinEvent(EVENT_OBJECT_HIDE, Window, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
   }
   else if (WinPos.flags & SWP_SHOWWINDOW)
   {
      if (Window->style & WS_CHILD)
      {
         if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
         {
            co_IntShellHookNotify(HSHELL_WINDOWCREATED, (WPARAM)UserHMGetHandle(Window), 0);
            if (!(WinPos.flags & SWP_NOACTIVATE))
               UpdateShellHook(Window);
         }
      }
      else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
          (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
           (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
      {
         if (!UserIsDesktopWindow(Window))
         {
            co_IntShellHookNotify(HSHELL_WINDOWCREATED, (WPARAM)UserHMGetHandle(Window), 0);
            if (!(WinPos.flags & SWP_NOACTIVATE))
               UpdateShellHook(Window);
         }
      }
 
      Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
      Window->head.pti->cVisWindows++;
      IntNotifyWinEvent(EVENT_OBJECT_SHOW, Window, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
   }
   else
   {
      IntCheckFullscreen(Window);
   }
 
   if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
   {
      NtGdiOffsetRgn(Window->hrgnUpdate,
                     NewWindowRect.left - OldWindowRect.left,
                     NewWindowRect.top - OldWindowRect.top);
   }
 
   DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
 
   // Change or update, set send non-client paint flag.
   if ( Window->style & WS_VISIBLE &&
       (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
   {
      TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
      Window->state |= WNDS_SENDNCPAINT;
   }
 
   /*
    * Request a full non-client repaint when the frame geometry changes.
    * Otherwise, copied bits can retain parts of the old frame. CORE-20769.
    */
   if ((Window->style & WS_VISIBLE) &&
       ((WinPos.flags & SWP_FRAMECHANGED) ||
        (OldWindowRect.right - OldWindowRect.left) != (NewWindowRect.right - NewWindowRect.left) ||
        (OldWindowRect.bottom - OldWindowRect.top) != (NewWindowRect.bottom - NewWindowRect.top)))
   {
      Window->state |= WNDS_SENDNCPAINT;
      Window->state2 |= WNDS2_FORCEFULLNCPAINTCLIPRGN;
   }
 
   if ((!(WinPos.flags & SWP_NOREDRAW) && ((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)) ||
       ((WinPos.flags & SWP_NOZORDER) && (WinPos.flags & SWP_NOOWNERZORDER)))
   {
      /* Determine the new visible region */
      VisAfter = VIS_ComputeVisibleRegion(Window, FALSE, FALSE,
                                          (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
 
      if ( VisAfter != NULL &&
           REGION_Complexity(VisAfter) == NULLREGION )
      {
         REGION_Delete(VisAfter);
         VisAfter = NULL;
      }
      else if(VisAfter)
      {
          /* Clip existing update region to new window size */
          if (Window->hrgnUpdate != NULL)
          {
              PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
              if (RgnUpdate)
              {
                  RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, VisAfter, RGN_AND);
                  REGION_UnlockRgn(RgnUpdate);
              }
          }
          REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
      }
 
      /*
       * Determine which pixels can be copied from the old window position
       * to the new. Those pixels must be visible in both the old and new
       * position. Also, check the class style to see if the windows of this
       * class need to be completely repainted on (horizontal/vertical) size
       * change.
       */
      if (VisBefore != NULL &&
          VisAfter != NULL &&
          !(WvrFlags & WVR_REDRAW) &&
          !(WinPos.flags & SWP_NOCOPYBITS) &&
          !(Window->ExStyle & WS_EX_TRANSPARENT))
      {
 
         /*
          * If this is (also) a window resize, the whole nonclient area
          * needs to be repainted. So we limit the copy to the client area,
          * 'cause there is no use in copying it (would possibly cause
          * "flashing" too). However, if the copy region is already empty,
          * we don't have to crop (can't take anything away from an empty
          * region...)
          */
 
         CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
         if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
            RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
         else if (VisBeforeJustClient != NULL)
         {
            RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
         }
 
         /* Now use in copying bits which are in the update region. */
         if (Window->hrgnUpdate != NULL)
         {
            PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
            if (RgnUpdate)
            {
                REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
                IntGdiCombineRgn(CopyRgn, CopyRgn, RgnUpdate, RGN_DIFF);
                REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
                REGION_UnlockRgn(RgnUpdate);
            }
         }
 
         /*
          * Now, get the bounding box of the copy region. If it's empty
          * there's nothing to copy. Also, it's no use copying bits onto
          * themselves.
          */
         if (REGION_GetRgnBox(CopyRgn, &CopyRect) == NULLREGION)
         {
            /* Nothing to copy, clean up */
            REGION_Delete(CopyRgn);
            CopyRgn = NULL;
         }
         else if ( OldWindowRect.left != NewWindowRect.left ||
                   OldWindowRect.top != NewWindowRect.top ||
                  (WinPos.flags & SWP_FRAMECHANGED) )
         {
             HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
             PREGION DcRgnObj = REGION_LockRgn(DcRgn);
 
          /*
           * Small trick here: there is no function to bitblt a region. So
           * we set the region as the clipping region, take the bounding box
           * of the region and bitblt that. Since nothing outside the clipping
           * region is copied, this has the effect of bitblt'ing the region.
           *
           * Since NtUserGetDCEx takes ownership of the clip region, we need
           * to create a copy of CopyRgn and pass that. We need CopyRgn later
           */
            IntGdiCombineRgn(DcRgnObj, CopyRgn, NULL, RGN_COPY);
            REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
            REGION_UnlockRgn(DcRgnObj);
            Dc = UserGetDCEx( Window,
                              DcRgn,
                              DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
            NtGdiBitBlt( Dc,
                         CopyRect.left, CopyRect.top,
                         CopyRect.right - CopyRect.left,
                         CopyRect.bottom - CopyRect.top,
                         Dc,
                         CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
                         CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
                         SRCCOPY,
                         CLR_INVALID,
                         0);
 
            UserReleaseDC(Window, Dc, FALSE);
            IntValidateParent(Window, CopyRgn);
            GreDeleteObject(DcRgn);
         }
      }
      else
      {
         CopyRgn = NULL;
      }
 
      /* We need to redraw what wasn't visible before or force a redraw */
      if (VisAfter != NULL)
      {
         PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
         if (DirtyRgn)
         {
             if (CopyRgn != NULL)
             {
                RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
             }
             else
             {
                RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
             }
 
             if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
             {
            /* old code
                NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
                IntInvalidateWindows( Window,
                                      DirtyRgn,
                   RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
             }
             GreDeleteObject(DirtyRgn);
             */
 
                PWND Parent = Window->spwndParent;
 
                REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
 
                if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
                {
                   IntInvalidateWindows( Parent, DirtyRgn, RDW_ERASE | RDW_INVALIDATE);
                   co_IntPaintWindows(Parent, RDW_NOCHILDREN, FALSE);
                }
                IntInvalidateWindows(Window, DirtyRgn, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
             }
             else if (RgnType != ERROR && RgnType == NULLREGION) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
             {
                if ( !PosChanged &&
                     !(WinPos.flags & SWP_DEFERERASE) &&
                      (WinPos.flags & SWP_FRAMECHANGED) )
                {
                    PWND pwnd = Window;
                    PWND Parent = Window->spwndParent;
 
                    if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
                    {
                        TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
                        pwnd = Parent ? Parent : pwnd;
                    }
 
                    if ( !(pwnd->style & WS_CHILD) )
                    {
                        /*
                         * Check if we have these specific windows style bits set/reset.
                         * FIXME: There may be other combinations of styles that need this handling as well.
                         * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
                         */
                        if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
                        {
                            IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
                        }
                        else  // Use region handling
                        {
                            HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
                            PREGION DcRgnObj = REGION_LockRgn(DcRgn);
                            TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
                            IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
                            REGION_UnlockRgn(DcRgnObj);
                            ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
                            GreDeleteObject(DcRgn);
                        }
                    }
                }
             }
             REGION_Delete(DirtyRgn);
         }
      }
 
      /* Expose what was covered before but not covered anymore */
      if (VisBefore != NULL)
      {
         PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
         if (ExposedRgn)
         {
             RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
             REGION_bOffsetRgn(ExposedRgn,
                               OldWindowRect.left - NewWindowRect.left,
                               OldWindowRect.top  - NewWindowRect.top);
 
             if (VisAfter != NULL)
                RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
 
             if (RgnType != ERROR && RgnType != NULLREGION)
             {
                co_VIS_WindowLayoutChanged(Window, ExposedRgn);
             }
             REGION_Delete(ExposedRgn);
         }
      }
   }
 
   if (!(WinPos.flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
   {
      if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
      {
         co_IntSendMessageNoWait(WinPos.hwnd, WM_CHILDACTIVATE, 0, 0);
      }
      else
      {
         //ERR("SetWindowPos Set FG Window!\n");
         if ( pti->MessageQueue->spwndActive != Window ||
              pti->MessageQueue != gpqForeground )
         {
            //ERR("WPSWP : set active window\n");
            if (!(Window->state & WNDS_BEINGACTIVATED)) // Inside SAW?
            {
               co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
            }
         }
      }
   }
 
   if ( !PosChanged &&
         (WinPos.flags & SWP_FRAMECHANGED) &&
        !(WinPos.flags & SWP_DEFERERASE) &&    // Prevent sending WM_SYNCPAINT message. 
         VisAfter )
   {
       PWND Parent = Window->spwndParent;
       if ( !(Window->style & WS_CHILD) && (Parent) && (Parent->style & WS_CLIPCHILDREN))
       {
           TRACE("SWP_FRAMECHANGED Parent %p WS_CLIPCHILDREN %p\n",Parent,Window);
           UserSyncAndPaintWindows(Parent, RDW_CLIPCHILDREN); // NC should redraw here, see NC HACK fix.
       }
   }
 
   // Fix wine msg test_SetFocus, prevents sending WM_WINDOWPOSCHANGED.
   if ( VisBefore == NULL &&
        VisBeforeJustClient == NULL &&
       !(Window->ExStyle & WS_EX_TOPMOST) &&
        (WinPos.flags & SWP_AGG_STATUSFLAGS) == (SWP_AGG_NOPOSCHANGE & ~SWP_NOZORDER))
   {
      TRACE("No drawing, set no Z order and no redraw!\n");
      WinPos.flags |= SWP_NOZORDER|SWP_NOREDRAW;
   }
 
   if (VisBefore != NULL)
   {
      REGION_Delete(VisBefore);
      VisBefore = NULL;
   }
   if (VisBeforeJustClient != NULL)
   {
      REGION_Delete(VisBeforeJustClient);
      VisBeforeJustClient = NULL;
   }
   if (VisAfter != NULL)
   {
      REGION_Delete(VisAfter);
      VisAfter = NULL;
   }
   if (CopyRgn != NULL)
   {
      REGION_Delete(CopyRgn);
      CopyRgn = NULL;
   }
 
   if(!(flags & SWP_DEFERERASE))
   {
       /* erase parent when hiding or resizing child */
       if ((flags & SWP_HIDEWINDOW) ||
         (!(flags & SWP_SHOWWINDOW) &&
          (WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOGEOMETRYCHANGE))
       {
           PWND Parent = Window->spwndParent;
           if (!Parent || UserIsDesktopWindow(Parent)) Parent = Window;
           UserSyncAndPaintWindows( Parent, RDW_ERASENOW);
       }
 
       /* Give newly shown windows a chance to redraw */
       if(((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
                && !(flags & SWP_AGG_NOCLIENTCHANGE) && (flags & SWP_SHOWWINDOW))
       {
           UserSyncAndPaintWindows( Window, RDW_ERASENOW);
       }
   }
 
   /* And last, send the WM_WINDOWPOSCHANGED message */
 
   TRACE("\tstatus hwnd %p flags = %04x\n", Window ? UserHMGetHandle(Window) : NULL, WinPos.flags & SWP_AGG_STATUSFLAGS);
 
   if (((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
            && !((flags & SWP_AGG_NOCLIENTCHANGE) && (flags & SWP_SHOWWINDOW)))
   {
      /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
         and always contains final window position.
       */
      WinPos.x = NewWindowRect.left;
      WinPos.y = NewWindowRect.top;
      WinPos.cx = NewWindowRect.right - NewWindowRect.left;
      WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
      TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
      co_IntSendMessageNoWait(WinPos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM) &WinPos);
   }
 
   if ( WinPos.flags & SWP_FRAMECHANGED  || WinPos.flags & SWP_STATECHANGED ||
      !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
   {
      PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
      if (pWnd)
         IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
   }
 
   /* Send WM_IME_SYSTEM:IMS_UPDATEIMEUI to the IME windows if necessary */
   if ((WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE)) != (SWP_NOMOVE | SWP_NOSIZE))
   {
      if (IS_IMM_MODE())
          IntImeWindowPosChanged();
   }
 
   if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
   {
      /* Generate mouse move message */
      MSG msg;
      msg.message = WM_MOUSEMOVE;
      msg.wParam = UserGetMouseButtonsState();
      msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
      msg.pt = gpsi->ptCursor;
      co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
   }
 
   return TRUE;
}

Referenced by co_IntSendActivateMessages(), co_IntSetForegroundMessageQueue(), co_IntSetParent(), co_IntShowDesktop(), co_IntSnapWindow(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserShowScrollBar(), co_WinPosArrangeIconicWindows(), co_WinPosShowWindow(), DefWndDoSizeMove(), DefWndHandleSetCursor(), DesktopWindowProc(), handle_internal_message(), IntActivateWindow(), IntEndDeferWindowPosEx(), IntSetWindowPlacement(), IntUpdateLayeredWindowI(), MENU_ShowPopup(), NC_HandleNCLButtonDblClk(), NtUserCallHwndLock(), NtUserCallTwoParam(), NtUserSetMenu(), NtUserSetShellWindowEx(), NtUserSetWindowPos(), NtUserSetWindowRgn(), SpiNotifyNCMetricsChanged(), and WinPosDoOwnedPopups().

co_WinPosShowWindow()

BOOLEAN FASTCALL co_WinPosShowWindow	(	PWND	Window,
		INT	Cmd
	)

Definition at line 2635 of file winpos.c.

{
   BOOLEAN WasVisible;
   UINT Swp = 0, EventMsg = 0;
   RECTL NewPos = {0, 0, 0, 0};
   BOOLEAN ShowFlag;
   LONG style;
   PWND Parent;
   PTHREADINFO pti;
   //HRGN VisibleRgn;
   BOOL ShowOwned = FALSE;
   BOOL FirstTime = FALSE;
   ASSERT_REFS_CO(Wnd);
   //KeRosDumpStackFrames(NULL, 20);
   pti = PsGetCurrentThreadWin32Thread();
   WasVisible = (Wnd->style & WS_VISIBLE) != 0;
   style = Wnd->style;
 
   TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
         UserHMGetHandle(Wnd), Cmd, pti->ppi->usi.wShowWindow);
 
   if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
   {
      if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
      {
         if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
         {
            if (Wnd->spwndOwner == NULL)
            {
               if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
               {
                    Cmd = SW_SHOWDEFAULT;
               }
               FirstTime = TRUE;
               TRACE("co_WPSW FT 1\n");
            }
         }
      }
   }
 
   if ( Cmd == SW_SHOWDEFAULT )
   {
      if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
      {
         Cmd = pti->ppi->usi.wShowWindow;
         FirstTime = TRUE;
         TRACE("co_WPSW FT 2\n");
      }
   }
 
   if (FirstTime)
   {
      pti->ppi->usi.dwFlags &= ~(STARTF_USEPOSITION|STARTF_USESIZE|STARTF_USESHOWWINDOW);
   }
 
   switch (Cmd)
   {
      case SW_HIDE:
         {
            if (!WasVisible)
            {
               //ERR("co_WinPosShowWindow Exit Bad\n");
               return FALSE;
            }
            Swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE;
            if (Wnd != pti->MessageQueue->spwndActive)
               Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
            break;
         }
 
      case SW_FORCEMINIMIZE:
         IntForceMinimizeWindow(Wnd);
         return WasVisible;
 
      case SW_SHOWMINNOACTIVE:
         Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
         /* Fall through. */
      case SW_SHOWMINIMIZED:
      case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
         Swp |= SWP_SHOWWINDOW;
         {
            Swp |= SWP_NOACTIVATE;
            if (!(style & WS_MINIMIZE))
            {
               IntShowOwnedPopups(Wnd, FALSE );
               // Fix wine Win test_SetFocus todo #1 & #2,
               if (Cmd == SW_SHOWMINIMIZED)
               {
                  //ERR("co_WinPosShowWindow Set focus 1\n");
                  if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
                     co_UserSetFocus(Wnd->spwndParent);
                  else
                     co_UserSetFocus(0);
               }
 
               Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
 
               EventMsg = EVENT_SYSTEM_MINIMIZESTART;
            }
            else
            {
               if (WasVisible)
               {
                  //ERR("co_WinPosShowWindow Exit Good\n");
                  return TRUE;
               }
               Swp |= SWP_NOSIZE | SWP_NOMOVE;
            }
            break;
         }
 
      case SW_SHOWMAXIMIZED:
         {
            Swp |= SWP_SHOWWINDOW;
            if (!(style & WS_MAXIMIZE))
            {
               ShowOwned = TRUE;
 
               Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
 
               EventMsg = EVENT_SYSTEM_MINIMIZEEND;
            }
            else
            {
               if (WasVisible)
               {
                  //ERR("co_WinPosShowWindow Exit Good 1\n");
                  return TRUE;
               }
               Swp |= SWP_NOSIZE | SWP_NOMOVE;
            }
            break;
         }
 
      case SW_SHOWNA:
         Swp |= SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
         if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
         break;
      case SW_SHOW:
         if (WasVisible) return(TRUE); // Nothing to do!
         Swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
         /* Don't activate the topmost window. */
         if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
         break;
 
      case SW_SHOWNOACTIVATE:
         Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
         /* Fall through. */
      case SW_SHOWNORMAL:
      case SW_SHOWDEFAULT:
      case SW_RESTORE:
         if (!WasVisible) Swp |= SWP_SHOWWINDOW;
         if (style & (WS_MINIMIZE | WS_MAXIMIZE))
         {
            Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
            if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
         }
         else
         {
            if (WasVisible)
            {
               //ERR("co_WinPosShowWindow Exit Good 3\n");
               return TRUE;
            }
            Swp |= SWP_NOSIZE | SWP_NOMOVE;
         }
         if ( style & WS_CHILD &&
             !(Wnd->ExStyle & WS_EX_MDICHILD) &&
             !(Swp & SWP_STATECHANGED))
            Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
         break;
 
      default:
         //ERR("co_WinPosShowWindow Exit Good 4\n");
         return FALSE;
   }
 
   ShowFlag = (Cmd != SW_HIDE);
 
   if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
   {
      co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SHOWWINDOW, ShowFlag, 0);
#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
      if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
         co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SETVISIBLE, ShowFlag, 0);
#endif
      if (!VerifyWnd(Wnd)) return WasVisible;
   }
 
   /* We can't activate a child window */
   if ((Wnd->style & WS_CHILD) &&
       !(Wnd->ExStyle & WS_EX_MDICHILD) &&
       Cmd != SW_SHOWNA)
   {
      //ERR("SWP Child No active and ZOrder\n");
      Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
   }
 
#if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
      // Breaks startup and shutdown active window...
   if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
        Wnd->pcls->style & CS_SAVEBITS &&
        ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
   {
      ERR("WinPosShowWindow Set active\n");
      //UserSetActiveWindow(Wnd);
      co_IntSetForegroundWindow(Wnd); // HACK
      Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
   }
#endif
 
   if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
   {
       TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
             (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
             (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
   co_WinPosSetWindowPos( Wnd,
                          0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
                          NewPos.left,
                          NewPos.top,
                          NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
                          NewPos.bottom,// NewPos.bottom - NewPos.top,
                          LOWORD(Swp));
   }
   else
   {
      TRACE("Parent Vis?\n");
      /* if parent is not visible simply toggle WS_VISIBLE and return */
      if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
      else IntSetStyle( Wnd, 0, WS_VISIBLE );
   }
 
   if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
 
   if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
 
   if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
   {
      if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue()  )
      {
          if (UserIsDesktopWindow(Wnd->spwndParent))
          {
              if (!ActivateOtherWindowMin(Wnd))
              {
                co_WinPosActivateOtherWindow(Wnd);
              }
          }
          else
          {
              co_WinPosActivateOtherWindow(Wnd);
          }
      }
 
      /* Revert focus to parent */
      if (Wnd == pti->MessageQueue->spwndFocus)
      {
         Parent = Wnd->spwndParent;
         if (UserIsDesktopWindow(Wnd->spwndParent))
             Parent = 0;
         co_UserSetFocus(Parent);
      }
      // Hide, just return.
      if (Cmd == SW_HIDE) return WasVisible;
   }
 
   /* FIXME: Check for window destruction. */
 
   if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
       !(Wnd->state2 & WNDS2_INDESTROY))
   {
        co_WinPosSendSizeMove(Wnd);
   }
 
   /* if previous state was minimized Windows sets focus to the window */
   if (style & WS_MINIMIZE)
   {
      co_UserSetFocus(Wnd);
      // Fix wine Win test_SetFocus todo #3,
      if (!(style & WS_CHILD)) co_IntSendMessage(UserHMGetHandle(Wnd), WM_ACTIVATE, WA_ACTIVE, 0);
   }
   //ERR("co_WinPosShowWindow EXIT\n");
   return WasVisible;
}

Referenced by co_IntSetParent(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserShowScrollBar(), DefWndHandleSysCommand(), handle_internal_message(), IntDefWindowProc(), IntSetWindowPlacement(), NtUserMinMaximize(), and NtUserShowWindow().

co_WinPosWindowFromPoint()

PWND APIENTRY co_WinPosWindowFromPoint	(	IN PWND	ScopeWin,
		IN POINT *	WinPoint,
		IN OUT USHORT *	HitTest,
		IN BOOL	Ignore
	)

Definition at line 3005 of file winpos.c.

{
   PWND Window;
   POINT Point = *WinPoint;
   USER_REFERENCE_ENTRY Ref;
 
   if( ScopeWin == NULL )
   {
       ScopeWin = UserGetDesktopWindow();
       if(ScopeWin == NULL)
           return NULL;
   }
 
   *HitTest = HTNOWHERE;
 
   ASSERT_REFS_CO(ScopeWin);
   UserRefObjectCo(ScopeWin, &Ref);
 
   Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
 
   UserDerefObjectCo(ScopeWin);
   if (Window)
       ASSERT_REFS_CO(Window);
   ASSERT_REFS_CO(ScopeWin);
 
   return Window;
}

Referenced by co_IntProcessMouseMessage(), and NtUserWindowFromPoint().

IntClientToScreen()

BOOL FASTCALL IntClientToScreen	(	PWND	Wnd,
		LPPOINT	lpPoint
	)

Definition at line 199 of file winpos.c.

{
   if (Wnd && Wnd->fnid != FNID_DESKTOP )
   {
      if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
         lpPoint->x = Wnd->rcClient.right - lpPoint->x;
      else
         lpPoint->x += Wnd->rcClient.left;
      lpPoint->y += Wnd->rcClient.top;
   }
   return TRUE;
}

Referenced by IntDefWindowProc(), NC_GetSysPopupPos(), and WinPosFixupFlags().

IntEqualRect()

FORCEINLINE BOOL IntEqualRect	(	RECTL *	lprc1,
		RECTL *	lprc2
	)

Definition at line 48 of file winpos.h.

{
   if (lprc1 == NULL || lprc2 == NULL)
       return FALSE;
 
   return (lprc1->left  == lprc2->left)  && (lprc1->top    == lprc2->top) &&
          (lprc1->right == lprc2->right) && (lprc1->bottom == lprc2->bottom);
}

Referenced by IntGetNCUpdateRgn(), and NC_DoNCPaint().

IntGetClientOrigin()

BOOL FASTCALL IntGetClientOrigin	(	PWND	Window,
		LPPOINT	Point
	)

Definition at line 71 of file winpos.c.

{
   Window = Window ? Window : UserGetDesktopWindow();
   if (Window == NULL)
   {
      Point->x = Point->y = 0;
      return FALSE;
   }
   Point->x = Window->rcClient.left;
   Point->y = Window->rcClient.top;
 
   return TRUE;
}

Referenced by co_IntFixCaret(), and IntScrollWindowEx().

IntGetWindowRect()

BOOL FASTCALL IntGetWindowRect	(	PWND	Wnd,
		RECTL *	Rect
	)

Definition at line 121 of file winpos.c.

{
   ASSERT( Wnd );
   ASSERT( Rect );
   if (!Wnd) return FALSE;
   if (!UserIsDesktopWindow(Wnd))
   {
       *Rect = Wnd->rcWindow;
   }
   else
   {
       Rect->left = Rect->top = 0;
       Rect->right = Wnd->rcWindow.right;
       Rect->bottom = Wnd->rcWindow.bottom;
/* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
       Rect->right = GetSystemMetrics(SM_CXSCREEN);
       Rect->bottom = GetSystemMetrics(SM_CYSCREEN);
*/   }
   return TRUE;
}

Referenced by DefWndScreenshot(), IntGetNCUpdateRgn(), IntIsWindowFullscreen(), MENU_FindItemByCoords(), MENU_ShowSubPopup(), NC_DoNCPaint(), NC_GetSysPopupPos(), UserDrawCaptionBar(), and UserDrawCaptionButtonWnd().

IntGetWindowSnapEdge()

UINT FASTCALL IntGetWindowSnapEdge

(

PWND

Wnd

)

Definition at line 3944 of file winpos.c.

{
    if (Wnd->ExStyle2 & WS_EX2_VERTICALLYMAXIMIZEDLEFT) return HTLEFT;
    if (Wnd->ExStyle2 & WS_EX2_VERTICALLYMAXIMIZEDRIGHT) return HTRIGHT;
    return HTNOWHERE;
}

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and IntDefWindowProc().

IntIsSnapAllowedForWindow()

FORCEINLINE BOOLEAN IntIsSnapAllowedForWindow

(

PWND

Wnd

)

Definition at line 101 of file winpos.h.

{
    /* We want to forbid snapping operations on the TaskBar and on child windows.
     * We use a heuristic for detecting the TaskBar by its typical Style & ExStyle. */
    const UINT style = Wnd->style;
    const UINT tbws = WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    const UINT tbes = WS_EX_TOOLWINDOW;
    BOOLEAN istb = (style & tbws) == tbws && (Wnd->ExStyle & (tbes | WS_EX_APPWINDOW)) == tbes;
    BOOLEAN thickframe = (style & WS_THICKFRAME) && (style & (WS_DLGFRAME | WS_BORDER)) != WS_DLGFRAME;
    return thickframe && !(style & WS_CHILD) && !istb;
}

Referenced by DefWndDoSizeMove(), and IntDefWindowProc().

IntIsWindowSnapped()

FORCEINLINE BOOLEAN IntIsWindowSnapped

(

PWND

Wnd

)

Definition at line 95 of file winpos.h.

{
    return (Wnd->ExStyle2 & (WS_EX2_VERTICALLYMAXIMIZEDLEFT | WS_EX2_VERTICALLYMAXIMIZEDRIGHT)) != 0;
}

Referenced by co_IntSnapWindow(), DefWndDoSizeMove(), and WinPosInitInternalPos().

IntPtInWindow()

FORCEINLINE BOOL IntPtInWindow	(	PWND	pwnd,
		INT	x,
		INT	y
	)

Definition at line 30 of file winpos.h.

{
    if(!RECTL_bPointInRect(&pwnd->rcWindow, x, y))
    {
        return FALSE;
    }
 
    if(!pwnd->hrgnClip || pwnd->style & WS_MINIMIZE)
    {
        return TRUE;
    }
 
    return NtGdiPtInRegion(pwnd->hrgnClip, 
                           x - pwnd->rcWindow.left,
                           y - pwnd->rcWindow.top);
}

Referenced by co_WinPosSearchChildren(), co_WinPosSetWindowPos(), IntChildWindowFromPointEx(), IntRealChildWindowFromPoint(), and IntTopLevelWindowFromPoint().

IntRealChildWindowFromPoint()

PWND FASTCALL IntRealChildWindowFromPoint	(	PWND	Parent,
		LONG	x,
		LONG	y
	)

Definition at line 3038 of file winpos.c.

{
   POINTL Pt;
   HWND *List, *phWnd;
   PWND pwndHit = NULL;
 
   Pt.x = x;
   Pt.y = y;
 
   if (!UserIsDesktopWindow(Parent))
   {
      Pt.x += Parent->rcClient.left;
      Pt.y += Parent->rcClient.top;
   }
 
   if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
 
   if ((List = IntWinListChildren(Parent)))
   {
      for (phWnd = List; *phWnd; phWnd++)
      {
         PWND Child;
         if ((Child = ValidateHwndNoErr(*phWnd)))
         {
            if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
            {
               if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
                   (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
               {
                  ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
                  return Child;
               }
               pwndHit = Child;
            }
         }
      }
      ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
   }
   return pwndHit ? pwndHit : Parent;
}

Referenced by NtUserRealChildWindowFromPoint().

IntScreenToClient()

BOOL FASTCALL IntScreenToClient	(	PWND	Wnd,
		LPPOINT	lpPoint
	)

Definition at line 213 of file winpos.c.

{
    if (Wnd && Wnd->fnid != FNID_DESKTOP )
    {
       if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
          lpPoint->x = Wnd->rcClient.right - lpPoint->x;
       else
          lpPoint->x -= Wnd->rcClient.left;
       lpPoint->y -= Wnd->rcClient.top;
    }
    return TRUE;
}

Referenced by co_IntSetParent(), IntDefWindowProc(), and MENU_TrackMouseMenuBar().

IntSetSnapEdge()

VOID FASTCALL IntSetSnapEdge	(	PWND	Wnd,
		UINT	Edge
	)

Definition at line 4029 of file winpos.c.

{
    UINT styleMask = WS_EX2_VERTICALLYMAXIMIZEDLEFT | WS_EX2_VERTICALLYMAXIMIZEDRIGHT;
    UINT style = 0;
    switch (Edge)
    {
    case HTNOWHERE:
        style = 0;
        break;
    case HTTOP: /* Maximize throws away the snap */
        style = 0;
        break;
    case HTLEFT:
        style = WS_EX2_VERTICALLYMAXIMIZEDLEFT;
        break;
    case HTRIGHT:
        style = WS_EX2_VERTICALLYMAXIMIZEDRIGHT;
        break;
    default:
        ERR("Unexpected snap edge %#x\n", Edge);
    }
    Wnd->ExStyle2 = (Wnd->ExStyle2 & ~styleMask) | style;
}

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), IntDefWindowProc(), and IntSetSnapInfo().

IntSetSnapInfo()

VOID FASTCALL IntSetSnapInfo	(	PWND	Wnd,
		UINT	Edge,
		IN const RECT *Pos	OPTIONAL
	)

Definition at line 4054 of file winpos.c.

{
    RECT r;
    IntSetSnapEdge(Wnd, Edge);
    if (Edge == HTNOWHERE)
    {
        RECTL_vSetEmptyRect(&r);
        Pos = (Wnd->style & WS_MINIMIZE) ? NULL : &r;
    }
    if (Pos)
    {
        Wnd->InternalPos.NormalRect = *Pos;
    }
}

Referenced by co_IntSnapWindow(), DefWndDoSizeMove(), and IntDefWindowProc().

IsSnapEnabled()

FORCEINLINE BOOL IsSnapEnabled

(

VOID

)

Definition at line 83 of file winpos.h.

{
    return g_bWindowSnapEnabled;
}

UserGetWindowBorders()

VOID UserGetWindowBorders	(	DWORD	Style,
		DWORD	ExStyle,
		SIZE *	Size,
		BOOL	WithClient
	)

Definition at line 894 of file winpos.c.

{
   DWORD Border = 0;
 
   if (UserHasWindowEdge(Style, ExStyle))
      Border += 2;
   else if ((ExStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE)
      Border += 1; /* for the outer frame always present */
   if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
      Border += 2;
   if (Style & WS_CAPTION || ExStyle & WS_EX_DLGMODALFRAME)
      Border ++; /* The other border */
   Size->cx = Size->cy = Border;
   if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
   {
      Size->cx += UserGetSystemMetrics(SM_CXFRAME) - UserGetSystemMetrics(SM_CXDLGFRAME);
      Size->cy += UserGetSystemMetrics(SM_CYFRAME) - UserGetSystemMetrics(SM_CYDLGFRAME);
   }
   Size->cx *= UserGetSystemMetrics(SM_CXBORDER);
   Size->cy *= UserGetSystemMetrics(SM_CYBORDER);
}

UserHasWindowEdge()

BOOL UserHasWindowEdge	(	DWORD	Style,
		DWORD	ExStyle
	)

Definition at line 850 of file winpos.c.

{
   if (Style & WS_MINIMIZE)
      return TRUE;
   if (ExStyle & WS_EX_DLGMODALFRAME)
      return TRUE;
   if (ExStyle & WS_EX_STATICEDGE)
      return FALSE;
   if (Style & WS_THICKFRAME)
      return TRUE;
   Style &= WS_CAPTION;
   if (Style == WS_DLGFRAME || Style == WS_CAPTION)
      return TRUE;
   return FALSE;
}

Referenced by UserGetWindowBorders().