* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Windows
- * FILE: subsystems/win32/win32k/ntuser/window.c
+ * FILE: win32ss/user/ntuser/winpos.c
* PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
*/
#define SWP_EX_PAINTSELF 0x0002
#define SWP_AGG_NOGEOMETRYCHANGE \
- (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
+ (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
#define SWP_AGG_NOPOSCHANGE \
- (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER)
+ (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
#define SWP_AGG_STATUSFLAGS \
(SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
+#define SWP_AGG_NOCLIENTCHANGE \
+ (SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
#define EMPTYPOINT(pt) ((pt).x == -1 && (pt).y == -1)
#define PLACE_MIN 0x0001
#define PLACE_MAX 0x0002
#define PLACE_RECT 0x0004
-VOID FASTCALL IntLinkWindow(PWND Wnd,PWND WndInsertAfter);
-
/* FUNCTIONS *****************************************************************/
+#if DBG
+/***********************************************************************
+ * dump_winpos_flags
+ */
+static void dump_winpos_flags(UINT flags)
+{
+ static const DWORD dumped_flags = (SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW |
+ SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_SHOWWINDOW |
+ SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOOWNERZORDER |
+ SWP_NOSENDCHANGING | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS |
+ SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_STATECHANGED);
+ TRACE("flags:");
+ if(flags & SWP_NOSIZE) TRACE(" SWP_NOSIZE");
+ if(flags & SWP_NOMOVE) TRACE(" SWP_NOMOVE");
+ if(flags & SWP_NOZORDER) TRACE(" SWP_NOZORDER");
+ if(flags & SWP_NOREDRAW) TRACE(" SWP_NOREDRAW");
+ if(flags & SWP_NOACTIVATE) TRACE(" SWP_NOACTIVATE");
+ if(flags & SWP_FRAMECHANGED) TRACE(" SWP_FRAMECHANGED");
+ if(flags & SWP_SHOWWINDOW) TRACE(" SWP_SHOWWINDOW");
+ if(flags & SWP_HIDEWINDOW) TRACE(" SWP_HIDEWINDOW");
+ if(flags & SWP_NOCOPYBITS) TRACE(" SWP_NOCOPYBITS");
+ if(flags & SWP_NOOWNERZORDER) TRACE(" SWP_NOOWNERZORDER");
+ if(flags & SWP_NOSENDCHANGING) TRACE(" SWP_NOSENDCHANGING");
+ if(flags & SWP_DEFERERASE) TRACE(" SWP_DEFERERASE");
+ if(flags & SWP_ASYNCWINDOWPOS) TRACE(" SWP_ASYNCWINDOWPOS");
+ if(flags & SWP_NOCLIENTSIZE) TRACE(" SWP_NOCLIENTSIZE");
+ if(flags & SWP_NOCLIENTMOVE) TRACE(" SWP_NOCLIENTMOVE");
+ if(flags & SWP_STATECHANGED) TRACE(" SWP_STATECHANGED");
+
+ if(flags & ~dumped_flags) TRACE(" %08x", flags & ~dumped_flags);
+ TRACE("\n");
+}
+#endif
+
BOOL FASTCALL
IntGetClientOrigin(PWND Window OPTIONAL, LPPOINT Point)
{
Rect->bottom = UserGetSystemMetrics(SM_CYMINIMIZED);
return;
}
- if ( Wnd != UserGetDesktopWindow()) // Wnd->fnid != FNID_DESKTOP )
+ if (!UserIsDesktopWindow(Wnd))
{
*Rect = Wnd->rcClient;
RECTL_vOffsetRect(Rect, -Wnd->rcClient.left, -Wnd->rcClient.top);
}
}
+BOOL FASTCALL
+IntGetWindowRect(PWND Wnd, RECTL *Rect)
+{
+ 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;
+}
+
+
INT FASTCALL
IntMapWindowPoints(PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
{
Delta.x = Delta.y = 0;
mirror_from = mirror_to = FALSE;
- if (FromWnd && FromWnd != UserGetDesktopWindow()) // FromWnd->fnid != FNID_DESKTOP)
+ if (FromWnd && !UserIsDesktopWindow(FromWnd))
{
if (FromWnd->ExStyle & WS_EX_LAYOUTRTL)
{
Delta.y = FromWnd->rcClient.top;
}
- if (ToWnd && ToWnd != UserGetDesktopWindow()) // ToWnd->fnid != FNID_DESKTOP)
+ if (ToWnd && !UserIsDesktopWindow(ToWnd))
{
if (ToWnd->ExStyle & WS_EX_LAYOUTRTL)
{
return NULL;
}
+VOID
+SelectWindowRgn(PWND Window, HRGN hRgnClip)
+{
+ if (Window->hrgnClip)
+ {
+ /* Delete no longer needed region handle */
+ IntGdiSetRegionOwner(Window->hrgnClip, GDI_OBJ_HMGR_POWNED);
+ GreDeleteObject(Window->hrgnClip);
+ Window->hrgnClip = NULL;
+ }
+
+ if (hRgnClip > HRGN_WINDOW)
+ {
+ /*if (!UserIsDesktopWindow(Window))
+ {
+ NtGdiOffsetRgn(hRgnClip, Window->rcWindow.left, Window->rcWindow.top);
+ }*/
+ /* Set public ownership */
+ IntGdiSetRegionOwner(hRgnClip, GDI_OBJ_HMGR_PUBLIC);
+
+ Window->hrgnClip = hRgnClip;
+ }
+}
+
//
-// This helps with bug 6751 forcing modal dialog active when another app is minimized or closed.
+// This helps with CORE-6129 forcing modal dialog active when another app is minimized or closed.
//
BOOL FASTCALL ActivateOtherWindowMin(PWND Wnd)
{
USER_REFERENCE_ENTRY Ref;
PTHREADINFO pti = gptiCurrent;
- //ERR("AOWM 1\n");
+ //ERR("AOWM 1 %p\n",Wnd->head.h);
ActivePrev = (pti->MessageQueue->spwndActivePrev != NULL);
FindTopWnd = TRUE;
//ERR("ActivateOtherWindowMin Set FG 1\n");
co_IntSetForegroundWindow(pWndSetActive);
UserDerefObjectCo(pWndSetActive);
- //ERR("AOWM 2 Exit Good\n");
+ //ERR("AOWM 2 Exit Good %p\n",pWndSetActive->head.h);
return TRUE;
}
if (!pWndTemp ) pWndTemp = pWndSetActive;
//ERR("ActivateOtherWindowMin Set FG 2\n");
co_IntSetForegroundWindow(pWndSetActive);
UserDerefObjectCo(pWndSetActive);
- //ERR("AOWM 3 Exit Good\n");
+ //ERR("AOWM 3 Exit Good %p\n",pWndSetActive->head.h);
return TRUE;
}
//ERR("AOWM 4 Bad\n");
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;
}
WndTo = Wnd;
for (;;)
{
- if (!(WndTo = WndTo->spwndNext)) break;
- if (can_activate_window( WndTo )) break;
+ if (!(WndTo = WndTo->spwndNext)) break;
+ if (can_activate_window( WndTo )) goto done;
}
-done:
-
- if (WndTo) UserRefObjectCo(WndTo, &Ref);
-
- if (!gpqForeground || Wnd == gpqForeground->spwndActive)
- {
- /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
- //ERR("WinPosActivateOtherWindow Set FG 0x%p\n",WndTo);
- if (co_IntSetForegroundWindow(WndTo))
- {
- if (WndTo) UserDerefObjectCo(WndTo);
- return;
- }
- }
- //ERR("WinPosActivateOtherWindow Set Active 0x%p\n",WndTo);
- if (!co_IntSetActiveWindow(WndTo,FALSE,TRUE,FALSE)) /* Ok for WndTo to be NULL here */
+ /*
+ Fixes wine win.c:test_SetParent last ShowWindow test after popup dies.
+ Check for previous active window to bring to top.
+ */
+ if (Wnd)
{
- co_IntSetActiveWindow(NULL,FALSE,TRUE,FALSE);
+ WndTo = Wnd->head.pti->MessageQueue->spwndActivePrev;
+ if (can_activate_window( WndTo )) goto done;
}
- if (WndTo) UserDerefObjectCo(WndTo);
-}
-
-UINT
-FASTCALL
-co_WinPosArrangeIconicWindows(PWND parent)
-{
- RECTL rectParent;
- INT i, x, y, xspacing, yspacing, sx, sy;
- HWND *List = IntWinListChildren(parent);
- ASSERT_REFS_CO(parent);
-
- /* Check if we found any children */
- if(List == NULL)
+ // Find any window to bring to top. Works Okay for wine since it does not see X11 windows.
+ WndTo = UserGetDesktopWindow();
+ WndTo = WndTo->spwndChild;
+ if ( WndTo == NULL )
{
- return 0;
+ //ERR("WinPosActivateOtherWindow No window!\n");
+ return;
}
-
- IntGetClientRect( parent, &rectParent );
- // FIXME: Support gspv.mm.iArrange.
- x = rectParent.left;
- y = rectParent.bottom;
-
- xspacing = (UserGetSystemMetrics(SM_CXMINSPACING)/2)+UserGetSystemMetrics(SM_CXBORDER);
- yspacing = (UserGetSystemMetrics(SM_CYMINSPACING)/2)+UserGetSystemMetrics(SM_CYBORDER);
-
- //ERR("X:%d Y:%d XS:%d YS:%d\n",x,y,xspacing,yspacing);
-
- for(i = 0; List[i]; i++)
+ for (;;)
{
- PWND Child;
-
- if (!(Child = ValidateHwndNoErr(List[i])))
- continue;
-
- if((Child->style & WS_MINIMIZE) != 0 )
+ if (WndTo == Wnd)
{
- USER_REFERENCE_ENTRY Ref;
- UserRefObjectCo(Child, &Ref);
-
- sx = x + UserGetSystemMetrics(SM_CXBORDER);
- sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
-
- co_WinPosSetWindowPos( Child, 0, sx, sy, 0, 0,
- SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
-
- Child->InternalPos.IconPos.x = sx;
- Child->InternalPos.IconPos.y = sy;
- Child->InternalPos.flags |= WPF_MININIT;
- Child->InternalPos.flags &= ~WPF_SETMINPOSITION;
-
- UserDerefObjectCo(Child);
-
- if (x <= (rectParent.right - UserGetSystemMetrics(SM_CXMINSPACING)))
- x += xspacing;
- else
- {
- x = rectParent.left;
- y -= yspacing;
- }
- //ERR("X:%d Y:%d\n",x,y);
+ WndTo = NULL;
+ break;
}
+ if (can_activate_window( WndTo )) goto done;
+ if (!(WndTo = WndTo->spwndNext)) break;
}
- ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
- return yspacing;
-}
-static VOID FASTCALL
-WinPosFindIconPos(PWND Window, POINT *Pos)
-{
- RECT rectParent;
- PWND pwndChild, pwndParent;
- int x, y, xspacing, yspacing;
+done:
+ if (WndTo) UserRefObjectCo(WndTo, &Ref);
- pwndParent = Window->spwndParent;
- if (pwndParent == UserGetDesktopWindow())
+ if (gpqForeground && (!gpqForeground->spwndActive || Wnd == gpqForeground->spwndActive))
{
- //ERR("Parent is Desktop, Min off screen!\n");
- /* ReactOS doesn't support iconic minimize to desktop */
- Pos->x = Pos->y = -32000;
- Window->InternalPos.flags |= WPF_MININIT;
- Window->InternalPos.IconPos.x = Pos->x;
- Window->InternalPos.IconPos.y = Pos->y;
- return;
+ /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
+ //ERR("WinPosActivateOtherWindow Set FG 0x%p hWnd %p\n",WndTo, WndTo ? WndTo->head.h : 0);
+ if (co_IntSetForegroundWindow(WndTo))
+ {
+ if (WndTo) UserDerefObjectCo(WndTo);
+ return;
+ }
}
-
- IntGetClientRect( pwndParent, &rectParent );
- // FIXME: Support gspv.mm.iArrange.
- x = rectParent.left;
- y = rectParent.bottom;
-
- xspacing = (UserGetSystemMetrics(SM_CXMINSPACING)/2)+UserGetSystemMetrics(SM_CXBORDER);
- yspacing = (UserGetSystemMetrics(SM_CYMINSPACING)/2)+UserGetSystemMetrics(SM_CYBORDER);
-
- //ERR("X:%d Y:%d XS:%d YS:%d\n",Pos->x,Pos->y,xspacing,yspacing);
-
- // Set to default position when minimized.
- Pos->x = x + UserGetSystemMetrics(SM_CXBORDER);
- Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
-
- for (pwndChild = pwndParent->spwndChild; pwndChild; pwndChild = pwndChild->spwndNext)
+ //ERR("WinPosActivateOtherWindow Set Active 0x%p\n",WndTo);
+ if (!UserSetActiveWindow(WndTo)) /* Ok for WndTo to be NULL here */
{
- if (pwndChild == Window) continue;
-
- if (pwndChild->style & WS_VISIBLE)
- {
- //ERR("Loop!\n");
- continue;
- }
- //ERR("Pos Child X %d Y %d!\n", pwndChild->InternalPos.IconPos.x, pwndChild->InternalPos.IconPos.y);
- if ( pwndChild->InternalPos.IconPos.x == Pos->x &&
- pwndChild->InternalPos.IconPos.y == Pos->y )
- {
- if (x <= rectParent.right - UserGetSystemMetrics(SM_CXMINSPACING))
- x += xspacing;
- else
- {
- x = rectParent.left;
- y -= yspacing;
- }
- Pos->x = x + UserGetSystemMetrics(SM_CXBORDER);
- Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
- }
+ //ERR("WPAOW SA 1\n");
+ UserSetActiveWindow(NULL);
}
- Window->InternalPos.IconPos.x = Pos->x;
- Window->InternalPos.IconPos.y = Pos->y;
- Window->InternalPos.flags |= WPF_MININIT;
- //ERR("Position is set! X:%d Y:%d\n",Pos->x,Pos->y);
- return;
+ if (WndTo) UserDerefObjectCo(WndTo);
}
VOID FASTCALL
POINT Size;
RECTL Rect = *RestoreRect;
- if (Wnd->spwndParent != UserGetDesktopWindow())
+ if (Wnd->spwndParent && !UserIsDesktopWindow(Wnd->spwndParent))
{
RECTL_vOffsetRect(&Rect,
-Wnd->spwndParent->rcClient.left,
return TRUE;
}
-UINT FASTCALL
-co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT* NewPos)
+UINT
+FASTCALL
+co_WinPosArrangeIconicWindows(PWND parent)
{
- POINT Size;
- WINDOWPLACEMENT wpl;
- LONG old_style;
- UINT SwpFlags = 0;
+ RECTL rectParent;
+ PWND Child;
+ INT x, y, xspacing, yspacing, sx, sy;
- ASSERT_REFS_CO(Wnd);
+ ASSERT_REFS_CO(parent);
- wpl.length = sizeof(wpl);
- IntGetWindowPlacement( Wnd, &wpl );
+ IntGetClientRect( parent, &rectParent );
+ // FIXME: Support Minimize Metrics gspv.mm.iArrange.
+ // Default: ARW_BOTTOMLEFT
+ x = rectParent.left;
+ y = rectParent.bottom;
- if (co_HOOK_CallHooks( WH_CBT, HCBT_MINMAX, (WPARAM)Wnd->head.h, ShowFlag))
+ xspacing = UserGetSystemMetrics(SM_CXMINIMIZED);
+ yspacing = UserGetSystemMetrics(SM_CYMINIMIZED);
+
+ Child = parent->spwndChild;
+ while(Child)
{
- ERR("WinPosMinMaximize WH_CBT Call Hook return!\n");
- return SWP_NOSIZE | SWP_NOMOVE;
- }
- if (Wnd->style & WS_MINIMIZE)
+ if((Child->style & WS_MINIMIZE) != 0 )
{
- switch (ShowFlag)
- {
- case SW_SHOWMINNOACTIVE:
- case SW_SHOWMINIMIZED:
- case SW_FORCEMINIMIZE:
- case SW_MINIMIZE:
- return SWP_NOSIZE | SWP_NOMOVE;
- }
- if (!co_IntSendMessageNoWait(Wnd->head.h, WM_QUERYOPEN, 0, 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
{
- return(SWP_NOSIZE | SWP_NOMOVE);
+ x = rectParent.left;
+ y -= yspacing;
}
- SwpFlags |= SWP_NOCOPYBITS;
}
- switch (ShowFlag)
- {
- case SW_SHOWMINNOACTIVE:
- case SW_SHOWMINIMIZED:
- case SW_FORCEMINIMIZE:
- case SW_MINIMIZE:
- {
- //ERR("MinMaximize Minimize\n");
- if (Wnd->style & WS_MAXIMIZE)
- {
- Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
- }
- else
- {
- Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
- }
-
- old_style = IntSetStyle( Wnd, WS_MINIMIZE, WS_MAXIMIZE );
+ Child = Child->spwndNext;
+ }
+ return yspacing;
+}
- co_UserRedrawWindow(Wnd, NULL, 0, RDW_VALIDATE | RDW_NOERASE |
- RDW_NOINTERNALPAINT);
+static VOID FASTCALL
+WinPosFindIconPos(PWND Window, POINT *Pos)
+{
+ RECT rectParent;
+ PWND pwndChild, pwndParent;
+ int x, y, xspacing, yspacing;
- if (!(Wnd->InternalPos.flags & WPF_SETMINPOSITION))
- Wnd->InternalPos.flags &= ~WPF_MININIT;
+ pwndParent = Window->spwndParent;
+ if (UserIsDesktopWindow(pwndParent))
+ {
+ ERR("FIXME: Parent is Desktop, Min off screen!\n");
+ /* FIXME: ReactOS doesn't support iconic minimize to desktop */
+ Pos->x = Pos->y = -32000;
+ Window->InternalPos.flags |= WPF_MININIT;
+ Window->InternalPos.IconPos.x = Pos->x;
+ Window->InternalPos.IconPos.y = Pos->y;
+ return;
+ }
- WinPosFindIconPos(Wnd, &wpl.ptMinPosition);
+ IntGetClientRect( pwndParent, &rectParent );
+ // FIXME: Support Minimize Metrics gspv.mm.iArrange.
+ // Default: ARW_BOTTOMLEFT
+ x = rectParent.left;
+ y = rectParent.bottom;
- if (!(old_style & WS_MINIMIZE)) SwpFlags |= SWP_STATECHANGED;
+ xspacing = UserGetSystemMetrics(SM_CXMINIMIZED);
+ yspacing = UserGetSystemMetrics(SM_CYMINIMIZED);
- /*ERR("Minimize: %d,%d %dx%d\n",
- wpl.ptMinPosition.x, wpl.ptMinPosition.y, UserGetSystemMetrics(SM_CXMINIMIZED),
- UserGetSystemMetrics(SM_CYMINIMIZED));
- */
- RECTL_vSetRect(NewPos, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
-// wpl.ptMinPosition.x + UserGetSystemMetrics(SM_CXMINIMIZED),
-// wpl.ptMinPosition.y + UserGetSystemMetrics(SM_CYMINIMIZED));
- UserGetSystemMetrics(SM_CXMINIMIZED),
- UserGetSystemMetrics(SM_CYMINIMIZED));
- SwpFlags |= SWP_NOCOPYBITS;
- break;
- }
+ // Set to default position when minimized.
+ Pos->x = x + UserGetSystemMetrics(SM_CXBORDER);
+ Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
- case SW_MAXIMIZE:
- {
- //ERR("MinMaximize Maximize\n");
- if ((Wnd->style & WS_MAXIMIZE) && (Wnd->style & WS_VISIBLE))
- {
- SwpFlags = SWP_NOSIZE | SWP_NOMOVE;
- break;
- }
- co_WinPosGetMinMaxInfo(Wnd, &Size, &wpl.ptMaxPosition, NULL, NULL);
+ for (pwndChild = pwndParent->spwndChild; pwndChild; pwndChild = pwndChild->spwndNext)
+ {
+ if (pwndChild == Window) continue;
- /*ERR("Maximize: %d,%d %dx%d\n",
- wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
- */
- old_style = IntSetStyle( Wnd, WS_MAXIMIZE, WS_MINIMIZE );
+ if ((pwndChild->style & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE) )
+ {
+ continue;
+ }
- if (!(old_style & WS_MAXIMIZE)) SwpFlags |= SWP_STATECHANGED;
- RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
-// wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
- Size.x, Size.y);
- break;
- }
+ if ( pwndChild->InternalPos.IconPos.x != Pos->x && pwndChild->InternalPos.IconPos.y != Pos->y )
+ {
+ break;
+ }
+ if (x <= rectParent.right - xspacing)
+ x += xspacing;
+ else
+ {
+ x = rectParent.left;
+ y -= yspacing;
+ }
+ Pos->x = x + UserGetSystemMetrics(SM_CXBORDER);
+ Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
+ }
- case SW_SHOWNOACTIVATE:
- Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
- /* fall through */
- case SW_SHOWNORMAL:
- case SW_RESTORE:
- case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
- {
- //ERR("MinMaximize Restore\n");
- old_style = IntSetStyle( Wnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
- if (old_style & WS_MINIMIZE)
- {
- if (Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED)
- {
- co_WinPosGetMinMaxInfo(Wnd, &Size, &wpl.ptMaxPosition, NULL, NULL);
- IntSetStyle( Wnd, WS_MAXIMIZE, 0 );
- SwpFlags |= SWP_STATECHANGED;
- /*ERR("Restore to Max: %d,%d %dx%d\n",
- wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
- */
- RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
-// wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
- Size.x, Size.y);
- break;
- }
- else
- {
- *NewPos = wpl.rcNormalPosition;
- /*ERR("Restore Max: %d,%d %dx%d\n",
- NewPos->left, NewPos->top, NewPos->right - NewPos->left, NewPos->bottom - NewPos->top);
- */
- NewPos->right -= NewPos->left;
- NewPos->bottom -= NewPos->top;
- break;
- }
- }
- else
- {
- if (!(old_style & WS_MAXIMIZE))
- {
- break;
- }
- SwpFlags |= SWP_STATECHANGED;
- Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
- *NewPos = wpl.rcNormalPosition;
- /*ERR("Restore Min: %d,%d %dx%d\n",
- NewPos->left, NewPos->top, NewPos->right - NewPos->left, NewPos->bottom - NewPos->top);
- */
- NewPos->right -= NewPos->left;
- NewPos->bottom -= NewPos->top;
- break;
- }
- }
- }
- return SwpFlags;
+ Window->InternalPos.IconPos.x = Pos->x;
+ Window->InternalPos.IconPos.y = Pos->y;
+ Window->InternalPos.flags |= WPF_MININIT;
+ TRACE("Position is set! X:%d Y:%d\n",Pos->x,Pos->y);
+ return;
}
BOOL
if (UserHasWindowEdge(Style, ExStyle))
Border += 2;
- else if (ExStyle & WS_EX_STATICEDGE)
- Border += 1;
+ 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 ++;
+ Border ++; /* The other border */
Size->cx = Size->cy = Border;
- if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE))
+ 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->cy *= UserGetSystemMetrics(SM_CYBORDER);
}
-BOOL WINAPI
-UserAdjustWindowRectEx(LPRECT lpRect,
- DWORD dwStyle,
- BOOL bMenu,
- DWORD dwExStyle)
+//
+// Fix CORE-5177
+// See winetests:user32:win.c:wine_AdjustWindowRectEx,
+// Simplified version.
+//
+DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
{
- SIZE BorderSize;
+ DWORD adjust = 0;
- if (bMenu)
- {
- lpRect->top -= UserGetSystemMetrics(SM_CYMENU);
- }
- if ((dwStyle & WS_CAPTION) == WS_CAPTION)
- {
- if (dwExStyle & WS_EX_TOOLWINDOW)
- lpRect->top -= UserGetSystemMetrics(SM_CYSMCAPTION);
- else
- lpRect->top -= UserGetSystemMetrics(SM_CYCAPTION);
- }
- UserGetWindowBorders(dwStyle, dwExStyle, &BorderSize, TRUE);
- RECTL_vInflateRect(
- lpRect,
- BorderSize.cx,
- BorderSize.cy);
+ if ( ExStyle & WS_EX_WINDOWEDGE ) // 1st
+ adjust = 2; /* outer */
+ else if ( ExStyle & WS_EX_STATICEDGE ) // 2nd
+ adjust = 1; /* for the outer frame always present */
- return TRUE;
+ if (ExStyle & WS_EX_CLIENTEDGE)
+ adjust += 2;
+
+ if ( Style & WS_CAPTION || ExStyle & WS_EX_DLGMODALFRAME )
+ adjust++; /* The other border */
+
+ return adjust;
}
UINT FASTCALL
LONG adjustedStyle;
LONG exstyle = Window->ExStyle;
RECT rc;
+ DWORD adjust;
ASSERT_REFS_CO(Window);
else
adjustedStyle = style;
- if(Window->spwndParent)
+ if (Window->spwndParent)
IntGetClientRect(Window->spwndParent, &rc);
- UserAdjustWindowRectEx(&rc, adjustedStyle, ((style & WS_POPUP) && Window->IDMenu), exstyle);
+
+ adjust = IntGetWindowBorders(adjustedStyle, exstyle);
+
+ // Handle special case while maximized. CORE-15893
+ if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
+ adjust += 2;
+
+ 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.ptMaxPosition.x = -xinc;
MinMax.ptMaxPosition.y = -yinc;
- if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
+ if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
co_IntSendMessage(Window->head.h, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
if (style & WS_MAXIMIZEBOX)
{
if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
- rc_work = monitor->rcWork;
+ rc_work = monitor->rcWork;
}
if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
}
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);
+ 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;
+ 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?
+ return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
+}
+
+static
+BOOL
+IntValidateParent(PWND Child, PREGION ValidateRgn)
+{
+ PWND ParentWnd = Child->spwndParent;
+
+ while (ParentWnd)
+ {
+ if (ParentWnd->style & WS_CLIPCHILDREN)
+ break;
+
+ if (ParentWnd->hrgnUpdate != 0)
+ {
+ IntInvalidateWindows( ParentWnd,
+ ValidateRgn,
+ RDW_VALIDATE | RDW_NOCHILDREN);
+ }
+
+ ParentWnd = ParentWnd->spwndParent;
+ }
+
+ return TRUE;
}
static
Parent = Window->spwndParent;
if (0 != (Window->style & WS_CHILD) && Parent)
{
- RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->rcClient.left,
- - Parent->rcClient.top);
- RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->rcClient.left,
- - Parent->rcClient.top);
- RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->rcClient.left,
- - Parent->rcClient.top);
+ RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->rcClient.left, - Parent->rcClient.top);
+ RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->rcClient.left, - Parent->rcClient.top);
+ RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->rcClient.left, - Parent->rcClient.top);
}
params.lppos = &winposCopy;
*ClientRect = params.rgrc[0]; // First rectangle contains the coordinates of the new client rectangle resulting from the move or resize
if ((Window->style & WS_CHILD) && Parent)
{
- RECTL_vOffsetRect(ClientRect, Parent->rcClient.left,
- Parent->rcClient.top);
+ RECTL_vOffsetRect(ClientRect, Parent->rcClient.left, Parent->rcClient.top);
}
FixClientRect(ClientRect, WindowRect);
}
WinPos->flags &= ~SWP_NOCLIENTMOVE;
}
- if (ClientRect->right - ClientRect->left !=
- Window->rcClient.right - Window->rcClient.left)
+ if (ClientRect->right - ClientRect->left != Window->rcClient.right - Window->rcClient.left)
{
WinPos->flags &= ~SWP_NOCLIENTSIZE;
}
else
wvrFlags &= ~WVR_HREDRAW;
- if (ClientRect->bottom - ClientRect->top !=
- Window->rcClient.bottom - Window->rcClient.top)
+ if (ClientRect->bottom - ClientRect->top != Window->rcClient.bottom - Window->rcClient.top)
{
WinPos->flags &= ~SWP_NOCLIENTSIZE;
}
/* Send WM_WINDOWPOSCHANGING message */
- if (!(WinPos->flags & SWP_NOSENDCHANGING))
+ if (!(WinPos->flags & SWP_NOSENDCHANGING)
+ && !((WinPos->flags & SWP_AGG_NOCLIENTCHANGE) && (WinPos->flags & SWP_SHOWWINDOW)))
{
- co_IntSendMessageNoWait(Window->head.h, WM_WINDOWPOSCHANGING, 0, (LPARAM) WinPos);
+ TRACE("Sending WM_WINDOWPOSCHANGING to hwnd %p flags %04x.\n", Window->head.h,WinPos->flags);
+ co_IntSendMessage(Window->head.h, WM_WINDOWPOSCHANGING, 0, (LPARAM) WinPos);
}
/* Calculate new position and size */
{
if (Window->style & WS_MINIMIZE)
{
- WindowRect->right = WindowRect->left + UserGetSystemMetrics(SM_CXICON);
- WindowRect->bottom = WindowRect->top + UserGetSystemMetrics(SM_CYICON);
+ WindowRect->right = WindowRect->left + UserGetSystemMetrics(SM_CXMINIMIZED);
+ WindowRect->bottom = WindowRect->top + UserGetSystemMetrics(SM_CYMINIMIZED);
}
else
{
WindowRect->bottom = WindowRect->top + WinPos->cy;
}
}
-#if 0
- if (!(WinPos->flags & SWP_NOMOVE))
- {
- WindowRect->left = WinPos->x;
- WindowRect->top = WinPos->y;
- WindowRect->right += WinPos->x - Window->rcWindow.left;
- WindowRect->bottom += WinPos->y - Window->rcWindow.top;
- RECTL_vOffsetRect(ClientRect,
- WinPos->x - Window->rcWindow.left,
- WinPos->y - Window->rcWindow.top);
- }
-
- *WindowRect = Window->rcWindow;
- *ClientRect = Window->rcClient;
-
- if (!(WinPos->flags & SWP_NOSIZE))
- {
- WindowRect->right = WindowRect->left + WinPos->cx;
- WindowRect->bottom = WindowRect->top + WinPos->cy;
- }
-#endif
if (!(WinPos->flags & SWP_NOMOVE))
{
INT X, Y;
PWND Parent;
X = WinPos->x;
Y = WinPos->y;
- //ERR("Not SWP_NOMOVE\n");
+
Parent = Window->spwndParent;
- if (((Window->style & WS_CHILD) != 0) &&
+
+ // Parent child position issue is in here. SetParent_W7 test CORE-6651.
+ if (//((Window->style & WS_CHILD) != 0) && <- Fixes wine msg test_SetParent: "rects do not match", the last test.
Parent &&
Parent != Window->head.rpdesk->pDeskInfo->spwnd)
{
- //ERR("Not SWP_NOMOVE 1 Parent client offset X %d Y %d\n",X,Y);
+ TRACE("Not SWP_NOMOVE 1 Parent client offset X %d Y %d\n",X,Y);
X += Parent->rcClient.left;
Y += Parent->rcClient.top;
- //ERR("Not SWP_NOMOVE 2 Parent client offset X %d Y %d\n",X,Y);
+ TRACE("Not SWP_NOMOVE 2 Parent client offset X %d Y %d\n",X,Y);
}
WindowRect->left = X;
RECTL_vOffsetRect(ClientRect, X - Window->rcWindow.left,
Y - Window->rcWindow.top);
}
-
WinPos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
WinPos->hwnd, WinPos->hwndInsertAfter, WinPos->x, WinPos->y,
WinPos->cx, WinPos->cy, WinPos->flags );
+ TRACE("WindowRect: %d %d %d %d\n", WindowRect->left,WindowRect->top,WindowRect->right,WindowRect->bottom);
+ TRACE("ClientRect: %d %d %d %d\n", ClientRect->left,ClientRect->top,ClientRect->right,ClientRect->bottom);
return TRUE;
}
TRACE("(%p) hInsertAfter = %p\n", Window, hWndInsertAfter );
- Owner = Window->spwndOwner ? Window->spwndOwner->head.h : NULL;
Style = Window->style;
if (Style & WS_CHILD)
return hWndInsertAfter;
}
+ Owner = Window->spwndOwner ? Window->spwndOwner->head.h : NULL;
+
if (Owner)
{
/* Make sure this popup stays above the owner */
if (hWndInsertAfter == HWND_BOTTOM)
{
- ERR("Window is HWND_BOTTOM\n");
+ ERR("Window is HWND_BOTTOM hwnd %p\n",hWndInsertAfter);
if (List) ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
goto done;
}
TRACE("skip all the topmost windows\n");
/* skip all the topmost windows */
while (List[i] &&
- (ChildObject = ValidateHwndNoErr(List[i])) &&
+ (ChildObject = ValidateHwndNoErr(List[i])) &&
(ChildObject->ExStyle & WS_EX_TOPMOST)) i++;
}
}
PWND Child;
ASSERT(Window != Window->spwndChild);
+ TRACE("InternalMoveWin X %d Y %d\n", MoveX, MoveY);
Window->rcWindow.left += MoveX;
Window->rcWindow.right += MoveX;
POINT pt;
/* Finally make sure that all coordinates are valid */
- if (WinPos->x < -32768) WinPos->x = -32768;
+ if (WinPos->x < -32768) WinPos->x = -32768;
else if (WinPos->x > 32767) WinPos->x = 32767;
- if (WinPos->y < -32768) WinPos->y = -32768;
+ if (WinPos->y < -32768) WinPos->y = -32768;
else if (WinPos->y > 32767) WinPos->y = 32767;
WinPos->cx = max(WinPos->cx, 0);
WinPos->cy = max(WinPos->cy, 0);
Parent = UserGetAncestor( Wnd, GA_PARENT );
- if (!IntIsWindowVisible( Parent )) WinPos->flags |= SWP_NOREDRAW;
+ if (!IntIsWindowVisible( Parent ) &&
+ /* Fix B : wine msg test_SetParent:WmSetParentSeq_2:25 wParam bits! */
+ (WinPos->flags & SWP_AGG_STATUSFLAGS) == SWP_AGG_NOPOSCHANGE) WinPos->flags |= SWP_NOREDRAW;
if (Wnd->style & WS_VISIBLE) WinPos->flags &= ~SWP_SHOWWINDOW;
else
pt.x = WinPos->x;
pt.y = WinPos->y;
IntClientToScreen( Parent, &pt );
- //ERR("WPFU C2S wpx %d wpy %d ptx %d pty %d\n",WinPos->x,WinPos->y,pt.x,pt.y);
+ TRACE("WPFU C2S wpx %d wpy %d ptx %d pty %d\n",WinPos->x,WinPos->y,pt.x,pt.y);
/* Check for right position */
if (Wnd->rcWindow.left == pt.x && Wnd->rcWindow.top == pt.y)
{
WinPos->flags |= SWP_NOMOVE;
}
- if (WinPos->hwnd == UserGetForegroundWindow())
+ if ( WinPos->hwnd != UserGetForegroundWindow() && (Wnd->style & (WS_POPUP | WS_CHILD)) != WS_CHILD)
{
- WinPos->flags |= SWP_NOACTIVATE; /* Already active */
- }
- else
- if ((Wnd->style & (WS_POPUP | WS_CHILD)) != WS_CHILD)
+ /* Bring to the top when activating */
+ if (!(WinPos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) &&
+ (WinPos->flags & SWP_NOZORDER ||
+ (WinPos->hwndInsertAfter != HWND_TOPMOST && WinPos->hwndInsertAfter != HWND_NOTOPMOST)))
{
- /* Bring to the top when activating */
- if (!(WinPos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) &&
- (WinPos->flags & SWP_NOZORDER ||
- (WinPos->hwndInsertAfter != HWND_TOPMOST && WinPos->hwndInsertAfter != HWND_NOTOPMOST)))
- {
- WinPos->flags &= ~SWP_NOZORDER;
- WinPos->hwndInsertAfter = (0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP);
- }
+ WinPos->flags &= ~SWP_NOZORDER;
+ WinPos->hwndInsertAfter = (0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP);
}
+ }
/* Check hwndInsertAfter */
if (!(WinPos->flags & SWP_NOZORDER))
WinPos->hwndInsertAfter = HWND_TOPMOST;
if (IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
+ {
WinPos->flags |= SWP_NOZORDER;
+ }
}
else if (WinPos->hwndInsertAfter == HWND_BOTTOM)
{
RECTL NewWindowRect;
RECTL NewClientRect;
RECTL valid_rects[2];
- PROSRGNDATA VisRgn;
- HRGN VisBefore = NULL;
- HRGN VisAfter = NULL;
- HRGN DirtyRgn = NULL;
- HRGN ExposedRgn = NULL;
- HRGN CopyRgn = NULL;
+ 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;
+ BOOL bPointerInWindow, PosChanged = FALSE;
+ PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
ASSERT_REFS_CO(Window);
+ TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags %s",
+ 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);
{
VisBefore = VIS_ComputeVisibleRegion(Window, FALSE, FALSE,
(Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
- VisRgn = NULL;
if ( VisBefore != NULL &&
- (VisRgn = (PROSRGNDATA)RGNOBJAPI_Lock(VisBefore, NULL)) &&
- REGION_Complexity(VisRgn) == NULLREGION )
+ REGION_Complexity(VisBefore) == NULLREGION )
{
- RGNOBJAPI_Unlock(VisRgn);
- GreDeleteObject(VisBefore);
+ REGION_Delete(VisBefore);
VisBefore = NULL;
}
- else if(VisRgn)
+ 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))
{
- RGNOBJAPI_Unlock(VisRgn);
- NtGdiOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
+ 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);
+ }
}
}
}
+ //// HACK 3
+ 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,
OldWindowRect = Window->rcWindow;
OldClientRect = Window->rcClient;
- //ERR("SetWindowPos OldWindowRect: %d %d %d %d\n", OldWindowRect.left,OldWindowRect.top,OldWindowRect.right,OldWindowRect.bottom);
- //ERR("SetWindowPos OldClientRect: %d %d %d %d\n", OldClientRect.left,OldClientRect.top,OldClientRect.right,OldClientRect.bottom);
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;
- //ERR("SetWindowPos NewWindowRect: %d %d %d %d\n", NewWindowRect.left,NewWindowRect.top,NewWindowRect.right,NewWindowRect.bottom);
- //ERR("SetWindowPos NewClientRect: %d %d %d %d\n", NewClientRect.left,NewClientRect.top,NewClientRect.right,NewClientRect.bottom);
-
/* erase parent when hiding or resizing child */
if (WinPos.flags & SWP_HIDEWINDOW)
{
0,
RDW_VALIDATE | RDW_NOFRAME | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_ALLCHILDREN);
- if (Window->spwndParent == UserGetDesktopWindow())
+ if (UserIsDesktopWindow(Window->spwndParent))
co_IntShellHookNotify(HSHELL_WINDOWDESTROYED, (WPARAM)Window->head.h, 0);
Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
}
else if (WinPos.flags & SWP_SHOWWINDOW)
{
- if (Window->spwndParent == UserGetDesktopWindow())
+ if (UserIsDesktopWindow(Window->spwndParent) &&
+ Window->spwndOwner == NULL &&
+ (!(Window->ExStyle & WS_EX_TOOLWINDOW) ||
+ (Window->ExStyle & WS_EX_APPWINDOW)))
co_IntShellHookNotify(HSHELL_WINDOWCREATED, (WPARAM)Window->head.h, 0);
Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
/* Determine the new visible region */
VisAfter = VIS_ComputeVisibleRegion(Window, FALSE, FALSE,
(Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
- VisRgn = NULL;
if ( VisAfter != NULL &&
- (VisRgn = (PROSRGNDATA)RGNOBJAPI_Lock(VisAfter, NULL)) &&
- REGION_Complexity(VisRgn) == NULLREGION )
+ REGION_Complexity(VisAfter) == NULLREGION )
{
- RGNOBJAPI_Unlock(VisRgn);
- GreDeleteObject(VisAfter);
+ REGION_Delete(VisAfter);
VisAfter = NULL;
}
- else if(VisRgn)
+ else if(VisAfter)
{
- RGNOBJAPI_Unlock(VisRgn);
- NtGdiOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
+ REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
}
/*
* class need to be completely repainted on (horizontal/vertical) size
* change.
*/
- if ( VisBefore != NULL &&
- VisAfter != NULL &&
- !(WinPos.flags & SWP_NOCOPYBITS) &&
- ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
- !(Window->ExStyle & WS_EX_TRANSPARENT) )
+ if ( ( VisBefore != NULL &&
+ VisAfter != NULL &&
+ !(WinPos.flags & SWP_NOCOPYBITS) &&
+ ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
+ !(Window->ExStyle & WS_EX_TRANSPARENT) ) )
{
- CopyRgn = IntSysCreateRectRgn(0, 0, 0, 0);
- RgnType = NtGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
/*
* If this is (also) a window resize, the whole nonclient area
* we don't have to crop (can't take anything away from an empty
* region...)
*/
- if (!(WinPos.flags & SWP_NOSIZE) &&
- RgnType != ERROR &&
- RgnType != NULLREGION )
+
+ CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
+ if (WinPos.flags & SWP_NOSIZE)
+ RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
+ else if (VisBeforeJustClient != NULL)
{
- PROSRGNDATA pCopyRgn;
- RECTL ORect = OldClientRect;
- RECTL NRect = NewClientRect;
- RECTL_vOffsetRect(&ORect, - OldWindowRect.left, - OldWindowRect.top);
- RECTL_vOffsetRect(&NRect, - NewWindowRect.left, - NewWindowRect.top);
- RECTL_bIntersectRect(&CopyRect, &ORect, &NRect);
- pCopyRgn = RGNOBJAPI_Lock(CopyRgn, NULL);
- REGION_CropAndOffsetRegion(pCopyRgn, pCopyRgn, &CopyRect, NULL);
- RGNOBJAPI_Unlock(pCopyRgn);
+ RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
+ REGION_Delete(VisBeforeJustClient);
}
- /* No use in copying bits which are in the update region. */
+ /* Now use in copying bits which are in the update region. */
if (Window->hrgnUpdate != NULL)
{
- NtGdiOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
- NtGdiCombineRgn(CopyRgn, CopyRgn, Window->hrgnUpdate, RGN_DIFF);
- NtGdiOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
+ 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);
+ }
}
/*
* there's nothing to copy. Also, it's no use copying bits onto
* themselves.
*/
- if ( (VisRgn = (PROSRGNDATA)RGNOBJAPI_Lock(CopyRgn, NULL)) &&
- REGION_GetRgnBox(VisRgn, &CopyRect) == NULLREGION)
+ if (REGION_GetRgnBox(CopyRgn, &CopyRect) == NULLREGION)
{
/* Nothing to copy, clean up */
- RGNOBJAPI_Unlock(VisRgn);
- GreDeleteObject(CopyRgn);
+ REGION_Delete(CopyRgn);
CopyRgn = NULL;
}
- else if (OldWindowRect.left != NewWindowRect.left ||
- OldWindowRect.top != NewWindowRect.top)
+ else if ( OldWindowRect.left != NewWindowRect.left ||
+ OldWindowRect.top != NewWindowRect.top ||
+ (WinPos.flags & SWP_FRAMECHANGED) )
{
- if(VisRgn)
- {
- RGNOBJAPI_Unlock(VisRgn);
- }
+ HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
+ PREGION DcRgnObj = REGION_LockRgn(DcRgn);
/*
* Small trick here: there is no function to bitblt a region. So
* Since NtUserGetDCEx takes ownership of the clip region, we need
* to create a copy of CopyRgn and pass that. We need CopyRgn later
*/
- NtGdiOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
+ IntGdiCombineRgn(DcRgnObj, CopyRgn, NULL, RGN_COPY);
+ REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
+ REGION_UnlockRgn(DcRgnObj);
Dc = UserGetDCEx( Window,
- CopyRgn,
- DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN);
+ 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,
0,
0);
- UserReleaseDC(Window, Dc, FALSE);
- IntValidateParent(Window, CopyRgn, FALSE);
- NtGdiOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
- }
- else if(VisRgn)
- {
- RGNOBJAPI_Unlock(VisRgn);
+ UserReleaseDC(Window, Dc, FALSE);
+ IntValidateParent(Window, CopyRgn);
+ GreDeleteObject(DcRgn);
}
}
else
CopyRgn = NULL;
}
- /* We need to redraw what wasn't visible before */
+ /* We need to redraw what wasn't visible before or force a redraw */
if (VisAfter != NULL)
{
- DirtyRgn = IntSysCreateRectRgn(0, 0, 0, 0);
- if (CopyRgn != NULL)
- {
- RgnType = NtGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
- }
- else
+ PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
+ if (DirtyRgn)
{
- RgnType = NtGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
- }
- if (RgnType != ERROR && RgnType != NULLREGION)
- {
- /* 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;
+ if (CopyRgn != NULL)
+ {
+ RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
+ }
+ else
+ {
+ RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
+ }
- NtGdiOffsetRgn( 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_ERASENOW, FALSE);
- }
- else
- {
+ 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);
- }
+ 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);
+ }
+ else
+ {
+ 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
+ {
+ 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) )
+ {
+ IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
+ }
+ }
+ }
+ REGION_Delete(DirtyRgn);
}
- GreDeleteObject(DirtyRgn);
}
if (CopyRgn != NULL)
{
- GreDeleteObject(CopyRgn);
+ REGION_Delete(CopyRgn);
}
/* Expose what was covered before but not covered anymore */
- if (VisBefore != NULL)
+ if ( VisBefore != NULL )
{
- ExposedRgn = IntSysCreateRectRgn(0, 0, 0, 0);
- RgnType = NtGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
- NtGdiOffsetRgn( ExposedRgn,
- OldWindowRect.left - NewWindowRect.left,
- OldWindowRect.top - NewWindowRect.top);
+ 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 = NtGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
+ if ( VisAfter != NULL )
+ RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
- if (RgnType != ERROR && RgnType != NULLREGION)
- {
- co_VIS_WindowLayoutChanged(Window, ExposedRgn);
+ if (RgnType != ERROR && RgnType != NULLREGION)
+ {
+ co_VIS_WindowLayoutChanged(Window, ExposedRgn);
+ }
+ REGION_Delete(ExposedRgn);
}
- GreDeleteObject(ExposedRgn);
- GreDeleteObject(VisBefore);
+ REGION_Delete(VisBefore);
}
if (VisAfter != NULL)
{
- GreDeleteObject(VisAfter);
+ REGION_Delete(VisAfter);
}
}
else
{
//ERR("SetWindowPos Set FG Window!\n");
- if (Window->state & WNDS_BEINGACTIVATED) // Inside SAW?
- co_IntSetActiveWindow(Window, FALSE, TRUE, FALSE); // Fixes Api AttachThreadInput tests.
- else
- co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
+ 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 WS_CLIPCHILDREN\n");
+ UserSyncAndPaintWindows( Parent, RDW_CLIPCHILDREN);
+ }
+ }
+
+ // 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(!(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 flags = %04x\n", WinPos.flags & SWP_AGG_STATUSFLAGS);
+ TRACE("\tstatus hwnd %p flags = %04x\n",Window?Window->head.h:NULL,WinPos.flags & SWP_AGG_STATUSFLAGS);
- if ((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
+ 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.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);
}
co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SIZE, wParam, lParam);
- if (Wnd->spwndParent == UserGetDesktopWindow()) // Wnd->spwndParent->fnid == FNID_DESKTOP )
+ 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);
IntEngWindowChanged(Wnd, WOC_RGN_CLIENT);
}
+UINT FASTCALL
+co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT* NewPos)
+{
+ POINT Size;
+ WINDOWPLACEMENT wpl;
+ LONG old_style;
+ UINT SwpFlags = 0;
+
+ ASSERT_REFS_CO(Wnd);
+
+ wpl.length = sizeof(wpl);
+ IntGetWindowPlacement( Wnd, &wpl );
+
+ if (co_HOOK_CallHooks( WH_CBT, HCBT_MINMAX, (WPARAM)Wnd->head.h, ShowFlag))
+ {
+ ERR("WinPosMinMaximize WH_CBT Call Hook return!\n");
+ return SWP_NOSIZE | SWP_NOMOVE;
+ }
+ if (Wnd->style & WS_MINIMIZE)
+ {
+ switch (ShowFlag)
+ {
+ case SW_MINIMIZE:
+ case SW_SHOWMINNOACTIVE:
+ case SW_SHOWMINIMIZED:
+ case SW_FORCEMINIMIZE:
+ return SWP_NOSIZE | SWP_NOMOVE;
+ }
+ if (!co_IntSendMessageNoWait(Wnd->head.h, WM_QUERYOPEN, 0, 0))
+ {
+ return(SWP_NOSIZE | SWP_NOMOVE);
+ }
+ SwpFlags |= SWP_NOCOPYBITS;
+ }
+ switch (ShowFlag)
+ {
+ case SW_MINIMIZE:
+ case SW_SHOWMINNOACTIVE:
+ case SW_SHOWMINIMIZED:
+ case SW_FORCEMINIMIZE:
+ {
+ //ERR("MinMaximize Minimize\n");
+ if (Wnd->style & WS_MAXIMIZE)
+ {
+ Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
+ }
+ else
+ {
+ Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
+ }
+
+ old_style = IntSetStyle( Wnd, WS_MINIMIZE, WS_MAXIMIZE );
+
+ co_UserRedrawWindow(Wnd, NULL, 0, RDW_VALIDATE | RDW_NOERASE | RDW_NOINTERNALPAINT);
+
+ if (!(Wnd->InternalPos.flags & WPF_SETMINPOSITION))
+ Wnd->InternalPos.flags &= ~WPF_MININIT;
+
+ WinPosFindIconPos(Wnd, &wpl.ptMinPosition);
+
+ if (!(old_style & WS_MINIMIZE))
+ {
+ SwpFlags |= SWP_STATECHANGED;
+ IntShowOwnedPopups(Wnd, FALSE);
+ }
+
+ RECTL_vSetRect(NewPos, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
+ wpl.ptMinPosition.x + UserGetSystemMetrics(SM_CXMINIMIZED),
+ wpl.ptMinPosition.y + UserGetSystemMetrics(SM_CYMINIMIZED));
+ SwpFlags |= SWP_NOCOPYBITS;
+ break;
+ }
+
+ case SW_MAXIMIZE:
+ {
+ //ERR("MinMaximize Maximize\n");
+ if ((Wnd->style & WS_MAXIMIZE) && (Wnd->style & WS_VISIBLE))
+ {
+ SwpFlags = SWP_NOSIZE | SWP_NOMOVE;
+ break;
+ }
+ co_WinPosGetMinMaxInfo(Wnd, &Size, &wpl.ptMaxPosition, NULL, NULL);
+
+ /*ERR("Maximize: %d,%d %dx%d\n",
+ wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
+ */
+ old_style = IntSetStyle( Wnd, WS_MAXIMIZE, WS_MINIMIZE );
+ /*if (old_style & WS_MINIMIZE)
+ {
+ IntShowOwnedPopups(Wnd, TRUE);
+ }*/
+
+ if (!(old_style & WS_MAXIMIZE)) SwpFlags |= SWP_STATECHANGED;
+ RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
+ //wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
+ Size.x, Size.y);
+ break;
+ }
+
+ case SW_SHOWNOACTIVATE:
+ Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
+ /* fall through */
+ case SW_SHOWNORMAL:
+ case SW_RESTORE:
+ case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
+ {
+ //ERR("MinMaximize Restore\n");
+ old_style = IntSetStyle( Wnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
+ if (old_style & WS_MINIMIZE)
+ {
+ IntShowOwnedPopups(Wnd, TRUE);
+
+ if (Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED)
+ {
+ co_WinPosGetMinMaxInfo(Wnd, &Size, &wpl.ptMaxPosition, NULL, NULL);
+ IntSetStyle( Wnd, WS_MAXIMIZE, 0 );
+ SwpFlags |= SWP_STATECHANGED;
+ RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
+ wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
+ break;
+ }
+ else
+ {
+ *NewPos = wpl.rcNormalPosition;
+ NewPos->right -= NewPos->left;
+ NewPos->bottom -= NewPos->top;
+ break;
+ }
+ }
+ else
+ {
+ if (!(old_style & WS_MAXIMIZE))
+ {
+ break;
+ }
+ SwpFlags |= SWP_STATECHANGED;
+ Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
+ *NewPos = wpl.rcNormalPosition;
+ NewPos->right -= NewPos->left;
+ NewPos->bottom -= NewPos->top;
+ break;
+ }
+ }
+ }
+ return SwpFlags;
+}
+
+/*
+ ShowWindow does not set SWP_FRAMECHANGED!!! Fix wine msg test_SetParent:WmSetParentSeq_2:23 wParam bits!
+ */
BOOLEAN FASTCALL
co_WinPosShowWindow(PWND Wnd, INT Cmd)
{
LONG style;
PWND Parent;
PTHREADINFO pti;
- // HRGN VisibleRgn;
- //ERR("co_WinPosShowWindow START\n");
+ //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",
+ Wnd->head.h, 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);
+ return FALSE;
}
Swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE;
if (Wnd != pti->MessageQueue->spwndActive)
if (!(style & WS_MINIMIZE))
{
IntShowOwnedPopups(Wnd, FALSE );
-
// Fix wine Win test_SetFocus todo #1 & #2,
if (Cmd == SW_SHOWMINIMIZED)
{
co_UserSetFocus(0);
}
- Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos) |
- SWP_FRAMECHANGED;
+ Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
EventMsg = EVENT_SYSTEM_MINIMIZESTART;
}
else
{
- if (!WasVisible)
- {
- Swp |= SWP_FRAMECHANGED;
- }
- else ////
+ if (WasVisible)
{
//ERR("co_WinPosShowWindow Exit Good\n");
return TRUE;
{
ShowOwned = TRUE;
- Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos) |
- SWP_FRAMECHANGED;
+ Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
EventMsg = EVENT_SYSTEM_MINIMIZEEND;
}
else
{
- if (!WasVisible)
- {
- Swp |= SWP_FRAMECHANGED;
- }
- else ////
+ if (WasVisible)
{
//ERR("co_WinPosShowWindow Exit Good 1\n");
return TRUE;
if (!WasVisible) Swp |= SWP_SHOWWINDOW;
if (style & (WS_MINIMIZE | WS_MAXIMIZE))
{
- Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos) |
- SWP_FRAMECHANGED;
-
+ Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
}
else
{
- if (!WasVisible)
- {
- Swp |= SWP_FRAMECHANGED;
- }
- else ////
+ if (WasVisible)
{
//ERR("co_WinPosShowWindow Exit Good 3\n");
return TRUE;
if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
{
co_IntSendMessageNoWait(Wnd->head.h, WM_SHOWWINDOW, ShowFlag, 0);
- if (!(Wnd->state2 & WNDS2_WIN31COMPAT))
+#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
+ if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
co_IntSendMessageNoWait(Wnd->head.h, WM_SETVISIBLE, ShowFlag, 0);
+#endif
if (!VerifyWnd(Wnd)) return WasVisible;
}
Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
}
-#if 0 // Explorer issues with common controls. Someone does not know how CS_SAVEBITS works.
+#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);
+ //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\n",
+ 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"));
+ (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,
- NewPos.bottom, //NewPos.bottom - 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
{
if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
{
- if ( Wnd->spwndParent == UserGetDesktopWindow())
+ if (UserIsDesktopWindow(Wnd->spwndParent))
{
- if(!ActivateOtherWindowMin(Wnd))
+ if (!ActivateOtherWindowMin(Wnd))
+ {
co_WinPosActivateOtherWindow(Wnd);
+ }
}
else
+ {
co_WinPosActivateOtherWindow(Wnd);
+ }
}
/* Revert focus to parent */
if (Wnd == pti->MessageQueue->spwndFocus)
{
Parent = Wnd->spwndParent;
- if (Wnd->spwndParent == UserGetDesktopWindow()) Parent = 0;
+ if (UserIsDesktopWindow(Wnd->spwndParent))
+ Parent = 0;
co_UserSetFocus(Parent);
}
+ // Hide, just return.
+ if (Cmd == SW_HIDE) return WasVisible;
}
/* FIXME: Check for window destruction. */
{
co_UserSetFocus(Wnd);
// Fix wine Win test_SetFocus todo #3,
- if (!(style & WS_CHILD)) co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_ACTIVATE, WA_ACTIVE, 0);
+ if (!(style & WS_CHILD)) co_IntSendMessage(UserHMGetHandle(Wnd), WM_ACTIVATE, WA_ACTIVE, 0);
}
//ERR("co_WinPosShowWindow EXIT\n");
- return(WasVisible);
+ return WasVisible;
}
-static
-PWND FASTCALL
+static PWND
co_WinPosSearchChildren(
- PWND ScopeWin,
- POINT *Point,
- USHORT *HitTest,
- BOOL Ignore
+ IN PWND ScopeWin,
+ IN POINT *Point,
+ IN OUT USHORT *HitTest,
+ IN BOOL Ignore
)
{
- PWND pwndChild;
HWND *List, *phWnd;
+ PWND pwndChild = NULL;
+ /* not visible */
if (!(ScopeWin->style & WS_VISIBLE))
{
return NULL;
}
- if (!Ignore && (ScopeWin->style & WS_DISABLED))
+ /* not in window or in window region */
+ if (!IntPtInWindow(ScopeWin, Point->x, Point->y))
{
return NULL;
}
- if (!IntPtInWindow(ScopeWin, Point->x, Point->y))
+ /* transparent */
+ if ((ScopeWin->ExStyle & (WS_EX_LAYERED|WS_EX_TRANSPARENT)) == (WS_EX_LAYERED|WS_EX_TRANSPARENT))
{
return NULL;
}
- UserReferenceObject(ScopeWin);
+ if (!Ignore && (ScopeWin->style & WS_DISABLED))
+ { /* disabled child */
+ if ((ScopeWin->style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return NULL;
+ /* process the hit error */
+ *HitTest = HTERROR;
+ return ScopeWin;
+ }
- if ( RECTL_bPointInRect(&ScopeWin->rcClient, Point->x, Point->y) )
+ /* not minimized and check if point is inside the window */
+ if (!(ScopeWin->style & WS_MINIMIZE) &&
+ RECTL_bPointInRect(&ScopeWin->rcClient, Point->x, Point->y) )
{
+ UserReferenceObject(ScopeWin);
+
List = IntWinListChildren(ScopeWin);
- if(List)
+ if (List)
{
for (phWnd = List; *phWnd; ++phWnd)
{
pwndChild = co_WinPosSearchChildren(pwndChild, Point, HitTest, Ignore);
- if(pwndChild != NULL)
+ if (pwndChild != NULL)
{
/* We found a window. Don't send any more WM_NCHITTEST messages */
ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
}
ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
}
+ UserDereferenceObject(ScopeWin);
}
if (ScopeWin->head.pti == PsGetCurrentThreadWin32Thread())
{
- *HitTest = (USHORT)co_IntSendMessage(ScopeWin->head.h, WM_NCHITTEST, 0,
- MAKELONG(Point->x, Point->y));
+ *HitTest = (USHORT)co_IntSendMessage(ScopeWin->head.h, WM_NCHITTEST, 0, MAKELONG(Point->x, Point->y));
+
if ((*HitTest) == (USHORT)HTTRANSPARENT)
{
- UserDereferenceObject(ScopeWin);
return NULL;
}
}
else
- *HitTest = HTCLIENT;
+ {
+ if (*HitTest == HTNOWHERE && pwndChild == NULL) *HitTest = HTCLIENT;
+ }
return ScopeWin;
}
-PWND FASTCALL
-co_WinPosWindowFromPoint(PWND ScopeWin, POINT *WinPoint, USHORT* HitTest, BOOL Ignore)
+PWND APIENTRY
+co_WinPosWindowFromPoint(
+ IN PWND ScopeWin,
+ IN POINT *WinPoint,
+ IN OUT USHORT* HitTest,
+ IN BOOL Ignore)
{
PWND Window;
POINT Point = *WinPoint;
Pt.x = x;
Pt.y = y;
- if (Parent != UserGetDesktopWindow())
+ if (!UserIsDesktopWindow(Parent))
{
Pt.x += Parent->rcClient.left;
Pt.y += Parent->rcClient.top;
Pt.x = x;
Pt.y = y;
- if (Parent != UserGetDesktopWindow())
+ if (!UserIsDesktopWindow(Parent))
{
if (Parent->ExStyle & WS_EX_LAYOUTRTL)
Pt.x = Parent->rcClient.right - Pt.x;
}
pWnd = UserGetWindowObject(Wnd);
- if ( !pWnd || // FIXME:
- pWnd == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- pWnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
{
goto Exit;
}
WndInsertAfter != HWND_NOTOPMOST )
{
pWndIA = UserGetWindowObject(WndInsertAfter);
- if ( !pWndIA ||
- pWndIA == UserGetDesktopWindow() ||
- pWndIA == UserGetMessageWindow() )
+ if (!pWndIA || UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
{
goto Exit;
}
}
Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN( FALSE);
}
- if(Safepl.length != sizeof(WINDOWPLACEMENT))
- {
- RETURN( FALSE);
- }
+
+ Safepl.length = sizeof(WINDOWPLACEMENT);
IntGetWindowPlacement(Wnd, &Safepl);
Status = MmCopyToCaller(lpwndpl, &Safepl, sizeof(WINDOWPLACEMENT));
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN( FALSE);
UserEnterExclusive();
pWnd = UserGetWindowObject(hWnd);
- if ( !pWnd || // FIXME:
- pWnd == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- pWnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
{
goto Exit;
}
TRACE("Enter NtUserSetWindowPos\n");
UserEnterExclusive();
- if (!(Window = UserGetWindowObject(hWnd)) || // FIXME:
- Window == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Window == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!(Window = UserGetWindowObject(hWnd)) ||
+ UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
{
ERR("NtUserSetWindowPos bad window handle!\n");
RETURN(FALSE);
}
- if ( hWndInsertAfter &&
+ if ( hWndInsertAfter != HWND_TOP &&
hWndInsertAfter != HWND_BOTTOM &&
hWndInsertAfter != HWND_TOPMOST &&
hWndInsertAfter != HWND_NOTOPMOST )
{
if (!(pWndIA = UserGetWindowObject(hWndInsertAfter)) ||
- pWndIA == UserGetDesktopWindow() ||
- pWndIA == UserGetMessageWindow() )
+ UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
{
ERR("NtUserSetWindowPos bad insert window handle!\n");
RETURN(FALSE);
HRGN hRgn,
BOOL bRedraw)
{
- HRGN hrgnCopy;
+ HRGN hrgnCopy = NULL;
PWND Window;
INT flags = (SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE);
BOOLEAN Ret = FALSE;
TRACE("Enter NtUserSetWindowRgn\n");
UserEnterExclusive();
- if (!(Window = UserGetWindowObject(hWnd)) || // FIXME:
- Window == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Window == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!(Window = UserGetWindowObject(hWnd)) ||
+ UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
{
RETURN( 0);
}
{
if (GreIsHandleValid(hRgn))
{
- hrgnCopy = IntSysCreateRectRgn(0, 0, 0, 0);
+ hrgnCopy = NtGdiCreateRectRgn(0, 0, 0, 0);
/* The coordinates of a window's window region are relative to the
upper-left corner of the window, not the client area of the window. */
NtGdiCombineRgn( hrgnCopy, hRgn, 0, RGN_COPY);
else
RETURN( 0);
}
- else
- {
- hrgnCopy = NULL;
- }
- if (Window->hrgnClip)
+ //// HACK 1 : Work around the lack of supporting DeferWindowPos.
+ if (hrgnCopy)
{
- /* Delete no longer needed region handle */
- IntGdiSetRegionOwner(Window->hrgnClip, GDI_OBJ_HMGR_POWNED);
- GreDeleteObject(Window->hrgnClip);
+ Window->hrgnNewFrame = hrgnCopy; // Should be PSMWP->acvr->hrgnClip
}
-
- if (hrgnCopy)
+ else
{
- /* Set public ownership */
- IntGdiSetRegionOwner(hrgnCopy, GDI_OBJ_HMGR_PUBLIC);
+ Window->hrgnNewFrame = HRGN_WINDOW;
}
- Window->hrgnClip = hrgnCopy;
-
+ //// HACK 2
Ret = co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, bRedraw ? flags : (flags|SWP_NOREDRAW) );
RETURN( (INT)Ret);
UserEnterExclusive();
if (!(Wnd = UserGetWindowObject(hwnd)) || // FIXME:
- Wnd == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Wnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ UserIsDesktopWindow(Wnd) || UserIsMessageWindow(Wnd))
{
RETURN( FALSE);
}
TRACE("Enter NtUserSetWindowPlacement\n");
UserEnterExclusive();
- if (!(Wnd = UserGetWindowObject(hWnd)) || // FIXME:
- Wnd == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Wnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!(Wnd = UserGetWindowObject(hWnd)) ||
+ UserIsDesktopWindow(Wnd) || UserIsMessageWindow(Wnd))
{
RETURN( FALSE);
}
TRACE("Enter NtUserShowWindowAsync\n");
UserEnterExclusive();
- if (!(Window = UserGetWindowObject(hWnd)) || // FIXME:
- Window == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Window == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!(Window = UserGetWindowObject(hWnd)) ||
+ UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
{
RETURN(FALSE);
}
DECLARE_RETURN(BOOL);
USER_REFERENCE_ENTRY Ref;
- TRACE("Enter NtUserShowWindow\n");
+ TRACE("Enter NtUserShowWindow hWnd %p SW_ %d\n",hWnd, nCmdShow);
UserEnterExclusive();
- if (!(Window = UserGetWindowObject(hWnd)) || // FIXME:
- Window == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
- Window == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
+ if (!(Window = UserGetWindowObject(hWnd)) ||
+ UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
{
RETURN(FALSE);
}
RETURN( NULL);
CLEANUP:
- if (Window) UserDereferenceObject(Window);
if (DesktopWindow) UserDerefObjectCo(DesktopWindow);
TRACE("Leave NtUserWindowFromPoint, ret=%p\n", _ret_);
projects / reactos.git / blobdiff