styleNew = (pwnd->style | set_bits) & ~clear_bits;
if (styleNew == styleOld) return styleNew;
pwnd->style = styleNew;
- if ((styleOld ^ styleNew) & WS_VISIBLE) DceResetActiveDCEs( pwnd );
+ if ((styleOld ^ styleNew) & WS_VISIBLE) // State Change.
+ {
+ if (styleOld & WS_VISIBLE) pwnd->head.pti->cVisWindows--;
+ if (styleNew & WS_VISIBLE) pwnd->head.pti->cVisWindows++;
+ DceResetActiveDCEs( pwnd );
+ }
return styleOld;
}
BOOL FASTCALL
IntIsWindowVisible(PWND Wnd)
{
- BOOL Ret = TRUE;
- do
+ PWND Temp = Wnd;
+ for (;;)
{
- if (!(Wnd->style & WS_VISIBLE))
- {
- Ret = FALSE;
- break;
- }
- if (Wnd->spwndParent != NULL)
- Wnd = Wnd->spwndParent;
- else
- break;
+ if (!Temp) return TRUE;
+ if (!(Temp->style & WS_VISIBLE)) break;
+ if (Temp->style & WS_MINIMIZE && Temp != Wnd) break;
+ if (Temp->fnid == FNID_DESKTOP) return TRUE;
+ Temp = Temp->spwndParent;
}
- while (Wnd != NULL);
- return Ret;
+ return FALSE;
}
PWND FASTCALL
PWND FASTCALL
IntGetNonChildAncestor(PWND pWnd)
{
- if (pWnd)
- {
- while(pWnd && ((pWnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD))
- pWnd = pWnd->spwndParent;
- }
+ while(pWnd && (pWnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
+ pWnd = pWnd->spwndParent;
return pWnd;
}
return FALSE;
}
+HWND FASTCALL
+IntGetWindow(HWND hWnd,
+ UINT uCmd)
+{
+ PWND Wnd, FoundWnd;
+ HWND Ret = NULL;
+
+ Wnd = ValidateHwndNoErr(hWnd);
+ if (!Wnd)
+ return NULL;
+
+ FoundWnd = NULL;
+ switch (uCmd)
+ {
+ case GW_OWNER:
+ if (Wnd->spwndOwner != NULL)
+ FoundWnd = Wnd->spwndOwner;
+ break;
+
+ case GW_HWNDFIRST:
+ if(Wnd->spwndParent != NULL)
+ {
+ FoundWnd = Wnd->spwndParent;
+ if (FoundWnd->spwndChild != NULL)
+ FoundWnd = FoundWnd->spwndChild;
+ }
+ break;
+ case GW_HWNDNEXT:
+ if (Wnd->spwndNext != NULL)
+ FoundWnd = Wnd->spwndNext;
+ break;
+
+ case GW_HWNDPREV:
+ if (Wnd->spwndPrev != NULL)
+ FoundWnd = Wnd->spwndPrev;
+ break;
+
+ case GW_CHILD:
+ if (Wnd->spwndChild != NULL)
+ FoundWnd = Wnd->spwndChild;
+ break;
+
+ case GW_HWNDLAST:
+ FoundWnd = Wnd;
+ while ( FoundWnd->spwndNext != NULL)
+ FoundWnd = FoundWnd->spwndNext;
+ break;
+
+ default:
+ Wnd = NULL;
+ break;
+ }
+
+ if (FoundWnd != NULL)
+ Ret = UserHMGetHandle(FoundWnd);
+ return Ret;
+}
+
/***********************************************************************
* IntSendDestroyMsg
*/
}
Window->state2 |= WNDS2_INDESTROY;
Window->style &= ~WS_VISIBLE;
+ Window->head.pti->cVisWindows--;
IntNotifyWinEvent(EVENT_OBJECT_DESTROY, Window, OBJID_WINDOW, CHILDID_SELF, 0);
/* flush the message queue */
MsqRemoveWindowMessagesFromQueue(Window);
- NT_ASSERT(Window->head.pti);
- IntDereferenceMessageQueue(Window->head.pti->MessageQueue);
-
/* from now on no messages can be sent to this window anymore */
Window->state |= WNDS_DESTROYED;
Window->fnid |= FNID_FREED;
IntUnlinkWindow(Window);
+ if (Window->PropListItems)
+ {
+ IntRemoveWindowProp(Window);
+ TRACE("Window->PropListItems %d\n",Window->PropListItems);
+ ASSERT(Window->PropListItems==0);
+ }
+
UserReferenceObject(Window);
UserDeleteObject(Window->head.h, TYPE_WINDOW);
GreDeleteObject(Window->hrgnClip);
Window->hrgnClip = NULL;
}
+ Window->head.pti->cWindows--;
// ASSERT(Window != NULL);
UserFreeWindowInfo(Window->head.pti, Window);
Current = WThread->WindowListHead.Flink;
Wnd = CONTAINING_RECORD(Current, WND, ThreadListEntry);
- TRACE("thread cleanup: while destroy wnds, wnd=0x%x\n",Wnd);
+ TRACE("thread cleanup: while destroy wnds, wnd=%p\n", Wnd);
/* Window removes itself from the list */
UserRefObjectCo(Wnd, &Ref); // FIXME: Temp HACK??
if (!co_UserDestroyWindow(Wnd))
{
- ERR("Unable to destroy window 0x%x at thread cleanup... This is _VERY_ bad!\n", Wnd);
+ ERR("Unable to destroy window %p at thread cleanup... This is _VERY_ bad!\n", Wnd);
}
UserDerefObjectCo(Wnd); // FIXME: Temp HACK??
}
Wnd->head.pti == WndNewOwner->head.pti ||
WndOldOwner->head.pti != WndNewOwner->head.pti )
{
- ERR("ProcessOwnerSwap Old out.\n");
- //UserAttachThreadInput(Wnd->head.pti, WndOldOwner->head.pti, FALSE);
+ //ERR("ProcessOwnerSwap Old out.\n");
+ UserAttachThreadInput(Wnd->head.pti, WndOldOwner->head.pti, FALSE);
}
}
}
if (!WndOldOwner ||
WndOldOwner->head.pti != WndNewOwner->head.pti )
{
- ERR("ProcessOwnerSwap New in.\n");
- //UserAttachThreadInput(Wnd->head.pti, WndNewOwner->head.pti, TRUE);
+ //ERR("ProcessOwnerSwap New in.\n");
+ UserAttachThreadInput(Wnd->head.pti, WndNewOwner->head.pti, TRUE);
}
}
}
goto Error;
}
+ /* if parent belongs to a different thread and the window isn't */
+ /* top-level, attach the two threads */
IntProcessOwnerSwap(Wnd, WndNewOwner, WndOldOwner);
if (IntValidateOwnerDepth(Wnd, WndNewOwner))
/* Some applications try to set a child as a parent */
if (IntIsChildWindow(Wnd, WndNewParent))
{
+ TRACE("IntSetParent try to set a child as a parent.\n");
EngSetLastError( ERROR_INVALID_PARAMETER );
return NULL;
}
{
if (Wnd == pWndExam)
{
+ TRACE("IntSetParent Failed Test for set parent to parent!\n");
EngSetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
/* Window must belong to current process */
if (Wnd->head.pti->ppi != PsGetCurrentProcessWin32Process())
+ {
+ ERR("IntSetParent Window must belong to current process!\n");
return NULL;
+ }
WndOldParent = Wnd->spwndParent;
pt.x = Wnd->rcWindow.left;
pt.y = Wnd->rcWindow.top;
+ IntScreenToClient(WndOldParent, &pt);
+
if (WndOldParent) UserReferenceObject(WndOldParent); /* Caller must deref */
if (WndNewParent != WndOldParent)
}
+ if ( WndNewParent == co_GetDesktopWindow(Wnd) &&
+ !(Wnd->style & WS_CLIPSIBLINGS) )
+ {
+ Wnd->style |= WS_CLIPSIBLINGS;
+ DceResetActiveDCEs(Wnd);
+ }
+
+ /* if parent belongs to a different thread and the window isn't */
+ /* top-level, attach the two threads */
if ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
{
if ( Wnd->spwndParent != co_GetDesktopWindow(Wnd))
{
if (Wnd->head.pti != WndOldParent->head.pti)
{
- ERR("SetParent Old out.\n");
- //UserAttachThreadInput(Wnd->head.pti, WndOldParent->head.pti, FALSE);
+ //ERR("SetParent Old out.\n");
+ UserAttachThreadInput(Wnd->head.pti, WndOldParent->head.pti, FALSE);
}
}
if ( WndNewParent != co_GetDesktopWindow(Wnd))
{
if (Wnd->head.pti != WndNewParent->head.pti)
{
- ERR("SetParent New in.\n");
- //UserAttachThreadInput(Wnd->head.pti, WndNewParent->head.pti, TRUE);
+ //ERR("SetParent New in.\n");
+ UserAttachThreadInput(Wnd->head.pti, WndNewParent->head.pti, TRUE);
}
}
}
* in the z-order and send the expected WM_WINDOWPOSCHANGING and
* WM_WINDOWPOSCHANGED notification messages.
*/
+ //ERR("IntSetParent SetWindowPos 1\n");
co_WinPosSetWindowPos( Wnd,
(0 == (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOP : HWND_TOPMOST),
pt.x, pt.y, 0, 0, swFlags);
-
+ //ERR("IntSetParent SetWindowPos 2\n");
if (WasVisible) co_WinPosShowWindow(Wnd, SW_SHOWNORMAL);
return WndOldParent;
if (hWndChild == IntGetDesktopWindow())
{
+ ERR("UserSetParent Access Denied!\n");
EngSetLastError(ERROR_ACCESS_DENIED);
return( NULL);
}
{
if (!(WndParent = UserGetWindowObject(hWndNewParent)))
{
+ ERR("UserSetParent Bad New Parent!\n");
return( NULL);
}
}
if (!(Wnd = UserGetWindowObject(hWndChild)))
{
+ ERR("UserSetParent Bad Child!\n");
return( NULL);
}
goto AllocError;
}
- TRACE("Created window object with handle %X\n", hWnd);
+ TRACE("Created window object with handle %p\n", hWnd);
if (pdeskCreated && pdeskCreated->DesktopWindow == NULL )
{ /* HACK: Helper for win32csr/desktopbg.c */
pWnd->InternalPos.MaxPos.x = pWnd->InternalPos.MaxPos.y = -1;
pWnd->InternalPos.IconPos.x = pWnd->InternalPos.IconPos.y = -1;
- IntReferenceMessageQueue(pWnd->head.pti->MessageQueue);
if (pWnd->spwndParent != NULL && Cs->hwndParent != 0)
{
pWnd->HideFocus = pWnd->spwndParent->HideFocus;
pWnd->HideAccel = pWnd->spwndParent->HideAccel;
}
+ pWnd->head.pti->cWindows++;
+
+ if (Class->hIcon && !Class->hIconSm)
+ {
+ Class->hIconSmIntern = co_IntCopyImage( Class->hIcon, IMAGE_ICON,
+ UserGetSystemMetrics( SM_CXSMICON ),
+ UserGetSystemMetrics( SM_CYSMICON ), 0 );
+ TRACE("IntCreateWindow hIconSmIntern %p\n",Class->hIconSmIntern);
+ Class->CSF_flags |= CSF_CACHEDSMICON;
+ }
+
if (pWnd->pcls->CSF_flags & CSF_SERVERSIDEPROC)
pWnd->state |= WNDS_SERVERSIDEWINDOWPROC;
if (!CallProc)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
- ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %x\n",hWnd);
+ ERR("Warning: Unable to create CallProc for edit control. Control may not operate correctly! hwnd %p\n", hWnd);
}
else
{
Class->atomClassName != gpsi->atomSysClass[ICLS_IME] &&
pti != pWnd->spwndOwner->head.pti)
{
- ERR("CreateWindow Owner in.\n");
- //UserAttachThreadInput(pti, pWnd->spwndOwner->head.pti, TRUE);
+ //ERR("CreateWindow Owner in.\n");
+ UserAttachThreadInput(pti, pWnd->spwndOwner->head.pti, TRUE);
}
}
}
/* Now find the parent and the owner window */
- hWndParent = IntGetDesktopWindow();
+ hWndParent = pti->rpdesk->pDeskInfo->spwnd->head.h;
hWndOwner = NULL;
if (Cs->hwndParent == HWND_MESSAGE)
{
- Cs->hwndParent = hWndParent = IntGetMessageWindow();
+ Cs->hwndParent = hWndParent = pti->rpdesk->spwndMessage->head.h;
}
else if (Cs->hwndParent)
{
Cs->lpszName = (LPCWSTR) WindowName;
Cs->lpszClass = (LPCWSTR) ClassName;
+ if ((Cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
+ {
+ if (ParentWindow != co_GetDesktopWindow(Window))
+ {
+ Cs->x += ParentWindow->rcClient.left;
+ Cs->y += ParentWindow->rcClient.top;
+ }
+ }
+
/* Send the WM_GETMINMAXINFO message */
Size.cx = Cs->cx;
Size.cy = Cs->cy;
Window->rcWindow.top = Cs->y;
Window->rcWindow.right = Cs->x + Size.cx;
Window->rcWindow.bottom = Cs->y + Size.cy;
+/*
if (0 != (Window->style & WS_CHILD) && ParentWindow)
{
// ERR("co_UserCreateWindowEx(): Offset rcWindow\n");
ParentWindow->rcClient.left,
ParentWindow->rcClient.top);
}
+*/
Window->rcClient = Window->rcWindow;
/* Link the window */
IntLinkHwnd(Window, hwndInsertAfter);
}
+ if (!(Window->state2 & WNDS2_WIN31COMPAT))
+ {
+ if (Class->style & CS_PARENTDC && !(ParentWindow->style & WS_CLIPCHILDREN))
+ Window->style &= ~(WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
+ }
+
if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
{
if ( !IntIsTopLevelWindow(Window) )
{
if (pti != Window->spwndParent->head.pti)
{
- ERR("CreateWindow Parent in.\n");
- //UserAttachThreadInput(pti, Window->spwndParent->head.pti, TRUE);
+ //ERR("CreateWindow Parent in.\n");
+ UserAttachThreadInput(pti, Window->spwndParent->head.pti, TRUE);
}
}
}
}
/* Send the WM_NCCALCSIZE message */
+ {
+ // RECT rc;
MaxPos.x = Window->rcWindow.left;
MaxPos.y = Window->rcWindow.top;
Result = co_WinPosGetNonClientSize(Window, &Window->rcWindow, &Window->rcClient);
+ //rc = Window->rcWindow;
+ //Result = co_IntSendMessageNoWait(Window->head.h, WM_NCCALCSIZE, FALSE, (LPARAM)&rc);
+ //Window->rcClient = rc;
RECTL_vOffsetRect(&Window->rcWindow, MaxPos.x - Window->rcWindow.left,
MaxPos.y - Window->rcWindow.top);
-
+ }
/* Send the WM_CREATE message. */
Result = co_IntSendMessage(UserHMGetHandle(Window), WM_CREATE, 0, (LPARAM) Cs);
}
}
- TRACE("co_UserCreateWindowEx(): Created window %X\n", hWnd);
+ TRACE("co_UserCreateWindowEx(): Created window %p\n", hWnd);
ret = Window;
cleanup:
{
if (Window->spwndOwner)
{
- ERR("DestroyWindow Owner out.\n");
- //UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE);
+ //ERR("DestroyWindow Owner out.\n");
+ UserAttachThreadInput(Window->head.pti, Window->spwndOwner->head.pti, FALSE);
}
}
}
{
if (!IntIsTopLevelWindow(Window))
{
- ERR("DestroyWindow Parent out.\n");
- //UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE);
+ //ERR("DestroyWindow Parent out.\n");
+ UserAttachThreadInput(Window->head.pti, Window->spwndParent->head.pti, FALSE);
}
}
}
RETURN(ret);
CLEANUP:
- TRACE("Leave NtUserDestroyWindow, ret=%i\n",_ret_);
+ TRACE("Leave NtUserDestroyWindow, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Ret);
CLEANUP:
- TRACE("Leave NtUserFindWindowEx, ret %i\n",_ret_);
+ TRACE("Leave NtUserFindWindowEx, ret %p\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN(Ancestor ? Ancestor->head.h : NULL);
CLEANUP:
- TRACE("Leave NtUserGetAncestor, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetAncestor, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( (DWORD) co_IntSendMessage( Wnd->head.h, LB_GETLISTBOXINFO, 0, 0 ));
CLEANUP:
- TRACE("Leave NtUserGetListBoxInfo, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetListBoxInfo, ret=%lu\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( co_UserSetParent(hWndChild, hWndNewParent));
CLEANUP:
- TRACE("Leave NtUserSetParent, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetParent, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
}
UserRefObjectCo(WndShell, &Ref);
+ WndShell->state2 |= WNDS2_BOTTOMMOST;
co_WinPosSetWindowPos(WndShell, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
WinStaObject->ShellWindow = hwndShell;
if (ti->pDeskInfo)
{
ti->pDeskInfo->hShellWindow = hwndShell;
+ ti->pDeskInfo->spwndShell = WndShell;
ti->pDeskInfo->ppiShellProcess = ti->ppi;
}
+ UserRegisterHotKey(WndShell, SC_TASKLIST, MOD_CONTROL, VK_ESCAPE);
+
UserDerefObjectCo(WndShell);
ObDereferenceObject(WinStaObject);
RETURN(Menu->MenuInfo.Self);
CLEANUP:
- TRACE("Leave NtUserGetSystemMenu, ret=%i\n",_ret_);
+ TRACE("Leave NtUserGetSystemMenu, ret=%p\n", _ret_);
UserLeave();
END_CLEANUP;
}
else
Window->ExStyle &= ~WS_EX_WINDOWEDGE;
+ if ((Style.styleOld ^ Style.styleNew) & WS_VISIBLE)
+ {
+ if (Style.styleOld & WS_VISIBLE) Window->head.pti->cVisWindows--;
+ if (Style.styleNew & WS_VISIBLE) Window->head.pti->cVisWindows++;
+ DceResetActiveDCEs( Window );
+ }
Window->style = (DWORD)Style.styleNew;
co_IntSendMessage(hWnd, WM_STYLECHANGED, GWL_STYLE, (LPARAM) &Style);
break;
break;
default:
- ERR("NtUserSetWindowLong(): Unsupported index %d\n", Index);
+ ERR("NtUserSetWindowLong(): Unsupported index %lu\n", Index);
EngSetLastError(ERROR_INVALID_INDEX);
OldValue = 0;
break;
RETURN( OldValue);
CLEANUP:
- TRACE("Leave NtUserSetWindowWord, ret=%i\n",_ret_);
+ TRACE("Leave NtUserSetWindowWord, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
DWORD APIENTRY
NtUserQueryWindow(HWND hWnd, DWORD Index)
{
+/* Console Leader Process CID Window offsets */
+#define GWLP_CONSOLE_LEADER_PID 0
+#define GWLP_CONSOLE_LEADER_TID 4
+
PWND pWnd;
DWORD Result;
DECLARE_RETURN(UINT);
switch(Index)
{
case QUERY_WINDOW_UNIQUE_PROCESS_ID:
- Result = (DWORD)IntGetWndProcessId(pWnd);
+ {
+ if ( (pWnd->head.pti->TIF_flags & TIF_CSRSSTHREAD) &&
+ (pWnd->pcls->atomClassName == gaGuiConsoleWndClass) )
+ {
+ // IntGetWindowLong(offset == GWLP_CONSOLE_LEADER_PID)
+ Result = (DWORD)(*((LONG_PTR*)((PCHAR)(pWnd + 1) + GWLP_CONSOLE_LEADER_PID)));
+ }
+ else
+ {
+ Result = (DWORD)IntGetWndProcessId(pWnd);
+ }
break;
+ }
case QUERY_WINDOW_UNIQUE_THREAD_ID:
- Result = (DWORD)IntGetWndThreadId(pWnd);
+ {
+ if ( (pWnd->head.pti->TIF_flags & TIF_CSRSSTHREAD) &&
+ (pWnd->pcls->atomClassName == gaGuiConsoleWndClass) )
+ {
+ // IntGetWindowLong(offset == GWLP_CONSOLE_LEADER_TID)
+ Result = (DWORD)(*((LONG_PTR*)((PCHAR)(pWnd + 1) + GWLP_CONSOLE_LEADER_TID)));
+ }
+ else
+ {
+ Result = (DWORD)IntGetWndThreadId(pWnd);
+ }
break;
+ }
case QUERY_WINDOW_ACTIVE:
Result = (DWORD)(pWnd->head.pti->MessageQueue->spwndActive ? UserHMGetHandle(pWnd->head.pti->MessageQueue->spwndActive) : 0);
break;
case QUERY_WINDOW_ISHUNG:
- Result = (DWORD)MsqIsHung(pWnd->head.pti->MessageQueue);
+ Result = (DWORD)MsqIsHung(pWnd->head.pti);
break;
case QUERY_WINDOW_REAL_ID:
RETURN( Result);
CLEANUP:
- TRACE("Leave NtUserQueryWindow, ret=%i\n",_ret_);
+ TRACE("Leave NtUserQueryWindow, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
RETURN( Ret);
CLEANUP:
- TRACE("Leave NtUserRegisterWindowMessage, ret=%i\n",_ret_);
+ TRACE("Leave NtUserRegisterWindowMessage, ret=%u\n", _ret_);
UserLeave();
END_CLEANUP;
}
projects / reactos.git / blobdiff