5061 lines
159 KiB
C
5061 lines
159 KiB
C
/*
|
|
* Window related functions
|
|
*
|
|
* Copyright 1993, 1994 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
|
|
#if 0
|
|
#pragma makedep unix
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "ntgdi_private.h"
|
|
#include "ntuser_private.h"
|
|
#include "wine/server.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(win);
|
|
|
|
#define NB_USER_HANDLES ((LAST_USER_HANDLE - FIRST_USER_HANDLE + 1) >> 1)
|
|
#define USER_HANDLE_TO_INDEX(hwnd) ((LOWORD(hwnd) - FIRST_USER_HANDLE) >> 1)
|
|
|
|
static void *user_handles[NB_USER_HANDLES];
|
|
|
|
#define SWP_AGG_NOGEOMETRYCHANGE \
|
|
(SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
|
|
#define SWP_AGG_NOPOSCHANGE \
|
|
(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)
|
|
|
|
/***********************************************************************
|
|
* alloc_user_handle
|
|
*/
|
|
HANDLE alloc_user_handle( struct user_object *ptr, unsigned int type )
|
|
{
|
|
HANDLE handle = 0;
|
|
|
|
SERVER_START_REQ( alloc_user_handle )
|
|
{
|
|
if (!wine_server_call_err( req )) handle = wine_server_ptr_handle( reply->handle );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (handle)
|
|
{
|
|
UINT index = USER_HANDLE_TO_INDEX( handle );
|
|
|
|
assert( index < NB_USER_HANDLES );
|
|
ptr->handle = handle;
|
|
ptr->type = type;
|
|
InterlockedExchangePointer( &user_handles[index], ptr );
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_user_handle_ptr
|
|
*/
|
|
void *get_user_handle_ptr( HANDLE handle, unsigned int type )
|
|
{
|
|
struct user_object *ptr;
|
|
WORD index = USER_HANDLE_TO_INDEX( handle );
|
|
|
|
if (index >= NB_USER_HANDLES) return NULL;
|
|
|
|
user_lock();
|
|
if ((ptr = user_handles[index]))
|
|
{
|
|
if (ptr->type == type &&
|
|
((UINT)(UINT_PTR)ptr->handle == (UINT)(UINT_PTR)handle ||
|
|
!HIWORD(handle) || HIWORD(handle) == 0xffff))
|
|
return ptr;
|
|
ptr = NULL;
|
|
}
|
|
else ptr = OBJ_OTHER_PROCESS;
|
|
user_unlock();
|
|
return ptr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* set_user_handle_ptr
|
|
*/
|
|
static void set_user_handle_ptr( HANDLE handle, struct user_object *ptr )
|
|
{
|
|
WORD index = USER_HANDLE_TO_INDEX(handle);
|
|
assert( index < NB_USER_HANDLES );
|
|
InterlockedExchangePointer( &user_handles[index], ptr );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* release_user_handle_ptr
|
|
*/
|
|
void release_user_handle_ptr( void *ptr )
|
|
{
|
|
assert( ptr && ptr != OBJ_OTHER_PROCESS );
|
|
user_unlock();
|
|
}
|
|
|
|
/***********************************************************************
|
|
* free_user_handle
|
|
*/
|
|
void *free_user_handle( HANDLE handle, unsigned int type )
|
|
{
|
|
struct user_object *ptr;
|
|
WORD index = USER_HANDLE_TO_INDEX( handle );
|
|
|
|
if ((ptr = get_user_handle_ptr( handle, type )) && ptr != OBJ_OTHER_PROCESS)
|
|
{
|
|
SERVER_START_REQ( free_user_handle )
|
|
{
|
|
req->handle = wine_server_user_handle( handle );
|
|
if (wine_server_call( req )) ptr = NULL;
|
|
else InterlockedCompareExchangePointer( &user_handles[index], NULL, ptr );
|
|
}
|
|
SERVER_END_REQ;
|
|
user_unlock();
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* next_thread_window
|
|
*/
|
|
static WND *next_thread_window_ptr( HWND *hwnd )
|
|
{
|
|
struct user_object *ptr;
|
|
WND *win;
|
|
WORD index = *hwnd ? USER_HANDLE_TO_INDEX( *hwnd ) + 1 : 0;
|
|
|
|
while (index < NB_USER_HANDLES)
|
|
{
|
|
if (!(ptr = user_handles[index++])) continue;
|
|
if (ptr->type != NTUSER_OBJ_WINDOW) continue;
|
|
win = (WND *)ptr;
|
|
if (win->tid != GetCurrentThreadId()) continue;
|
|
*hwnd = ptr->handle;
|
|
return win;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* get_hwnd_message_parent
|
|
*
|
|
* Return the parent for HWND_MESSAGE windows.
|
|
*/
|
|
HWND get_hwnd_message_parent(void)
|
|
{
|
|
struct user_thread_info *thread_info = get_user_thread_info();
|
|
|
|
if (!thread_info->msg_window) get_desktop_window(); /* trigger creation */
|
|
return thread_info->msg_window;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_full_window_handle
|
|
*
|
|
* Convert a possibly truncated window handle to a full 32-bit handle.
|
|
*/
|
|
HWND get_full_window_handle( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
|
|
if (!hwnd || (ULONG_PTR)hwnd >> 16) return hwnd;
|
|
if (LOWORD(hwnd) <= 1 || LOWORD(hwnd) == 0xffff) return hwnd;
|
|
/* do sign extension for -2 and -3 */
|
|
if (LOWORD(hwnd) >= (WORD)-3) return (HWND)(LONG_PTR)(INT16)LOWORD(hwnd);
|
|
|
|
if (!(win = get_win_ptr( hwnd ))) return hwnd;
|
|
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
if (LOWORD(hwnd) == LOWORD(get_desktop_window())) return get_desktop_window();
|
|
else return get_hwnd_message_parent();
|
|
}
|
|
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
hwnd = win->obj.handle;
|
|
release_win_ptr( win );
|
|
}
|
|
else /* may belong to another process */
|
|
{
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req )) hwnd = wine_server_ptr_handle( reply->full_handle );
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
return hwnd;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* is_desktop_window
|
|
*
|
|
* Check if window is the desktop or the HWND_MESSAGE top parent.
|
|
*/
|
|
BOOL is_desktop_window( HWND hwnd )
|
|
{
|
|
struct user_thread_info *thread_info = get_user_thread_info();
|
|
|
|
if (!hwnd) return FALSE;
|
|
if (hwnd == thread_info->top_window) return TRUE;
|
|
if (hwnd == thread_info->msg_window) return TRUE;
|
|
|
|
if (!HIWORD(hwnd) || HIWORD(hwnd) == 0xffff)
|
|
{
|
|
if (LOWORD(thread_info->top_window) == LOWORD(hwnd)) return TRUE;
|
|
if (LOWORD(thread_info->msg_window) == LOWORD(hwnd)) return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* win_get_ptr
|
|
*
|
|
* Return a pointer to the WND structure if local to the process,
|
|
* or WND_OTHER_PROCESS if handle may be valid in other process.
|
|
* If ret value is a valid pointer, it must be released with WIN_ReleasePtr.
|
|
*/
|
|
WND *get_win_ptr( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
|
|
if ((win = get_user_handle_ptr( hwnd, NTUSER_OBJ_WINDOW )) == WND_OTHER_PROCESS)
|
|
{
|
|
if (is_desktop_window( hwnd )) win = WND_DESKTOP;
|
|
}
|
|
return win;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* is_current_thread_window
|
|
*
|
|
* Check whether a given window belongs to the current process (and return the full handle).
|
|
*/
|
|
HWND is_current_thread_window( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
HWND ret = 0;
|
|
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_OTHER_PROCESS || win == WND_DESKTOP)
|
|
return 0;
|
|
if (win->tid == GetCurrentThreadId()) ret = win->obj.handle;
|
|
release_win_ptr( win );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* is_current_process_window
|
|
*
|
|
* Check whether a given window belongs to the current process (and return the full handle).
|
|
*/
|
|
HWND is_current_process_window( HWND hwnd )
|
|
{
|
|
WND *ptr;
|
|
HWND ret;
|
|
|
|
if (!(ptr = get_win_ptr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
|
|
ret = ptr->obj.handle;
|
|
release_win_ptr( ptr );
|
|
return ret;
|
|
}
|
|
|
|
/* see IsWindow */
|
|
BOOL is_window( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
BOOL ret;
|
|
|
|
if (!(win = get_win_ptr( hwnd ))) return FALSE;
|
|
if (win == WND_DESKTOP) return TRUE;
|
|
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
release_win_ptr( win );
|
|
return TRUE;
|
|
}
|
|
|
|
/* check other processes */
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
/* see GetWindowThreadProcessId */
|
|
DWORD get_window_thread( HWND hwnd, DWORD *process )
|
|
{
|
|
WND *ptr;
|
|
DWORD tid = 0;
|
|
|
|
if (!(ptr = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE);
|
|
return 0;
|
|
}
|
|
|
|
if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP)
|
|
{
|
|
/* got a valid window */
|
|
tid = ptr->tid;
|
|
if (process) *process = GetCurrentProcessId();
|
|
release_win_ptr( ptr );
|
|
return tid;
|
|
}
|
|
|
|
/* check other processes */
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
tid = (DWORD)reply->tid;
|
|
if (process) *process = (DWORD)reply->pid;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return tid;
|
|
}
|
|
|
|
/* see GetParent */
|
|
static HWND get_parent( HWND hwnd )
|
|
{
|
|
HWND retval = 0;
|
|
WND *win;
|
|
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP) return 0;
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
LONG style = get_window_long( hwnd, GWL_STYLE );
|
|
if (style & (WS_POPUP | WS_CHILD))
|
|
{
|
|
SERVER_START_REQ( get_window_tree )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
if (style & WS_POPUP) retval = wine_server_ptr_handle( reply->owner );
|
|
else if (style & WS_CHILD) retval = wine_server_ptr_handle( reply->parent );
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (win->dwStyle & WS_POPUP) retval = win->owner;
|
|
else if (win->dwStyle & WS_CHILD) retval = win->parent;
|
|
release_win_ptr( win );
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/*****************************************************************
|
|
* NtUserSetParent (win32u.@)
|
|
*/
|
|
HWND WINAPI NtUserSetParent( HWND hwnd, HWND parent )
|
|
{
|
|
RECT window_rect, old_screen_rect, new_screen_rect;
|
|
DPI_AWARENESS_CONTEXT context;
|
|
WINDOWPOS winpos;
|
|
HWND full_handle;
|
|
HWND old_parent = 0;
|
|
BOOL was_visible;
|
|
WND *win;
|
|
BOOL ret;
|
|
|
|
TRACE("(%p %p)\n", hwnd, parent);
|
|
|
|
if (is_broadcast(hwnd) || is_broadcast(parent))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
|
|
if (!parent) parent = get_desktop_window();
|
|
else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent();
|
|
else parent = get_full_window_handle( parent );
|
|
|
|
if (!is_window( parent ))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
|
|
/* Some applications try to set a child as a parent */
|
|
if (is_child( hwnd, parent ))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
|
|
if (!(full_handle = is_current_thread_window( hwnd )))
|
|
return UlongToHandle( send_message( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 ));
|
|
|
|
if (full_handle == parent)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
|
|
/* Windows hides the window first, then shows it again
|
|
* including the WM_SHOWWINDOW messages and all */
|
|
was_visible = NtUserShowWindow( hwnd, SW_HIDE );
|
|
|
|
win = get_win_ptr( hwnd );
|
|
if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) return 0;
|
|
|
|
get_window_rects( hwnd, COORDS_PARENT, &window_rect, NULL, get_dpi_for_window(hwnd) );
|
|
get_window_rects( hwnd, COORDS_SCREEN, &old_screen_rect, NULL, 0 );
|
|
|
|
SERVER_START_REQ( set_parent )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->parent = wine_server_user_handle( parent );
|
|
if ((ret = !wine_server_call_err( req )))
|
|
{
|
|
old_parent = wine_server_ptr_handle( reply->old_parent );
|
|
win->parent = parent = wine_server_ptr_handle( reply->full_parent );
|
|
win->dpi = reply->dpi;
|
|
win->dpi_awareness = reply->awareness;
|
|
}
|
|
|
|
}
|
|
SERVER_END_REQ;
|
|
release_win_ptr( win );
|
|
if (!ret) return 0;
|
|
|
|
get_window_rects( hwnd, COORDS_SCREEN, &new_screen_rect, NULL, 0 );
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( hwnd ));
|
|
|
|
user_driver->pSetParent( full_handle, parent, old_parent );
|
|
|
|
winpos.hwnd = hwnd;
|
|
winpos.hwndInsertAfter = HWND_TOP;
|
|
winpos.x = window_rect.left;
|
|
winpos.y = window_rect.top;
|
|
winpos.cx = 0;
|
|
winpos.cy = 0;
|
|
winpos.flags = SWP_NOSIZE;
|
|
|
|
set_window_pos( &winpos, new_screen_rect.left - old_screen_rect.left,
|
|
new_screen_rect.top - old_screen_rect.top );
|
|
|
|
if (was_visible) NtUserShowWindow( hwnd, SW_SHOW );
|
|
|
|
set_thread_dpi_awareness_context( context );
|
|
return old_parent;
|
|
}
|
|
|
|
/* see GetWindow */
|
|
static HWND get_window_relative( HWND hwnd, UINT rel )
|
|
{
|
|
HWND retval = 0;
|
|
|
|
if (rel == GW_OWNER) /* this one may be available locally */
|
|
{
|
|
WND *win = get_win_ptr( hwnd );
|
|
if (!win)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP) return 0;
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
retval = win->owner;
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
/* else fall through to server call */
|
|
}
|
|
|
|
SERVER_START_REQ( get_window_tree )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
switch(rel)
|
|
{
|
|
case GW_HWNDFIRST:
|
|
retval = wine_server_ptr_handle( reply->first_sibling );
|
|
break;
|
|
case GW_HWNDLAST:
|
|
retval = wine_server_ptr_handle( reply->last_sibling );
|
|
break;
|
|
case GW_HWNDNEXT:
|
|
retval = wine_server_ptr_handle( reply->next_sibling );
|
|
break;
|
|
case GW_HWNDPREV:
|
|
retval = wine_server_ptr_handle( reply->prev_sibling );
|
|
break;
|
|
case GW_OWNER:
|
|
retval = wine_server_ptr_handle( reply->owner );
|
|
break;
|
|
case GW_CHILD:
|
|
retval = wine_server_ptr_handle( reply->first_child );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return retval;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* list_window_parents
|
|
*
|
|
* Build an array of all parents of a given window, starting with
|
|
* the immediate parent. The array must be freed with free().
|
|
*/
|
|
static HWND *list_window_parents( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
HWND current, *list;
|
|
int i, pos = 0, size = 16, count;
|
|
|
|
if (!(list = malloc( size * sizeof(HWND) ))) return NULL;
|
|
|
|
current = hwnd;
|
|
for (;;)
|
|
{
|
|
if (!(win = get_win_ptr( current ))) goto empty;
|
|
if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
if (!pos) goto empty;
|
|
list[pos] = 0;
|
|
return list;
|
|
}
|
|
list[pos] = current = win->parent;
|
|
release_win_ptr( win );
|
|
if (!current) return list;
|
|
if (++pos == size - 1)
|
|
{
|
|
/* need to grow the list */
|
|
HWND *new_list = realloc( list, (size + 16) * sizeof(HWND) );
|
|
if (!new_list) goto empty;
|
|
list = new_list;
|
|
size += 16;
|
|
}
|
|
}
|
|
|
|
/* at least one parent belongs to another process, have to query the server */
|
|
|
|
for (;;)
|
|
{
|
|
count = 0;
|
|
SERVER_START_REQ( get_window_parents )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
|
|
if (!wine_server_call( req )) count = reply->count;
|
|
}
|
|
SERVER_END_REQ;
|
|
if (!count) goto empty;
|
|
if (size > count)
|
|
{
|
|
/* start from the end since HWND is potentially larger than user_handle_t */
|
|
for (i = count - 1; i >= 0; i--)
|
|
list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
|
|
list[count] = 0;
|
|
return list;
|
|
}
|
|
free( list );
|
|
size = count + 1;
|
|
if (!(list = malloc( size * sizeof(HWND) ))) return NULL;
|
|
}
|
|
|
|
empty:
|
|
free( list );
|
|
return NULL;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* list_window_children
|
|
*
|
|
* Build an array of the children of a given window. The array must be
|
|
* freed with HeapFree. Returns NULL when no windows are found.
|
|
*/
|
|
HWND *list_window_children( HDESK desktop, HWND hwnd, UNICODE_STRING *class, DWORD tid )
|
|
{
|
|
HWND *list;
|
|
int i, size = 128;
|
|
ATOM atom = class ? get_int_atom_value( class ) : 0;
|
|
|
|
/* empty class is not the same as NULL class */
|
|
if (!atom && class && !class->Length) return NULL;
|
|
|
|
for (;;)
|
|
{
|
|
int count = 0;
|
|
|
|
if (!(list = malloc( size * sizeof(HWND) ))) break;
|
|
|
|
SERVER_START_REQ( get_window_children )
|
|
{
|
|
req->desktop = wine_server_obj_handle( desktop );
|
|
req->parent = wine_server_user_handle( hwnd );
|
|
req->tid = tid;
|
|
req->atom = atom;
|
|
if (!atom && class) wine_server_add_data( req, class->Buffer, class->Length );
|
|
wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
|
|
if (!wine_server_call( req )) count = reply->count;
|
|
}
|
|
SERVER_END_REQ;
|
|
if (count && count < size)
|
|
{
|
|
/* start from the end since HWND is potentially larger than user_handle_t */
|
|
for (i = count - 1; i >= 0; i--)
|
|
list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
|
|
list[count] = 0;
|
|
return list;
|
|
}
|
|
free( list );
|
|
if (!count) break;
|
|
size = count + 1; /* restart with a large enough buffer */
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************
|
|
* NtUserGetAncestor (win32u.@)
|
|
*/
|
|
HWND WINAPI NtUserGetAncestor( HWND hwnd, UINT type )
|
|
{
|
|
HWND *list, ret = 0;
|
|
WND *win;
|
|
|
|
switch(type)
|
|
{
|
|
case GA_PARENT:
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP) return 0;
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
ret = win->parent;
|
|
release_win_ptr( win );
|
|
}
|
|
else /* need to query the server */
|
|
{
|
|
SERVER_START_REQ( get_window_tree )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->parent );
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
break;
|
|
|
|
case GA_ROOT:
|
|
if (!(list = list_window_parents( hwnd ))) return 0;
|
|
|
|
if (!list[0] || !list[1]) ret = get_full_window_handle( hwnd ); /* top-level window */
|
|
else
|
|
{
|
|
int count = 2;
|
|
while (list[count]) count++;
|
|
ret = list[count - 2]; /* get the one before the desktop */
|
|
}
|
|
free( list );
|
|
break;
|
|
|
|
case GA_ROOTOWNER:
|
|
if (is_desktop_window( hwnd )) return 0;
|
|
ret = get_full_window_handle( hwnd );
|
|
for (;;)
|
|
{
|
|
HWND parent = get_parent( ret );
|
|
if (!parent) break;
|
|
ret = parent;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* see IsChild */
|
|
BOOL is_child( HWND parent, HWND child )
|
|
{
|
|
HWND *list;
|
|
int i;
|
|
BOOL ret = FALSE;
|
|
|
|
if (!(get_window_long( child, GWL_STYLE ) & WS_CHILD)) return FALSE;
|
|
if (!(list = list_window_parents( child ))) return FALSE;
|
|
parent = get_full_window_handle( parent );
|
|
for (i = 0; list[i]; i++)
|
|
{
|
|
if (list[i] == parent)
|
|
{
|
|
ret = list[i] && list[i+1];
|
|
break;
|
|
}
|
|
if (!(get_window_long( list[i], GWL_STYLE ) & WS_CHILD)) break;
|
|
}
|
|
free( list );
|
|
return ret;
|
|
}
|
|
|
|
/* see IsWindowVisible */
|
|
static BOOL is_window_visible( HWND hwnd )
|
|
{
|
|
HWND *list;
|
|
BOOL retval = TRUE;
|
|
int i;
|
|
|
|
if (!(get_window_long( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
|
|
if (!(list = list_window_parents( hwnd ))) return TRUE;
|
|
if (list[0])
|
|
{
|
|
for (i = 0; list[i+1]; i++)
|
|
if (!(get_window_long( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
|
|
retval = !list[i+1] && (list[i] == get_desktop_window()); /* top message window isn't visible */
|
|
}
|
|
free( list );
|
|
return retval;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* is_window_drawable
|
|
*
|
|
* hwnd is drawable when it is visible, all parents are not
|
|
* minimized, and it is itself not minimized unless we are
|
|
* trying to draw its default class icon.
|
|
*/
|
|
static BOOL is_window_drawable( HWND hwnd, BOOL icon )
|
|
{
|
|
HWND *list;
|
|
BOOL retval = TRUE;
|
|
int i;
|
|
LONG style = get_window_long( hwnd, GWL_STYLE );
|
|
|
|
if (!(style & WS_VISIBLE)) return FALSE;
|
|
if ((style & WS_MINIMIZE) && icon && get_class_long_ptr( hwnd, GCLP_HICON, FALSE )) return FALSE;
|
|
|
|
if (!(list = list_window_parents( hwnd ))) return TRUE;
|
|
if (list[0])
|
|
{
|
|
for (i = 0; list[i+1]; i++)
|
|
if ((get_window_long( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
|
|
break;
|
|
retval = !list[i+1] && (list[i] == get_desktop_window()); /* top message window isn't visible */
|
|
}
|
|
free( list );
|
|
return retval;
|
|
}
|
|
|
|
/* see IsWindowUnicode */
|
|
BOOL is_window_unicode( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
BOOL ret = FALSE;
|
|
|
|
if (!(win = get_win_ptr(hwnd))) return FALSE;
|
|
|
|
if (win == WND_DESKTOP) return TRUE;
|
|
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
ret = (win->flags & WIN_ISUNICODE) != 0;
|
|
release_win_ptr( win );
|
|
}
|
|
else
|
|
{
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req )) ret = reply->is_unicode;
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* see GetWindowDpiAwarenessContext */
|
|
DPI_AWARENESS_CONTEXT get_window_dpi_awareness_context( HWND hwnd )
|
|
{
|
|
DPI_AWARENESS_CONTEXT ret = 0;
|
|
WND *win;
|
|
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP) return DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE;
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
ret = ULongToHandle( win->dpi_awareness | 0x10 );
|
|
release_win_ptr( win );
|
|
}
|
|
else
|
|
{
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req )) ret = ULongToHandle( reply->awareness | 0x10 );
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* see GetDpiForWindow */
|
|
UINT get_dpi_for_window( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
UINT ret = 0;
|
|
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
POINT pt = { 0, 0 };
|
|
return get_monitor_dpi( monitor_from_point( pt, MONITOR_DEFAULTTOPRIMARY, 0 ));
|
|
}
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
ret = win->dpi;
|
|
if (!ret) ret = get_win_monitor_dpi( hwnd );
|
|
release_win_ptr( win );
|
|
}
|
|
else
|
|
{
|
|
SERVER_START_REQ( get_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (!wine_server_call_err( req )) ret = reply->dpi;
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LONG_PTR get_win_data( const void *ptr, UINT size )
|
|
{
|
|
if (size == sizeof(WORD))
|
|
{
|
|
WORD ret;
|
|
memcpy( &ret, ptr, sizeof(ret) );
|
|
return ret;
|
|
}
|
|
else if (size == sizeof(DWORD))
|
|
{
|
|
DWORD ret;
|
|
memcpy( &ret, ptr, sizeof(ret) );
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
LONG_PTR ret;
|
|
memcpy( &ret, ptr, sizeof(ret) );
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* helper for set_window_long */
|
|
static inline void set_win_data( void *ptr, LONG_PTR val, UINT size )
|
|
{
|
|
if (size == sizeof(WORD))
|
|
{
|
|
WORD newval = val;
|
|
memcpy( ptr, &newval, sizeof(newval) );
|
|
}
|
|
else if (size == sizeof(DWORD))
|
|
{
|
|
DWORD newval = val;
|
|
memcpy( ptr, &newval, sizeof(newval) );
|
|
}
|
|
else
|
|
{
|
|
memcpy( ptr, &val, sizeof(val) );
|
|
}
|
|
}
|
|
|
|
BOOL is_iconic( HWND hwnd )
|
|
{
|
|
return (get_window_long( hwnd, GWL_STYLE ) & WS_MINIMIZE) != 0;
|
|
}
|
|
|
|
static BOOL is_zoomed( HWND hwnd )
|
|
{
|
|
return (get_window_long( hwnd, GWL_STYLE ) & WS_MAXIMIZE) != 0;
|
|
}
|
|
|
|
static LONG_PTR get_window_long_size( HWND hwnd, INT offset, UINT size, BOOL ansi )
|
|
{
|
|
LONG_PTR retval = 0;
|
|
WND *win;
|
|
|
|
if (offset == GWLP_HWNDPARENT)
|
|
{
|
|
HWND parent = NtUserGetAncestor( hwnd, GA_PARENT );
|
|
if (parent == get_desktop_window())
|
|
parent = get_window_relative( hwnd, GW_OWNER );
|
|
return (ULONG_PTR)parent;
|
|
}
|
|
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
switch (offset)
|
|
{
|
|
case GWL_STYLE:
|
|
retval = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; /* message parent is not visible */
|
|
if (get_full_window_handle( hwnd ) == get_desktop_window())
|
|
retval |= WS_VISIBLE;
|
|
return retval;
|
|
case GWL_EXSTYLE:
|
|
case GWLP_USERDATA:
|
|
case GWLP_ID:
|
|
case GWLP_HINSTANCE:
|
|
return 0;
|
|
case GWLP_WNDPROC:
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return 0;
|
|
}
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
if (offset == GWLP_WNDPROC)
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return 0;
|
|
}
|
|
SERVER_START_REQ( set_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->flags = 0; /* don't set anything, just retrieve */
|
|
req->extra_offset = (offset >= 0) ? offset : -1;
|
|
req->extra_size = (offset >= 0) ? size : 0;
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
switch(offset)
|
|
{
|
|
case GWL_STYLE: retval = reply->old_style; break;
|
|
case GWL_EXSTYLE: retval = reply->old_ex_style; break;
|
|
case GWLP_ID: retval = reply->old_id; break;
|
|
case GWLP_HINSTANCE: retval = (ULONG_PTR)wine_server_get_ptr( reply->old_instance ); break;
|
|
case GWLP_USERDATA: retval = reply->old_user_data; break;
|
|
default:
|
|
if (offset >= 0) retval = get_win_data( &reply->old_extra_value, size );
|
|
else SetLastError( ERROR_INVALID_INDEX );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return retval;
|
|
}
|
|
|
|
/* now we have a valid win */
|
|
|
|
if (offset >= 0)
|
|
{
|
|
if (offset > (int)(win->cbWndExtra - size))
|
|
{
|
|
WARN("Invalid offset %d\n", offset );
|
|
release_win_ptr( win );
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
retval = get_win_data( (char *)win->wExtra + offset, size );
|
|
|
|
/* Special case for dialog window procedure */
|
|
if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && win->dlgInfo)
|
|
retval = (LONG_PTR)get_winproc( (WNDPROC)retval, ansi );
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
|
|
switch(offset)
|
|
{
|
|
case GWLP_USERDATA: retval = win->userdata; break;
|
|
case GWL_STYLE: retval = win->dwStyle; break;
|
|
case GWL_EXSTYLE: retval = win->dwExStyle; break;
|
|
case GWLP_ID: retval = win->wIDmenu; break;
|
|
case GWLP_HINSTANCE: retval = (ULONG_PTR)win->hInstance; break;
|
|
case GWLP_WNDPROC:
|
|
/* This looks like a hack only for the edit control (see tests). This makes these controls
|
|
* more tolerant to A/W mismatches. The lack of W->A->W conversion for such a mismatch suggests
|
|
* that the hack is in GetWindowLongPtr[AW], not in winprocs.
|
|
*/
|
|
if (win->winproc == BUILTIN_WINPROC(WINPROC_EDIT) && (!!ansi != !(win->flags & WIN_ISUNICODE)))
|
|
retval = (ULONG_PTR)win->winproc;
|
|
else
|
|
retval = (ULONG_PTR)get_winproc( win->winproc, ansi );
|
|
break;
|
|
default:
|
|
WARN("Unknown offset %d\n", offset );
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
break;
|
|
}
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
|
|
/* see GetWindowLongW */
|
|
DWORD get_window_long( HWND hwnd, INT offset )
|
|
{
|
|
return get_window_long_size( hwnd, offset, sizeof(LONG), FALSE );
|
|
}
|
|
|
|
/* see GetWindowLongPtr */
|
|
static ULONG_PTR get_window_long_ptr( HWND hwnd, INT offset, BOOL ansi )
|
|
{
|
|
return get_window_long_size( hwnd, offset, sizeof(LONG_PTR), ansi );
|
|
}
|
|
|
|
/* see GetWindowWord */
|
|
static WORD get_window_word( HWND hwnd, INT offset )
|
|
{
|
|
switch(offset)
|
|
{
|
|
case GWLP_ID:
|
|
case GWLP_HINSTANCE:
|
|
case GWLP_HWNDPARENT:
|
|
break;
|
|
default:
|
|
if (offset < 0)
|
|
{
|
|
WARN("Invalid offset %d\n", offset );
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
return get_window_long_size( hwnd, offset, sizeof(WORD), TRUE );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* set_window_style
|
|
*
|
|
* Change the style of a window.
|
|
*/
|
|
ULONG set_window_style( HWND hwnd, ULONG set_bits, ULONG clear_bits )
|
|
{
|
|
BOOL ok, made_visible = FALSE;
|
|
STYLESTRUCT style;
|
|
WND *win = get_win_ptr( hwnd );
|
|
|
|
if (!win || win == WND_DESKTOP) return 0;
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
if (is_window(hwnd))
|
|
return send_message( hwnd, WM_WINE_SETSTYLE, set_bits, clear_bits );
|
|
return 0;
|
|
}
|
|
style.styleOld = win->dwStyle;
|
|
style.styleNew = (win->dwStyle | set_bits) & ~clear_bits;
|
|
if (style.styleNew == style.styleOld)
|
|
{
|
|
release_win_ptr( win );
|
|
return style.styleNew;
|
|
}
|
|
SERVER_START_REQ( set_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->flags = SET_WIN_STYLE;
|
|
req->style = style.styleNew;
|
|
req->extra_offset = -1;
|
|
if ((ok = !wine_server_call( req )))
|
|
{
|
|
style.styleOld = reply->old_style;
|
|
win->dwStyle = style.styleNew;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (ok && ((style.styleOld ^ style.styleNew) & WS_VISIBLE))
|
|
{
|
|
made_visible = (style.styleNew & WS_VISIBLE) != 0;
|
|
invalidate_dce( win, NULL );
|
|
}
|
|
release_win_ptr( win );
|
|
|
|
if (!ok) return 0;
|
|
|
|
user_driver->pSetWindowStyle( hwnd, GWL_STYLE, &style );
|
|
if (made_visible) update_window_state( hwnd );
|
|
|
|
return style.styleOld;
|
|
}
|
|
|
|
static DWORD fix_exstyle( DWORD style, DWORD exstyle )
|
|
{
|
|
if ((exstyle & WS_EX_DLGMODALFRAME) ||
|
|
(!(exstyle & WS_EX_STATICEDGE) && (style & (WS_DLGFRAME | WS_THICKFRAME))))
|
|
exstyle |= WS_EX_WINDOWEDGE;
|
|
else
|
|
exstyle &= ~WS_EX_WINDOWEDGE;
|
|
return exstyle;
|
|
}
|
|
|
|
/* Change the owner of a window. */
|
|
static HWND set_window_owner( HWND hwnd, HWND owner )
|
|
{
|
|
WND *win = get_win_ptr( hwnd );
|
|
HWND ret = 0;
|
|
|
|
if (!win || win == WND_DESKTOP) return 0;
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
if (is_window(hwnd)) ERR( "cannot set owner %p on other process window %p\n", owner, hwnd );
|
|
return 0;
|
|
}
|
|
SERVER_START_REQ( set_window_owner )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->owner = wine_server_user_handle( owner );
|
|
if (!wine_server_call( req ))
|
|
{
|
|
win->owner = wine_server_ptr_handle( reply->full_owner );
|
|
ret = wine_server_ptr_handle( reply->prev_owner );
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
release_win_ptr( win );
|
|
return ret;
|
|
}
|
|
|
|
/* Helper function for SetWindowLong(). */
|
|
LONG_PTR set_window_long( HWND hwnd, INT offset, UINT size, LONG_PTR newval, BOOL ansi )
|
|
{
|
|
BOOL ok, made_visible = FALSE;
|
|
LONG_PTR retval = 0;
|
|
STYLESTRUCT style;
|
|
WND *win;
|
|
|
|
TRACE( "%p %d %lx %c\n", hwnd, offset, newval, ansi ? 'A' : 'W' );
|
|
|
|
if (is_broadcast(hwnd))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(win = get_win_ptr( hwnd )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
/* can't change anything on the desktop window */
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return 0;
|
|
}
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
if (offset == GWLP_WNDPROC)
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return 0;
|
|
}
|
|
if (offset > 32767 || offset < -32767)
|
|
{
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
return send_message( hwnd, WM_WINE_SETWINDOWLONG, MAKEWPARAM( offset, size ), newval );
|
|
}
|
|
|
|
/* first some special cases */
|
|
switch( offset )
|
|
{
|
|
case GWL_STYLE:
|
|
style.styleOld = win->dwStyle;
|
|
style.styleNew = newval;
|
|
release_win_ptr( win );
|
|
send_message( hwnd, WM_STYLECHANGING, GWL_STYLE, (LPARAM)&style );
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_OTHER_PROCESS) return 0;
|
|
newval = style.styleNew;
|
|
/* WS_CLIPSIBLINGS can't be reset on top-level windows */
|
|
if (win->parent == get_desktop_window()) newval |= WS_CLIPSIBLINGS;
|
|
/* WS_MINIMIZE can't be reset */
|
|
if (win->dwStyle & WS_MINIMIZE) newval |= WS_MINIMIZE;
|
|
break;
|
|
case GWL_EXSTYLE:
|
|
style.styleOld = win->dwExStyle;
|
|
style.styleNew = newval;
|
|
release_win_ptr( win );
|
|
send_message( hwnd, WM_STYLECHANGING, GWL_EXSTYLE, (LPARAM)&style );
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_OTHER_PROCESS) return 0;
|
|
/* WS_EX_TOPMOST can only be changed through SetWindowPos */
|
|
newval = (style.styleNew & ~WS_EX_TOPMOST) | (win->dwExStyle & WS_EX_TOPMOST);
|
|
newval = fix_exstyle(win->dwStyle, newval);
|
|
break;
|
|
case GWLP_HWNDPARENT:
|
|
if (win->parent == get_desktop_window())
|
|
{
|
|
release_win_ptr( win );
|
|
return (ULONG_PTR)set_window_owner( hwnd, (HWND)newval );
|
|
}
|
|
else
|
|
{
|
|
release_win_ptr( win );
|
|
return (ULONG_PTR)NtUserSetParent( hwnd, (HWND)newval );
|
|
}
|
|
case GWLP_WNDPROC:
|
|
{
|
|
WNDPROC proc;
|
|
UINT old_flags = win->flags;
|
|
retval = get_window_long_ptr( hwnd, offset, ansi );
|
|
proc = alloc_winproc( (WNDPROC)newval, ansi );
|
|
if (proc) win->winproc = proc;
|
|
if (is_winproc_unicode( proc, !ansi )) win->flags |= WIN_ISUNICODE;
|
|
else win->flags &= ~WIN_ISUNICODE;
|
|
if (!((old_flags ^ win->flags) & WIN_ISUNICODE))
|
|
{
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
/* update is_unicode flag on the server side */
|
|
break;
|
|
}
|
|
case GWLP_ID:
|
|
case GWLP_HINSTANCE:
|
|
case GWLP_USERDATA:
|
|
break;
|
|
case DWLP_DLGPROC:
|
|
if ((win->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
|
|
(size == sizeof(LONG_PTR)) && win->dlgInfo)
|
|
{
|
|
WNDPROC *ptr = (WNDPROC *)((char *)win->wExtra + DWLP_DLGPROC);
|
|
retval = (ULONG_PTR)get_winproc( *ptr, ansi );
|
|
*ptr = alloc_winproc( (WNDPROC)newval, ansi );
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
/* fall through */
|
|
default:
|
|
if (offset < 0 || offset > (int)(win->cbWndExtra - size))
|
|
{
|
|
WARN("Invalid offset %d\n", offset );
|
|
release_win_ptr( win );
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
else if (get_win_data( (char *)win->wExtra + offset, size ) == newval)
|
|
{
|
|
/* already set to the same value */
|
|
release_win_ptr( win );
|
|
return newval;
|
|
}
|
|
break;
|
|
}
|
|
|
|
SERVER_START_REQ( set_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->extra_offset = -1;
|
|
switch(offset)
|
|
{
|
|
case GWL_STYLE:
|
|
req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE;
|
|
req->style = newval;
|
|
req->ex_style = fix_exstyle(newval, win->dwExStyle);
|
|
break;
|
|
case GWL_EXSTYLE:
|
|
req->flags = SET_WIN_EXSTYLE;
|
|
req->ex_style = newval;
|
|
break;
|
|
case GWLP_ID:
|
|
req->flags = SET_WIN_ID;
|
|
req->extra_value = newval;
|
|
break;
|
|
case GWLP_HINSTANCE:
|
|
req->flags = SET_WIN_INSTANCE;
|
|
req->instance = wine_server_client_ptr( (void *)newval );
|
|
break;
|
|
case GWLP_WNDPROC:
|
|
req->flags = SET_WIN_UNICODE;
|
|
req->is_unicode = (win->flags & WIN_ISUNICODE) != 0;
|
|
break;
|
|
case GWLP_USERDATA:
|
|
req->flags = SET_WIN_USERDATA;
|
|
req->user_data = newval;
|
|
break;
|
|
default:
|
|
req->flags = SET_WIN_EXTRA;
|
|
req->extra_offset = offset;
|
|
req->extra_size = size;
|
|
set_win_data( &req->extra_value, newval, size );
|
|
}
|
|
if ((ok = !wine_server_call_err( req )))
|
|
{
|
|
switch(offset)
|
|
{
|
|
case GWL_STYLE:
|
|
win->dwStyle = newval;
|
|
win->dwExStyle = fix_exstyle(win->dwStyle, win->dwExStyle);
|
|
retval = reply->old_style;
|
|
break;
|
|
case GWL_EXSTYLE:
|
|
win->dwExStyle = newval;
|
|
retval = reply->old_ex_style;
|
|
break;
|
|
case GWLP_ID:
|
|
win->wIDmenu = newval;
|
|
retval = reply->old_id;
|
|
break;
|
|
case GWLP_HINSTANCE:
|
|
win->hInstance = (HINSTANCE)newval;
|
|
retval = (ULONG_PTR)wine_server_get_ptr( reply->old_instance );
|
|
break;
|
|
case GWLP_WNDPROC:
|
|
break;
|
|
case GWLP_USERDATA:
|
|
win->userdata = newval;
|
|
retval = reply->old_user_data;
|
|
break;
|
|
default:
|
|
retval = get_win_data( (char *)win->wExtra + offset, size );
|
|
set_win_data( (char *)win->wExtra + offset, newval, size );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if ((offset == GWL_STYLE && ((style.styleOld ^ style.styleNew) & WS_VISIBLE)) ||
|
|
(offset == GWL_EXSTYLE && ((style.styleOld ^ style.styleNew) & WS_EX_LAYERED)))
|
|
{
|
|
made_visible = (win->dwStyle & WS_VISIBLE) != 0;
|
|
invalidate_dce( win, NULL );
|
|
}
|
|
release_win_ptr( win );
|
|
|
|
if (!ok) return 0;
|
|
|
|
if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
|
|
{
|
|
style.styleOld = retval;
|
|
style.styleNew = newval;
|
|
user_driver->pSetWindowStyle( hwnd, offset, &style );
|
|
if (made_visible) update_window_state( hwnd );
|
|
send_message( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/**********************************************************************
|
|
* NtUserSetWindowWord (win32u.@)
|
|
*/
|
|
WORD WINAPI NtUserSetWindowWord( HWND hwnd, INT offset, WORD newval )
|
|
{
|
|
switch(offset)
|
|
{
|
|
case GWLP_ID:
|
|
case GWLP_HINSTANCE:
|
|
case GWLP_HWNDPARENT:
|
|
break;
|
|
default:
|
|
if (offset < 0)
|
|
{
|
|
WARN("Invalid offset %d\n", offset );
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
return set_window_long( hwnd, offset, sizeof(WORD), newval, TRUE );
|
|
}
|
|
|
|
/**********************************************************************
|
|
* NtUserSetWindowLong (win32u.@)
|
|
*/
|
|
LONG WINAPI NtUserSetWindowLong( HWND hwnd, INT offset, LONG newval, BOOL ansi )
|
|
{
|
|
return set_window_long( hwnd, offset, sizeof(LONG), newval, ansi );
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserSetWindowLongPtr (win32u.@)
|
|
*/
|
|
LONG_PTR WINAPI NtUserSetWindowLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi )
|
|
{
|
|
return set_window_long( hwnd, offset, sizeof(LONG_PTR), newval, ansi );
|
|
}
|
|
|
|
static BOOL set_window_pixel_format( HWND hwnd, int format )
|
|
{
|
|
WND *win = get_win_ptr( hwnd );
|
|
|
|
if (!win || win == WND_DESKTOP || win == WND_OTHER_PROCESS)
|
|
{
|
|
WARN( "setting format %d on win %p not supported\n", format, hwnd );
|
|
return FALSE;
|
|
}
|
|
win->pixel_format = format;
|
|
release_win_ptr( win );
|
|
|
|
update_window_state( hwnd );
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserGetProp (win32u.@)
|
|
*
|
|
* NOTE Native allows only ATOMs as the second argument. We allow strings
|
|
* to save extra server call in GetPropW.
|
|
*/
|
|
HANDLE WINAPI NtUserGetProp( HWND hwnd, const WCHAR *str )
|
|
{
|
|
ULONG_PTR ret = 0;
|
|
|
|
SERVER_START_REQ( get_window_property )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
if (IS_INTRESOURCE(str)) req->atom = LOWORD(str);
|
|
else wine_server_add_data( req, str, lstrlenW(str) * sizeof(WCHAR) );
|
|
if (!wine_server_call_err( req )) ret = reply->data;
|
|
}
|
|
SERVER_END_REQ;
|
|
return (HANDLE)ret;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserSetProp (win32u.@)
|
|
*
|
|
* NOTE Native allows only ATOMs as the second argument. We allow strings
|
|
* to save extra server call in SetPropW.
|
|
*/
|
|
BOOL WINAPI NtUserSetProp( HWND hwnd, const WCHAR *str, HANDLE handle )
|
|
{
|
|
BOOL ret;
|
|
|
|
SERVER_START_REQ( set_window_property )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->data = (ULONG_PTR)handle;
|
|
if (IS_INTRESOURCE(str)) req->atom = LOWORD(str);
|
|
else wine_server_add_data( req, str, lstrlenW(str) * sizeof(WCHAR) );
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* NtUserRemoveProp (win32u.@)
|
|
*
|
|
* NOTE Native allows only ATOMs as the second argument. We allow strings
|
|
* to save extra server call in RemovePropW.
|
|
*/
|
|
HANDLE WINAPI NtUserRemoveProp( HWND hwnd, const WCHAR *str )
|
|
{
|
|
ULONG_PTR ret = 0;
|
|
|
|
SERVER_START_REQ( remove_window_property )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
if (IS_INTRESOURCE(str)) req->atom = LOWORD(str);
|
|
else wine_server_add_data( req, str, lstrlenW(str) * sizeof(WCHAR) );
|
|
if (!wine_server_call_err( req )) ret = reply->data;
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
return (HANDLE)ret;
|
|
}
|
|
|
|
static void mirror_rect( const RECT *window_rect, RECT *rect )
|
|
{
|
|
int width = window_rect->right - window_rect->left;
|
|
int tmp = rect->left;
|
|
rect->left = width - rect->right;
|
|
rect->right = width - tmp;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_window_rects
|
|
*
|
|
* Get the window and client rectangles.
|
|
*/
|
|
BOOL get_window_rects( HWND hwnd, enum coords_relative relative, RECT *window_rect,
|
|
RECT *client_rect, UINT dpi )
|
|
{
|
|
WND *win = get_win_ptr( hwnd );
|
|
BOOL ret = TRUE;
|
|
|
|
if (!win)
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return FALSE;
|
|
}
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
RECT rect;
|
|
rect.left = rect.top = 0;
|
|
if (hwnd == get_hwnd_message_parent())
|
|
{
|
|
rect.right = 100;
|
|
rect.bottom = 100;
|
|
rect = map_dpi_rect( rect, get_dpi_for_window( hwnd ), dpi );
|
|
}
|
|
else
|
|
{
|
|
rect = get_primary_monitor_rect( dpi );
|
|
}
|
|
if (window_rect) *window_rect = rect;
|
|
if (client_rect) *client_rect = rect;
|
|
return TRUE;
|
|
}
|
|
if (win != WND_OTHER_PROCESS)
|
|
{
|
|
UINT window_dpi = get_dpi_for_window( hwnd );
|
|
RECT window = win->window_rect;
|
|
RECT client = win->client_rect;
|
|
|
|
switch (relative)
|
|
{
|
|
case COORDS_CLIENT:
|
|
OffsetRect( &window, -win->client_rect.left, -win->client_rect.top );
|
|
OffsetRect( &client, -win->client_rect.left, -win->client_rect.top );
|
|
if (win->dwExStyle & WS_EX_LAYOUTRTL)
|
|
mirror_rect( &win->client_rect, &window );
|
|
break;
|
|
case COORDS_WINDOW:
|
|
OffsetRect( &window, -win->window_rect.left, -win->window_rect.top );
|
|
OffsetRect( &client, -win->window_rect.left, -win->window_rect.top );
|
|
if (win->dwExStyle & WS_EX_LAYOUTRTL)
|
|
mirror_rect( &win->window_rect, &client );
|
|
break;
|
|
case COORDS_PARENT:
|
|
if (win->parent)
|
|
{
|
|
WND *parent = get_win_ptr( win->parent );
|
|
if (parent == WND_DESKTOP) break;
|
|
if (!parent || parent == WND_OTHER_PROCESS)
|
|
{
|
|
release_win_ptr( win );
|
|
goto other_process;
|
|
}
|
|
if (parent->flags & WIN_CHILDREN_MOVED)
|
|
{
|
|
release_win_ptr( parent );
|
|
release_win_ptr( win );
|
|
goto other_process;
|
|
}
|
|
if (parent->dwExStyle & WS_EX_LAYOUTRTL)
|
|
{
|
|
mirror_rect( &parent->client_rect, &window );
|
|
mirror_rect( &parent->client_rect, &client );
|
|
}
|
|
release_win_ptr( parent );
|
|
}
|
|
break;
|
|
case COORDS_SCREEN:
|
|
while (win->parent)
|
|
{
|
|
WND *parent = get_win_ptr( win->parent );
|
|
if (parent == WND_DESKTOP) break;
|
|
if (!parent || parent == WND_OTHER_PROCESS)
|
|
{
|
|
release_win_ptr( win );
|
|
goto other_process;
|
|
}
|
|
release_win_ptr( win );
|
|
if (parent->flags & WIN_CHILDREN_MOVED)
|
|
{
|
|
release_win_ptr( parent );
|
|
goto other_process;
|
|
}
|
|
win = parent;
|
|
if (win->parent)
|
|
{
|
|
offset_rect( &window, win->client_rect.left, win->client_rect.top );
|
|
offset_rect( &client, win->client_rect.left, win->client_rect.top );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (window_rect) *window_rect = map_dpi_rect( window, window_dpi, dpi );
|
|
if (client_rect) *client_rect = map_dpi_rect( client, window_dpi, dpi );
|
|
release_win_ptr( win );
|
|
return TRUE;
|
|
}
|
|
|
|
other_process:
|
|
SERVER_START_REQ( get_window_rectangles )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->relative = relative;
|
|
req->dpi = dpi;
|
|
if ((ret = !wine_server_call_err( req )))
|
|
{
|
|
if (window_rect)
|
|
{
|
|
window_rect->left = reply->window.left;
|
|
window_rect->top = reply->window.top;
|
|
window_rect->right = reply->window.right;
|
|
window_rect->bottom = reply->window.bottom;
|
|
}
|
|
if (client_rect)
|
|
{
|
|
client_rect->left = reply->client.left;
|
|
client_rect->top = reply->client.top;
|
|
client_rect->right = reply->client.right;
|
|
client_rect->bottom = reply->client.bottom;
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
/* see GetWindowRect */
|
|
BOOL get_window_rect( HWND hwnd, RECT *rect, UINT dpi )
|
|
{
|
|
return get_window_rects( hwnd, COORDS_SCREEN, rect, NULL, dpi );
|
|
}
|
|
|
|
/* see GetClientRect */
|
|
BOOL get_client_rect( HWND hwnd, RECT *rect )
|
|
{
|
|
return get_window_rects( hwnd, COORDS_CLIENT, NULL, rect, get_thread_dpi() );
|
|
}
|
|
|
|
/* see GetWindowInfo */
|
|
static BOOL get_window_info( HWND hwnd, WINDOWINFO *info )
|
|
{
|
|
|
|
if (!info || !get_window_rects( hwnd, COORDS_SCREEN, &info->rcWindow,
|
|
&info->rcClient, get_thread_dpi() ))
|
|
return FALSE;
|
|
|
|
info->dwStyle = get_window_long( hwnd, GWL_STYLE );
|
|
info->dwExStyle = get_window_long( hwnd, GWL_EXSTYLE );
|
|
info->dwWindowStatus = get_active_window() == hwnd ? WS_ACTIVECAPTION : 0;
|
|
info->cxWindowBorders = info->rcClient.left - info->rcWindow.left;
|
|
info->cyWindowBorders = info->rcWindow.bottom - info->rcClient.bottom;
|
|
info->atomWindowType = get_class_long( hwnd, GCW_ATOM, FALSE );
|
|
info->wCreatorVersion = 0x0400;
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* update_surface_region
|
|
*/
|
|
static void update_surface_region( HWND hwnd )
|
|
{
|
|
NTSTATUS status;
|
|
HRGN region = 0;
|
|
RGNDATA *data;
|
|
size_t size = 256;
|
|
WND *win = get_win_ptr( hwnd );
|
|
|
|
if (!win || win == WND_DESKTOP || win == WND_OTHER_PROCESS) return;
|
|
if (!win->surface) goto done;
|
|
|
|
do
|
|
{
|
|
if (!(data = malloc( FIELD_OFFSET( RGNDATA, Buffer[size] )))) goto done;
|
|
|
|
SERVER_START_REQ( get_surface_region )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
wine_server_set_reply( req, data->Buffer, size );
|
|
if (!(status = wine_server_call( req )))
|
|
{
|
|
size_t reply_size = wine_server_reply_size( reply );
|
|
if (reply_size)
|
|
{
|
|
data->rdh.dwSize = sizeof(data->rdh);
|
|
data->rdh.iType = RDH_RECTANGLES;
|
|
data->rdh.nCount = reply_size / sizeof(RECT);
|
|
data->rdh.nRgnSize = reply_size;
|
|
region = NtGdiExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data );
|
|
NtGdiOffsetRgn( region, -reply->visible_rect.left, -reply->visible_rect.top );
|
|
}
|
|
}
|
|
else size = reply->total_size;
|
|
}
|
|
SERVER_END_REQ;
|
|
free( data );
|
|
} while (status == STATUS_BUFFER_OVERFLOW);
|
|
|
|
if (status) goto done;
|
|
|
|
win->surface->funcs->set_region( win->surface, region );
|
|
if (region) NtGdiDeleteObjectApp( region );
|
|
|
|
done:
|
|
release_win_ptr( win );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* apply_window_pos
|
|
*
|
|
* Backend implementation of SetWindowPos.
|
|
*/
|
|
static BOOL apply_window_pos( HWND hwnd, HWND insert_after, UINT swp_flags,
|
|
const RECT *window_rect, const RECT *client_rect, const RECT *valid_rects )
|
|
{
|
|
WND *win;
|
|
HWND surface_win = 0, parent = NtUserGetAncestor( hwnd, GA_PARENT );
|
|
BOOL ret, needs_update = FALSE;
|
|
RECT visible_rect, old_visible_rect, old_window_rect, old_client_rect, extra_rects[3];
|
|
struct window_surface *old_surface, *new_surface = NULL;
|
|
|
|
if (!parent || parent == get_desktop_window())
|
|
{
|
|
new_surface = &dummy_surface; /* provide a default surface for top-level windows */
|
|
window_surface_add_ref( new_surface );
|
|
}
|
|
visible_rect = *window_rect;
|
|
if (!(ret = user_driver->pWindowPosChanging( hwnd, insert_after, swp_flags,
|
|
window_rect, client_rect, &visible_rect, &new_surface )))
|
|
{
|
|
if (IsRectEmpty( window_rect )) visible_rect = *window_rect;
|
|
else
|
|
{
|
|
visible_rect = get_virtual_screen_rect( get_thread_dpi() );
|
|
intersect_rect( &visible_rect, &visible_rect, window_rect );
|
|
}
|
|
}
|
|
|
|
get_window_rects( hwnd, COORDS_SCREEN, &old_window_rect, NULL, get_thread_dpi() );
|
|
if (IsRectEmpty( &valid_rects[0] )) valid_rects = NULL;
|
|
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_DESKTOP || win == WND_OTHER_PROCESS)
|
|
{
|
|
if (new_surface) window_surface_release( new_surface );
|
|
return FALSE;
|
|
}
|
|
|
|
/* create or update window surface for top-level windows if the driver doesn't implement WindowPosChanging */
|
|
if (!ret && new_surface && !IsRectEmpty( &visible_rect ) &&
|
|
(!(get_window_long( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED) ||
|
|
NtUserGetLayeredWindowAttributes( hwnd, NULL, NULL, NULL )))
|
|
{
|
|
window_surface_release( new_surface );
|
|
if ((new_surface = win->surface)) window_surface_add_ref( new_surface );
|
|
create_offscreen_window_surface( &visible_rect, &new_surface );
|
|
}
|
|
|
|
old_visible_rect = win->visible_rect;
|
|
old_client_rect = win->client_rect;
|
|
old_surface = win->surface;
|
|
if (old_surface != new_surface) swp_flags |= SWP_FRAMECHANGED; /* force refreshing non-client area */
|
|
if (new_surface == &dummy_surface) swp_flags |= SWP_NOREDRAW;
|
|
else if (old_surface == &dummy_surface)
|
|
{
|
|
swp_flags |= SWP_NOCOPYBITS;
|
|
valid_rects = NULL;
|
|
}
|
|
|
|
SERVER_START_REQ( set_window_pos )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->previous = wine_server_user_handle( insert_after );
|
|
req->swp_flags = swp_flags;
|
|
req->window.left = window_rect->left;
|
|
req->window.top = window_rect->top;
|
|
req->window.right = window_rect->right;
|
|
req->window.bottom = window_rect->bottom;
|
|
req->client.left = client_rect->left;
|
|
req->client.top = client_rect->top;
|
|
req->client.right = client_rect->right;
|
|
req->client.bottom = client_rect->bottom;
|
|
if (!EqualRect( window_rect, &visible_rect ) || new_surface || valid_rects)
|
|
{
|
|
extra_rects[0] = extra_rects[1] = visible_rect;
|
|
if (new_surface)
|
|
{
|
|
extra_rects[1] = new_surface->rect;
|
|
OffsetRect( &extra_rects[1], visible_rect.left, visible_rect.top );
|
|
}
|
|
if (valid_rects) extra_rects[2] = valid_rects[0];
|
|
else SetRectEmpty( &extra_rects[2] );
|
|
wine_server_add_data( req, extra_rects, sizeof(extra_rects) );
|
|
}
|
|
if (new_surface) req->paint_flags |= SET_WINPOS_PAINT_SURFACE;
|
|
if (win->pixel_format) req->paint_flags |= SET_WINPOS_PIXEL_FORMAT;
|
|
|
|
if ((ret = !wine_server_call( req )))
|
|
{
|
|
win->dwStyle = reply->new_style;
|
|
win->dwExStyle = reply->new_ex_style;
|
|
win->window_rect = *window_rect;
|
|
win->client_rect = *client_rect;
|
|
win->visible_rect = visible_rect;
|
|
win->surface = new_surface;
|
|
surface_win = wine_server_ptr_handle( reply->surface_win );
|
|
needs_update = reply->needs_update;
|
|
if (get_window_long( win->parent, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL)
|
|
{
|
|
RECT client;
|
|
get_window_rects( win->parent, COORDS_CLIENT, NULL, &client, get_thread_dpi() );
|
|
mirror_rect( &client, &win->window_rect );
|
|
mirror_rect( &client, &win->client_rect );
|
|
mirror_rect( &client, &win->visible_rect );
|
|
}
|
|
/* if an RTL window is resized the children have moved */
|
|
if (win->dwExStyle & WS_EX_LAYOUTRTL &&
|
|
client_rect->right - client_rect->left != old_client_rect.right - old_client_rect.left)
|
|
win->flags |= WIN_CHILDREN_MOVED;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (ret)
|
|
{
|
|
if (needs_update) update_surface_region( surface_win );
|
|
if (((swp_flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE) ||
|
|
(swp_flags & (SWP_HIDEWINDOW | SWP_SHOWWINDOW | SWP_STATECHANGED | SWP_FRAMECHANGED)))
|
|
invalidate_dce( win, &old_window_rect );
|
|
}
|
|
|
|
release_win_ptr( win );
|
|
|
|
if (ret)
|
|
{
|
|
TRACE( "win %p surface %p -> %p\n", hwnd, old_surface, new_surface );
|
|
register_window_surface( old_surface, new_surface );
|
|
if (old_surface)
|
|
{
|
|
if (valid_rects)
|
|
{
|
|
move_window_bits( hwnd, old_surface, new_surface, &visible_rect,
|
|
&old_visible_rect, window_rect, valid_rects );
|
|
valid_rects = NULL; /* prevent the driver from trying to also move the bits */
|
|
}
|
|
window_surface_release( old_surface );
|
|
}
|
|
else if (surface_win && surface_win != hwnd)
|
|
{
|
|
if (valid_rects)
|
|
{
|
|
RECT rects[2];
|
|
int x_offset = old_visible_rect.left - visible_rect.left;
|
|
int y_offset = old_visible_rect.top - visible_rect.top;
|
|
|
|
/* if all that happened is that the whole window moved, copy everything */
|
|
if (!(swp_flags & SWP_FRAMECHANGED) &&
|
|
old_visible_rect.right - visible_rect.right == x_offset &&
|
|
old_visible_rect.bottom - visible_rect.bottom == y_offset &&
|
|
old_client_rect.left - client_rect->left == x_offset &&
|
|
old_client_rect.right - client_rect->right == x_offset &&
|
|
old_client_rect.top - client_rect->top == y_offset &&
|
|
old_client_rect.bottom - client_rect->bottom == y_offset &&
|
|
EqualRect( &valid_rects[0], client_rect ))
|
|
{
|
|
rects[0] = visible_rect;
|
|
rects[1] = old_visible_rect;
|
|
valid_rects = rects;
|
|
}
|
|
move_window_bits_parent( hwnd, surface_win, window_rect, valid_rects );
|
|
valid_rects = NULL; /* prevent the driver from trying to also move the bits */
|
|
}
|
|
}
|
|
|
|
user_driver->pWindowPosChanged( hwnd, insert_after, swp_flags, window_rect,
|
|
client_rect, &visible_rect, valid_rects, new_surface );
|
|
}
|
|
else if (new_surface) window_surface_release( new_surface );
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* NtUserGetWindowRgnEx (win32u.@)
|
|
*/
|
|
int WINAPI NtUserGetWindowRgnEx( HWND hwnd, HRGN hrgn, UINT unk )
|
|
{
|
|
NTSTATUS status;
|
|
HRGN win_rgn = 0;
|
|
RGNDATA *data;
|
|
size_t size = 256;
|
|
int ret = ERROR;
|
|
|
|
do
|
|
{
|
|
if (!(data = malloc( sizeof(*data) + size - 1 )))
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
return ERROR;
|
|
}
|
|
SERVER_START_REQ( get_window_region )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
wine_server_set_reply( req, data->Buffer, size );
|
|
if (!(status = wine_server_call( req )))
|
|
{
|
|
size_t reply_size = wine_server_reply_size( reply );
|
|
if (reply_size)
|
|
{
|
|
data->rdh.dwSize = sizeof(data->rdh);
|
|
data->rdh.iType = RDH_RECTANGLES;
|
|
data->rdh.nCount = reply_size / sizeof(RECT);
|
|
data->rdh.nRgnSize = reply_size;
|
|
win_rgn = NtGdiExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data );
|
|
}
|
|
}
|
|
else size = reply->total_size;
|
|
}
|
|
SERVER_END_REQ;
|
|
free( data );
|
|
} while (status == STATUS_BUFFER_OVERFLOW);
|
|
|
|
if (set_ntstatus( status ) && win_rgn)
|
|
{
|
|
ret = NtGdiCombineRgn( hrgn, win_rgn, 0, RGN_COPY );
|
|
NtGdiDeleteObjectApp( win_rgn );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserSetWindowRgn (win32u.@)
|
|
*/
|
|
int WINAPI NtUserSetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
|
|
{
|
|
static const RECT empty_rect;
|
|
BOOL ret;
|
|
|
|
if (hrgn)
|
|
{
|
|
RGNDATA *data;
|
|
DWORD size;
|
|
|
|
if (!(size = NtGdiGetRegionData( hrgn, 0, NULL ))) return FALSE;
|
|
if (!(data = malloc( size ))) return FALSE;
|
|
if (!NtGdiGetRegionData( hrgn, size, data ))
|
|
{
|
|
free( data );
|
|
return FALSE;
|
|
}
|
|
SERVER_START_REQ( set_window_region )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->redraw = redraw != 0;
|
|
if (data->rdh.nCount)
|
|
wine_server_add_data( req, data->Buffer, data->rdh.nCount * sizeof(RECT) );
|
|
else
|
|
wine_server_add_data( req, &empty_rect, sizeof(empty_rect) );
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
free( data );
|
|
}
|
|
else /* clear existing region */
|
|
{
|
|
SERVER_START_REQ( set_window_region )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->redraw = redraw != 0;
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
|
|
if (ret)
|
|
{
|
|
UINT swp_flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED |
|
|
SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE;
|
|
if (!redraw) swp_flags |= SWP_NOREDRAW;
|
|
user_driver->pSetWindowRgn( hwnd, hrgn, redraw );
|
|
NtUserSetWindowPos( hwnd, 0, 0, 0, 0, 0, swp_flags );
|
|
if (hrgn) NtGdiDeleteObjectApp( hrgn );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserMoveWindow (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserMoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy, BOOL repaint )
|
|
{
|
|
int flags = SWP_NOZORDER | SWP_NOACTIVATE;
|
|
if (!repaint) flags |= SWP_NOREDRAW;
|
|
TRACE( "%p %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint );
|
|
return NtUserSetWindowPos( hwnd, 0, x, y, cx, cy, flags );
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserGetLayeredWindowAttributes (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserGetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags )
|
|
{
|
|
BOOL ret;
|
|
|
|
SERVER_START_REQ( get_window_layered_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if ((ret = !wine_server_call_err( req )))
|
|
{
|
|
if (key) *key = reply->color_key;
|
|
if (alpha) *alpha = reply->alpha;
|
|
if (flags) *flags = reply->flags;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserSetLayeredWindowAttributes (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserSetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
|
|
{
|
|
BOOL ret;
|
|
|
|
TRACE( "(%p,%08x,%d,%x)\n", hwnd, key, alpha, flags );
|
|
|
|
SERVER_START_REQ( set_window_layered_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->color_key = key;
|
|
req->alpha = alpha;
|
|
req->flags = flags;
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (ret)
|
|
{
|
|
user_driver->pSetLayeredWindowAttributes( hwnd, key, alpha, flags );
|
|
update_window_state( hwnd );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* UpdateLayeredWindow (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserUpdateLayeredWindow( HWND hwnd, HDC hdc_dst, const POINT *pts_dst, const SIZE *size,
|
|
HDC hdc_src, const POINT *pts_src, COLORREF key,
|
|
const BLENDFUNCTION *blend, DWORD flags, const RECT *dirty )
|
|
{
|
|
DWORD swp_flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW;
|
|
RECT window_rect, client_rect;
|
|
UPDATELAYEREDWINDOWINFO info;
|
|
SIZE offset;
|
|
|
|
if (flags & ~(ULW_COLORKEY | ULW_ALPHA | ULW_OPAQUE | ULW_EX_NORESIZE) ||
|
|
!(get_window_long( hwnd, GWL_EXSTYLE ) & WS_EX_LAYERED) ||
|
|
NtUserGetLayeredWindowAttributes( hwnd, NULL, NULL, NULL ))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
get_window_rects( hwnd, COORDS_PARENT, &window_rect, &client_rect, get_thread_dpi() );
|
|
|
|
if (pts_dst)
|
|
{
|
|
offset.cx = pts_dst->x - window_rect.left;
|
|
offset.cy = pts_dst->y - window_rect.top;
|
|
OffsetRect( &client_rect, offset.cx, offset.cy );
|
|
OffsetRect( &window_rect, offset.cx, offset.cy );
|
|
swp_flags &= ~SWP_NOMOVE;
|
|
}
|
|
if (size)
|
|
{
|
|
offset.cx = size->cx - (window_rect.right - window_rect.left);
|
|
offset.cy = size->cy - (window_rect.bottom - window_rect.top);
|
|
if (size->cx <= 0 || size->cy <= 0)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
if ((flags & ULW_EX_NORESIZE) && (offset.cx || offset.cy))
|
|
{
|
|
SetLastError( ERROR_INCORRECT_SIZE );
|
|
return FALSE;
|
|
}
|
|
client_rect.right += offset.cx;
|
|
client_rect.bottom += offset.cy;
|
|
window_rect.right += offset.cx;
|
|
window_rect.bottom += offset.cy;
|
|
swp_flags &= ~SWP_NOSIZE;
|
|
}
|
|
|
|
TRACE( "window %p win %s client %s\n", hwnd,
|
|
wine_dbgstr_rect(&window_rect), wine_dbgstr_rect(&client_rect) );
|
|
|
|
apply_window_pos( hwnd, 0, swp_flags, &window_rect, &client_rect, NULL );
|
|
|
|
info.cbSize = sizeof(info);
|
|
info.hdcDst = hdc_dst;
|
|
info.pptDst = pts_dst;
|
|
info.psize = size;
|
|
info.hdcSrc = hdc_src;
|
|
info.pptSrc = pts_src;
|
|
info.crKey = key;
|
|
info.pblend = blend;
|
|
info.dwFlags = flags;
|
|
info.prcDirty = dirty;
|
|
return user_driver->pUpdateLayeredWindow( hwnd, &info, &window_rect );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* list_children_from_point
|
|
*
|
|
* Get the list of children that can contain point from the server.
|
|
* Point is in screen coordinates.
|
|
* Returned list must be freed by caller.
|
|
*/
|
|
static HWND *list_children_from_point( HWND hwnd, POINT pt )
|
|
{
|
|
int i, size = 128;
|
|
HWND *list;
|
|
|
|
for (;;)
|
|
{
|
|
int count = 0;
|
|
|
|
if (!(list = malloc( size * sizeof(HWND) ))) break;
|
|
|
|
SERVER_START_REQ( get_window_children_from_point )
|
|
{
|
|
req->parent = wine_server_user_handle( hwnd );
|
|
req->x = pt.x;
|
|
req->y = pt.y;
|
|
req->dpi = get_thread_dpi();
|
|
wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
|
|
if (!wine_server_call( req )) count = reply->count;
|
|
}
|
|
SERVER_END_REQ;
|
|
if (count && count < size)
|
|
{
|
|
/* start from the end since HWND is potentially larger than user_handle_t */
|
|
for (i = count - 1; i >= 0; i--)
|
|
list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
|
|
list[count] = 0;
|
|
return list;
|
|
}
|
|
free( list );
|
|
if (!count) break;
|
|
size = count + 1; /* restart with a large enough buffer */
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* window_from_point
|
|
*
|
|
* Find the window and hittest for a given point.
|
|
*/
|
|
static HWND window_from_point( HWND hwnd, POINT pt, INT *hittest )
|
|
{
|
|
int i, res;
|
|
HWND ret, *list;
|
|
POINT win_pt;
|
|
|
|
if (!hwnd) hwnd = get_desktop_window();
|
|
|
|
*hittest = HTNOWHERE;
|
|
|
|
if (!(list = list_children_from_point( hwnd, pt ))) return 0;
|
|
|
|
/* now determine the hittest */
|
|
|
|
for (i = 0; list[i]; i++)
|
|
{
|
|
LONG style = get_window_long( list[i], GWL_STYLE );
|
|
|
|
/* If window is minimized or disabled, return at once */
|
|
if (style & WS_DISABLED)
|
|
{
|
|
*hittest = HTERROR;
|
|
break;
|
|
}
|
|
/* Send WM_NCCHITTEST (if same thread) */
|
|
if (!is_current_thread_window( list[i] ))
|
|
{
|
|
*hittest = HTCLIENT;
|
|
break;
|
|
}
|
|
win_pt = map_dpi_point( pt, get_thread_dpi(), get_dpi_for_window( list[i] ));
|
|
res = send_message( list[i], WM_NCHITTEST, 0, MAKELPARAM( win_pt.x, win_pt.y ));
|
|
if (res != HTTRANSPARENT)
|
|
{
|
|
*hittest = res; /* Found the window */
|
|
break;
|
|
}
|
|
/* continue search with next window in z-order */
|
|
}
|
|
ret = list[i];
|
|
free( list );
|
|
TRACE( "scope %p (%d,%d) returning %p\n", hwnd, pt.x, pt.y, ret );
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* NtUserWindowFromPoint (win32u.@)
|
|
*/
|
|
HWND WINAPI NtUserWindowFromPoint( LONG x, LONG y )
|
|
{
|
|
POINT pt = { .x = x, .y = y };
|
|
INT hittest;
|
|
return window_from_point( 0, pt, &hittest );
|
|
}
|
|
|
|
/*******************************************************************
|
|
* get_work_rect
|
|
*
|
|
* Get the work area that a maximized window can cover, depending on style.
|
|
*/
|
|
static BOOL get_work_rect( HWND hwnd, RECT *rect )
|
|
{
|
|
HMONITOR monitor = monitor_from_window( hwnd, MONITOR_DEFAULTTOPRIMARY, get_thread_dpi() );
|
|
MONITORINFO mon_info;
|
|
DWORD style;
|
|
|
|
if (!monitor) return FALSE;
|
|
|
|
mon_info.cbSize = sizeof(mon_info);
|
|
get_monitor_info( monitor, &mon_info );
|
|
*rect = mon_info.rcMonitor;
|
|
|
|
style = get_window_long( hwnd, GWL_STYLE );
|
|
if (style & WS_MAXIMIZEBOX)
|
|
{
|
|
if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
|
|
*rect = mon_info.rcWork;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static RECT get_maximized_work_rect( HWND hwnd )
|
|
{
|
|
RECT work_rect = { 0 };
|
|
|
|
if ((get_window_long( hwnd, GWL_STYLE ) & (WS_MINIMIZE | WS_MAXIMIZE)) == WS_MAXIMIZE)
|
|
{
|
|
if (!get_work_rect( hwnd, &work_rect ))
|
|
work_rect = get_primary_monitor_rect( get_thread_dpi() );
|
|
}
|
|
return work_rect;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* update_maximized_pos
|
|
*
|
|
* For top level windows covering the work area, we might have to
|
|
* "forget" the maximized position. Windows presumably does this
|
|
* to avoid situations where the border style changes, which would
|
|
* lead the window to be outside the screen, or the window gets
|
|
* reloaded on a different screen, and the "saved" position no
|
|
* longer applies to it (despite being maximized).
|
|
*
|
|
* Some applications (e.g. Imperiums: Greek Wars) depend on this.
|
|
*/
|
|
static void update_maximized_pos( WND *wnd, RECT *work_rect )
|
|
{
|
|
if (wnd->parent && wnd->parent != get_desktop_window())
|
|
return;
|
|
|
|
if (wnd->dwStyle & WS_MAXIMIZE)
|
|
{
|
|
if (wnd->window_rect.left <= work_rect->left && wnd->window_rect.top <= work_rect->top &&
|
|
wnd->window_rect.right >= work_rect->right && wnd->window_rect.bottom >= work_rect->bottom)
|
|
wnd->max_pos.x = wnd->max_pos.y = -1;
|
|
}
|
|
else
|
|
wnd->max_pos.x = wnd->max_pos.y = -1;
|
|
}
|
|
|
|
static BOOL empty_point( POINT pt )
|
|
{
|
|
return pt.x == -1 && pt.y == -1;
|
|
}
|
|
|
|
/* see GetWindowPlacement */
|
|
BOOL get_window_placement( HWND hwnd, WINDOWPLACEMENT *placement )
|
|
{
|
|
RECT work_rect = get_maximized_work_rect( hwnd );
|
|
WND *win = get_win_ptr( hwnd );
|
|
UINT win_dpi;
|
|
|
|
if (!win) return FALSE;
|
|
|
|
if (win == WND_DESKTOP)
|
|
{
|
|
placement->length = sizeof(*placement);
|
|
placement->showCmd = SW_SHOWNORMAL;
|
|
placement->flags = 0;
|
|
placement->ptMinPosition.x = -1;
|
|
placement->ptMinPosition.y = -1;
|
|
placement->ptMaxPosition.x = -1;
|
|
placement->ptMaxPosition.y = -1;
|
|
get_window_rect( hwnd, &placement->rcNormalPosition, get_thread_dpi() );
|
|
return TRUE;
|
|
}
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
RECT normal_position;
|
|
DWORD style;
|
|
|
|
if (!get_window_rect( hwnd, &normal_position, get_thread_dpi() ))
|
|
return FALSE;
|
|
|
|
FIXME("not fully supported on other process window %p.\n", hwnd);
|
|
|
|
placement->length = sizeof(*placement);
|
|
style = get_window_long( hwnd, GWL_STYLE );
|
|
if (style & WS_MINIMIZE)
|
|
placement->showCmd = SW_SHOWMINIMIZED;
|
|
else
|
|
placement->showCmd = (style & WS_MAXIMIZE) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL;
|
|
/* provide some dummy information */
|
|
placement->flags = 0;
|
|
placement->ptMinPosition.x = -1;
|
|
placement->ptMinPosition.y = -1;
|
|
placement->ptMaxPosition.x = -1;
|
|
placement->ptMaxPosition.y = -1;
|
|
placement->rcNormalPosition = normal_position;
|
|
return TRUE;
|
|
}
|
|
|
|
/* update the placement according to the current style */
|
|
if (win->dwStyle & WS_MINIMIZE)
|
|
{
|
|
win->min_pos.x = win->window_rect.left;
|
|
win->min_pos.y = win->window_rect.top;
|
|
}
|
|
else if (win->dwStyle & WS_MAXIMIZE)
|
|
{
|
|
win->max_pos.x = win->window_rect.left;
|
|
win->max_pos.y = win->window_rect.top;
|
|
}
|
|
else
|
|
{
|
|
win->normal_rect = win->window_rect;
|
|
}
|
|
update_maximized_pos( win, &work_rect );
|
|
|
|
placement->length = sizeof(*placement);
|
|
if (win->dwStyle & WS_MINIMIZE)
|
|
placement->showCmd = SW_SHOWMINIMIZED;
|
|
else
|
|
placement->showCmd = ( win->dwStyle & WS_MAXIMIZE ) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
|
|
if (win->flags & WIN_RESTORE_MAX)
|
|
placement->flags = WPF_RESTORETOMAXIMIZED;
|
|
else
|
|
placement->flags = 0;
|
|
win_dpi = get_dpi_for_window( hwnd );
|
|
placement->ptMinPosition = empty_point(win->min_pos) ? win->min_pos
|
|
: map_dpi_point( win->min_pos, win_dpi, get_thread_dpi() );
|
|
placement->ptMaxPosition = empty_point(win->max_pos) ? win->max_pos
|
|
: map_dpi_point( win->max_pos, win_dpi, get_thread_dpi() );
|
|
placement->rcNormalPosition = map_dpi_rect( win->normal_rect, win_dpi, get_thread_dpi() );
|
|
release_win_ptr( win );
|
|
|
|
TRACE( "%p: returning min %d,%d max %d,%d normal %s\n",
|
|
hwnd, placement->ptMinPosition.x, placement->ptMinPosition.y,
|
|
placement->ptMaxPosition.x, placement->ptMaxPosition.y,
|
|
wine_dbgstr_rect(&placement->rcNormalPosition) );
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserBuildHwndList (win32u.@)
|
|
*/
|
|
NTSTATUS WINAPI NtUserBuildHwndList( HDESK desktop, ULONG unk2, ULONG unk3, ULONG unk4,
|
|
ULONG thread_id, ULONG count, HWND *buffer, ULONG *size )
|
|
{
|
|
user_handle_t *list = (user_handle_t *)buffer;
|
|
int i;
|
|
NTSTATUS status;
|
|
|
|
SERVER_START_REQ( get_window_children )
|
|
{
|
|
req->desktop = wine_server_obj_handle( desktop );
|
|
req->tid = thread_id;
|
|
if (count) wine_server_set_reply( req, list, (count - 1) * sizeof(user_handle_t) );
|
|
status = wine_server_call( req );
|
|
if (status && status != STATUS_BUFFER_TOO_SMALL) return status;
|
|
*size = reply->count + 1;
|
|
}
|
|
SERVER_END_REQ;
|
|
if (*size > count) return STATUS_BUFFER_TOO_SMALL;
|
|
|
|
/* start from the end since HWND is potentially larger than user_handle_t */
|
|
for (i = *size - 2; i >= 0; i--)
|
|
buffer[i] = wine_server_ptr_handle( list[i] );
|
|
buffer[*size - 1] = HWND_BOTTOM;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Retrieve the window text from the server. */
|
|
static data_size_t get_server_window_text( HWND hwnd, WCHAR *text, data_size_t count )
|
|
{
|
|
data_size_t len = 0, needed = 0;
|
|
|
|
SERVER_START_REQ( get_window_text )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
if (count) wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
needed = reply->length;
|
|
len = wine_server_reply_size(reply);
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
if (text) text[len / sizeof(WCHAR)] = 0;
|
|
return needed;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* NtUserInternalGetWindowText (win32u.@)
|
|
*/
|
|
INT WINAPI NtUserInternalGetWindowText( HWND hwnd, WCHAR *text, INT count )
|
|
{
|
|
WND *win;
|
|
|
|
if (count <= 0) return 0;
|
|
if (!(win = get_win_ptr( hwnd ))) return 0;
|
|
if (win == WND_DESKTOP) text[0] = 0;
|
|
else if (win != WND_OTHER_PROCESS)
|
|
{
|
|
if (win->text) lstrcpynW( text, win->text, count );
|
|
else text[0] = 0;
|
|
release_win_ptr( win );
|
|
}
|
|
else
|
|
{
|
|
get_server_window_text( hwnd, text, count );
|
|
}
|
|
return lstrlenW(text);
|
|
}
|
|
|
|
/*******************************************************************
|
|
* get_windows_offset
|
|
*
|
|
* Calculate the offset between the origin of the two windows. Used
|
|
* to implement MapWindowPoints.
|
|
*/
|
|
static BOOL get_windows_offset( HWND hwnd_from, HWND hwnd_to, UINT dpi, BOOL *mirrored, POINT *ret_offset )
|
|
{
|
|
WND *win;
|
|
POINT offset;
|
|
BOOL mirror_from, mirror_to, ret;
|
|
HWND hwnd;
|
|
|
|
offset.x = offset.y = 0;
|
|
*mirrored = mirror_from = mirror_to = FALSE;
|
|
|
|
/* Translate source window origin to screen coords */
|
|
if (hwnd_from)
|
|
{
|
|
if (!(win = get_win_ptr( hwnd_from )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return FALSE;
|
|
}
|
|
if (win == WND_OTHER_PROCESS) goto other_process;
|
|
if (win != WND_DESKTOP)
|
|
{
|
|
if (win->dwExStyle & WS_EX_LAYOUTRTL)
|
|
{
|
|
mirror_from = TRUE;
|
|
offset.x += win->client_rect.right - win->client_rect.left;
|
|
}
|
|
while (win->parent)
|
|
{
|
|
offset.x += win->client_rect.left;
|
|
offset.y += win->client_rect.top;
|
|
hwnd = win->parent;
|
|
release_win_ptr( win );
|
|
if (!(win = get_win_ptr( hwnd ))) break;
|
|
if (win == WND_OTHER_PROCESS) goto other_process;
|
|
if (win == WND_DESKTOP) break;
|
|
if (win->flags & WIN_CHILDREN_MOVED)
|
|
{
|
|
release_win_ptr( win );
|
|
goto other_process;
|
|
}
|
|
}
|
|
if (win && win != WND_DESKTOP) release_win_ptr( win );
|
|
offset = map_dpi_point( offset, get_dpi_for_window( hwnd_from ), dpi );
|
|
}
|
|
}
|
|
|
|
/* Translate origin to destination window coords */
|
|
if (hwnd_to)
|
|
{
|
|
if (!(win = get_win_ptr( hwnd_to )))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return FALSE;
|
|
}
|
|
if (win == WND_OTHER_PROCESS) goto other_process;
|
|
if (win != WND_DESKTOP)
|
|
{
|
|
POINT pt = { 0, 0 };
|
|
if (win->dwExStyle & WS_EX_LAYOUTRTL)
|
|
{
|
|
mirror_to = TRUE;
|
|
pt.x += win->client_rect.right - win->client_rect.left;
|
|
}
|
|
while (win->parent)
|
|
{
|
|
pt.x += win->client_rect.left;
|
|
pt.y += win->client_rect.top;
|
|
hwnd = win->parent;
|
|
release_win_ptr( win );
|
|
if (!(win = get_win_ptr( hwnd ))) break;
|
|
if (win == WND_OTHER_PROCESS) goto other_process;
|
|
if (win == WND_DESKTOP) break;
|
|
if (win->flags & WIN_CHILDREN_MOVED)
|
|
{
|
|
release_win_ptr( win );
|
|
goto other_process;
|
|
}
|
|
}
|
|
if (win && win != WND_DESKTOP) release_win_ptr( win );
|
|
pt = map_dpi_point( pt, get_dpi_for_window( hwnd_to ), dpi );
|
|
offset.x -= pt.x;
|
|
offset.y -= pt.y;
|
|
}
|
|
}
|
|
|
|
*mirrored = mirror_from ^ mirror_to;
|
|
if (mirror_from) offset.x = -offset.x;
|
|
*ret_offset = offset;
|
|
return TRUE;
|
|
|
|
other_process: /* one of the parents may belong to another process, do it the hard way */
|
|
SERVER_START_REQ( get_windows_offset )
|
|
{
|
|
req->from = wine_server_user_handle( hwnd_from );
|
|
req->to = wine_server_user_handle( hwnd_to );
|
|
req->dpi = dpi;
|
|
if ((ret = !wine_server_call_err( req )))
|
|
{
|
|
ret_offset->x = reply->x;
|
|
ret_offset->y = reply->y;
|
|
*mirrored = reply->mirror;
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
/* see ScreenToClient */
|
|
static BOOL screen_to_client( HWND hwnd, POINT *pt )
|
|
{
|
|
POINT offset;
|
|
BOOL mirrored;
|
|
|
|
if (!hwnd)
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return FALSE;
|
|
}
|
|
if (!get_windows_offset( 0, hwnd, get_thread_dpi(), &mirrored, &offset )) return FALSE;
|
|
pt->x += offset.x;
|
|
pt->y += offset.y;
|
|
if (mirrored) pt->x = -pt->x;
|
|
return TRUE;
|
|
}
|
|
|
|
/* map coordinates of a window region */
|
|
void map_window_region( HWND from, HWND to, HRGN hrgn )
|
|
{
|
|
BOOL mirrored;
|
|
POINT offset;
|
|
UINT i, size;
|
|
RGNDATA *data;
|
|
HRGN new_rgn;
|
|
RECT *rect;
|
|
|
|
if (!get_windows_offset( from, to, get_thread_dpi(), &mirrored, &offset )) return;
|
|
|
|
if (!mirrored)
|
|
{
|
|
NtGdiOffsetRgn( hrgn, offset.x, offset.y );
|
|
return;
|
|
}
|
|
if (!(size = NtGdiGetRegionData( hrgn, 0, NULL ))) return;
|
|
if (!(data = malloc( size ))) return;
|
|
NtGdiGetRegionData( hrgn, size, data );
|
|
rect = (RECT *)data->Buffer;
|
|
for (i = 0; i < data->rdh.nCount; i++)
|
|
{
|
|
int tmp = -(rect[i].left + offset.x);
|
|
rect[i].left = -(rect[i].right + offset.x);
|
|
rect[i].right = tmp;
|
|
rect[i].top += offset.y;
|
|
rect[i].bottom += offset.y;
|
|
}
|
|
if ((new_rgn = NtGdiExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data )))
|
|
{
|
|
NtGdiCombineRgn( hrgn, new_rgn, 0, RGN_COPY );
|
|
NtGdiDeleteObjectApp( new_rgn );
|
|
}
|
|
free( data );
|
|
}
|
|
|
|
/* see MapWindowPoints */
|
|
int map_window_points( HWND hwnd_from, HWND hwnd_to, POINT *points, UINT count, UINT dpi )
|
|
{
|
|
BOOL mirrored;
|
|
POINT offset;
|
|
UINT i;
|
|
|
|
if (!get_windows_offset( hwnd_from, hwnd_to, dpi, &mirrored, &offset )) return 0;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
points[i].x += offset.x;
|
|
points[i].y += offset.y;
|
|
if (mirrored) points[i].x = -points[i].x;
|
|
}
|
|
if (mirrored && count == 2) /* special case for rectangle */
|
|
{
|
|
int tmp = points[0].x;
|
|
points[0].x = points[1].x;
|
|
points[1].x = tmp;
|
|
}
|
|
return MAKELONG( LOWORD(offset.x), LOWORD(offset.y) );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* 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" );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* map_dpi_winpos
|
|
*/
|
|
static void map_dpi_winpos( WINDOWPOS *winpos )
|
|
{
|
|
UINT dpi_from = get_thread_dpi();
|
|
UINT dpi_to = get_dpi_for_window( winpos->hwnd );
|
|
|
|
if (!dpi_from) dpi_from = get_win_monitor_dpi( winpos->hwnd );
|
|
if (dpi_from == dpi_to) return;
|
|
winpos->x = muldiv( winpos->x, dpi_to, dpi_from );
|
|
winpos->y = muldiv( winpos->y, dpi_to, dpi_from );
|
|
winpos->cx = muldiv( winpos->cx, dpi_to, dpi_from );
|
|
winpos->cy = muldiv( winpos->cy, dpi_to, dpi_from );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* calc_winpos
|
|
*/
|
|
static BOOL calc_winpos( WINDOWPOS *winpos, RECT *old_window_rect, RECT *old_client_rect,
|
|
RECT *new_window_rect, RECT *new_client_rect )
|
|
{
|
|
WND *win;
|
|
|
|
/* Send WM_WINDOWPOSCHANGING message */
|
|
if (!(winpos->flags & SWP_NOSENDCHANGING)
|
|
&& !((winpos->flags & SWP_AGG_NOCLIENTCHANGE) && (winpos->flags & SWP_SHOWWINDOW)))
|
|
send_message( winpos->hwnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)winpos );
|
|
|
|
if (!(win = get_win_ptr( winpos->hwnd )) ||
|
|
win == WND_OTHER_PROCESS || win == WND_DESKTOP) return FALSE;
|
|
|
|
/* Calculate new position and size */
|
|
get_window_rects( winpos->hwnd, COORDS_PARENT, old_window_rect, old_client_rect, get_thread_dpi() );
|
|
*new_window_rect = *old_window_rect;
|
|
*new_client_rect = *old_client_rect;
|
|
|
|
if (!(winpos->flags & SWP_NOSIZE))
|
|
{
|
|
if (win->dwStyle & WS_MINIMIZE)
|
|
{
|
|
new_window_rect->right = new_window_rect->left + get_system_metrics( SM_CXMINIMIZED );
|
|
new_window_rect->bottom = new_window_rect->top + get_system_metrics( SM_CYMINIMIZED );
|
|
}
|
|
else
|
|
{
|
|
new_window_rect->right = new_window_rect->left + winpos->cx;
|
|
new_window_rect->bottom = new_window_rect->top + winpos->cy;
|
|
}
|
|
}
|
|
|
|
if (!(winpos->flags & SWP_NOMOVE))
|
|
{
|
|
/* If the window is toplevel minimized off-screen, force keep it there */
|
|
if ((win->dwStyle & WS_MINIMIZE) &&
|
|
win->window_rect.left <= -32000 && win->window_rect.top <= -32000 &&
|
|
(!win->parent || win->parent == get_desktop_window()))
|
|
{
|
|
winpos->x = -32000;
|
|
winpos->y = -32000;
|
|
}
|
|
new_window_rect->left = winpos->x;
|
|
new_window_rect->top = winpos->y;
|
|
new_window_rect->right += winpos->x - old_window_rect->left;
|
|
new_window_rect->bottom += winpos->y - old_window_rect->top;
|
|
|
|
offset_rect( new_client_rect, winpos->x - old_window_rect->left,
|
|
winpos->y - old_window_rect->top );
|
|
}
|
|
winpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
|
|
|
|
TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x current %s style %08x new %s\n",
|
|
winpos->hwnd, winpos->hwndInsertAfter, winpos->x, winpos->y,
|
|
winpos->cx, winpos->cy, winpos->flags,
|
|
wine_dbgstr_rect( old_window_rect ), win->dwStyle,
|
|
wine_dbgstr_rect( new_window_rect ));
|
|
|
|
release_win_ptr( win );
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_valid_rects
|
|
*
|
|
* Compute the valid rects from the old and new client rect and WVR_* flags.
|
|
* Helper for WM_NCCALCSIZE handling.
|
|
*/
|
|
static inline void get_valid_rects( const RECT *old_client, const RECT *new_client, UINT flags,
|
|
RECT *valid )
|
|
{
|
|
int cx, cy;
|
|
|
|
if (flags & WVR_REDRAW)
|
|
{
|
|
SetRectEmpty( &valid[0] );
|
|
SetRectEmpty( &valid[1] );
|
|
return;
|
|
}
|
|
|
|
if (flags & WVR_VALIDRECTS)
|
|
{
|
|
if (!intersect_rect( &valid[0], &valid[0], new_client ) ||
|
|
!intersect_rect( &valid[1], &valid[1], old_client ))
|
|
{
|
|
SetRectEmpty( &valid[0] );
|
|
SetRectEmpty( &valid[1] );
|
|
return;
|
|
}
|
|
flags = WVR_ALIGNLEFT | WVR_ALIGNTOP;
|
|
}
|
|
else
|
|
{
|
|
valid[0] = *new_client;
|
|
valid[1] = *old_client;
|
|
}
|
|
|
|
/* make sure the rectangles have the same size */
|
|
cx = min( valid[0].right - valid[0].left, valid[1].right - valid[1].left );
|
|
cy = min( valid[0].bottom - valid[0].top, valid[1].bottom - valid[1].top );
|
|
|
|
if (flags & WVR_ALIGNBOTTOM)
|
|
{
|
|
valid[0].top = valid[0].bottom - cy;
|
|
valid[1].top = valid[1].bottom - cy;
|
|
}
|
|
else
|
|
{
|
|
valid[0].bottom = valid[0].top + cy;
|
|
valid[1].bottom = valid[1].top + cy;
|
|
}
|
|
if (flags & WVR_ALIGNRIGHT)
|
|
{
|
|
valid[0].left = valid[0].right - cx;
|
|
valid[1].left = valid[1].right - cx;
|
|
}
|
|
else
|
|
{
|
|
valid[0].right = valid[0].left + cx;
|
|
valid[1].right = valid[1].left + cx;
|
|
}
|
|
}
|
|
|
|
static UINT calc_ncsize( WINDOWPOS *winpos, const RECT *old_window_rect, const RECT *old_client_rect,
|
|
const RECT *new_window_rect, RECT *new_client_rect, RECT *valid_rects,
|
|
int parent_x, int parent_y )
|
|
{
|
|
UINT wvr_flags = 0;
|
|
|
|
/* Send WM_NCCALCSIZE message to get new client area */
|
|
if ((winpos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE)
|
|
{
|
|
NCCALCSIZE_PARAMS params;
|
|
WINDOWPOS winposCopy;
|
|
|
|
params.rgrc[0] = *new_window_rect;
|
|
params.rgrc[1] = *old_window_rect;
|
|
params.rgrc[2] = *old_client_rect;
|
|
params.lppos = &winposCopy;
|
|
winposCopy = *winpos;
|
|
|
|
if (winpos->flags & SWP_NOMOVE)
|
|
{
|
|
winposCopy.x = old_window_rect->left;
|
|
winposCopy.y = old_window_rect->top;
|
|
}
|
|
|
|
if (winpos->flags & SWP_NOSIZE)
|
|
{
|
|
winposCopy.cx = old_window_rect->right - old_window_rect->left;
|
|
winposCopy.cy = old_window_rect->bottom - old_window_rect->top;
|
|
}
|
|
|
|
wvr_flags = send_message( winpos->hwnd, WM_NCCALCSIZE, TRUE, (LPARAM)¶ms );
|
|
|
|
*new_client_rect = params.rgrc[0];
|
|
|
|
TRACE( "hwnd %p old win %s old client %s new win %s new client %s\n", winpos->hwnd,
|
|
wine_dbgstr_rect(old_window_rect), wine_dbgstr_rect(old_client_rect),
|
|
wine_dbgstr_rect(new_window_rect), wine_dbgstr_rect(new_client_rect) );
|
|
|
|
if (new_client_rect->left != old_client_rect->left - parent_x ||
|
|
new_client_rect->top != old_client_rect->top - parent_y)
|
|
winpos->flags &= ~SWP_NOCLIENTMOVE;
|
|
|
|
if ((new_client_rect->right - new_client_rect->left !=
|
|
old_client_rect->right - old_client_rect->left))
|
|
winpos->flags &= ~SWP_NOCLIENTSIZE;
|
|
else
|
|
wvr_flags &= ~WVR_HREDRAW;
|
|
|
|
if (new_client_rect->bottom - new_client_rect->top !=
|
|
old_client_rect->bottom - old_client_rect->top)
|
|
winpos->flags &= ~SWP_NOCLIENTSIZE;
|
|
else
|
|
wvr_flags &= ~WVR_VREDRAW;
|
|
|
|
valid_rects[0] = params.rgrc[1];
|
|
valid_rects[1] = params.rgrc[2];
|
|
}
|
|
else
|
|
{
|
|
if (!(winpos->flags & SWP_NOMOVE) &&
|
|
(new_client_rect->left != old_client_rect->left - parent_x ||
|
|
new_client_rect->top != old_client_rect->top - parent_y))
|
|
winpos->flags &= ~SWP_NOCLIENTMOVE;
|
|
}
|
|
|
|
if (winpos->flags & (SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_SHOWWINDOW | SWP_HIDEWINDOW))
|
|
{
|
|
SetRectEmpty( &valid_rects[0] );
|
|
SetRectEmpty( &valid_rects[1] );
|
|
}
|
|
else get_valid_rects( old_client_rect, new_client_rect, wvr_flags, valid_rects );
|
|
|
|
return wvr_flags;
|
|
}
|
|
|
|
/* fix redundant flags and values in the WINDOWPOS structure */
|
|
static BOOL fixup_swp_flags( WINDOWPOS *winpos, const RECT *old_window_rect, int parent_x, int parent_y )
|
|
{
|
|
HWND parent;
|
|
WND *win = get_win_ptr( winpos->hwnd );
|
|
BOOL ret = TRUE;
|
|
|
|
if (!win || win == WND_OTHER_PROCESS)
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return FALSE;
|
|
}
|
|
winpos->hwnd = win->obj.handle; /* make it a full handle */
|
|
|
|
/* Finally make sure that all coordinates are valid */
|
|
if (winpos->x < -32768) winpos->x = -32768;
|
|
else if (winpos->x > 32767) winpos->x = 32767;
|
|
if (winpos->y < -32768) winpos->y = -32768;
|
|
else if (winpos->y > 32767) winpos->y = 32767;
|
|
|
|
if (winpos->cx < 0) winpos->cx = 0;
|
|
else if (winpos->cx > 32767) winpos->cx = 32767;
|
|
if (winpos->cy < 0) winpos->cy = 0;
|
|
else if (winpos->cy > 32767) winpos->cy = 32767;
|
|
|
|
parent = NtUserGetAncestor( winpos->hwnd, GA_PARENT );
|
|
if (!is_window_visible( parent )) winpos->flags |= SWP_NOREDRAW;
|
|
|
|
if (win->dwStyle & WS_VISIBLE) winpos->flags &= ~SWP_SHOWWINDOW;
|
|
else
|
|
{
|
|
winpos->flags &= ~SWP_HIDEWINDOW;
|
|
if (!(winpos->flags & SWP_SHOWWINDOW)) winpos->flags |= SWP_NOREDRAW;
|
|
}
|
|
|
|
if ((old_window_rect->right - old_window_rect->left == winpos->cx) &&
|
|
(old_window_rect->bottom - old_window_rect->top == winpos->cy))
|
|
winpos->flags |= SWP_NOSIZE; /* Already the right size */
|
|
|
|
if ((old_window_rect->left - parent_x == winpos->x) && (old_window_rect->top - parent_y == winpos->y))
|
|
winpos->flags |= SWP_NOMOVE; /* Already the right position */
|
|
|
|
if ((win->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)
|
|
{
|
|
if (!(winpos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) && /* Bring to the top when activating */
|
|
(winpos->flags & SWP_NOZORDER ||
|
|
(winpos->hwndInsertAfter != HWND_TOPMOST && winpos->hwndInsertAfter != HWND_NOTOPMOST)))
|
|
{
|
|
winpos->flags &= ~SWP_NOZORDER;
|
|
winpos->hwndInsertAfter = HWND_TOP;
|
|
}
|
|
}
|
|
|
|
/* Check hwndInsertAfter */
|
|
if (winpos->flags & SWP_NOZORDER) goto done;
|
|
|
|
if (winpos->hwndInsertAfter == HWND_TOP)
|
|
{
|
|
if (get_window_relative( winpos->hwnd, GW_HWNDFIRST ) == winpos->hwnd)
|
|
winpos->flags |= SWP_NOZORDER;
|
|
}
|
|
else if (winpos->hwndInsertAfter == HWND_BOTTOM)
|
|
{
|
|
if (!(win->dwExStyle & WS_EX_TOPMOST) &&
|
|
get_window_relative( winpos->hwnd, GW_HWNDLAST ) == winpos->hwnd)
|
|
winpos->flags |= SWP_NOZORDER;
|
|
}
|
|
else if (winpos->hwndInsertAfter == HWND_TOPMOST)
|
|
{
|
|
if ((win->dwExStyle & WS_EX_TOPMOST) &&
|
|
get_window_relative( winpos->hwnd, GW_HWNDFIRST ) == winpos->hwnd)
|
|
winpos->flags |= SWP_NOZORDER;
|
|
}
|
|
else if (winpos->hwndInsertAfter == HWND_NOTOPMOST)
|
|
{
|
|
if (!(win->dwExStyle & WS_EX_TOPMOST))
|
|
winpos->flags |= SWP_NOZORDER;
|
|
}
|
|
else
|
|
{
|
|
if ((winpos->hwnd == winpos->hwndInsertAfter) ||
|
|
(winpos->hwnd == get_window_relative( winpos->hwndInsertAfter, GW_HWNDNEXT )))
|
|
winpos->flags |= SWP_NOZORDER;
|
|
}
|
|
done:
|
|
release_win_ptr( win );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* swp_owner_popups
|
|
*
|
|
* fix Z order taking into account owned popups -
|
|
* basically we need to maintain them above the window that owns them
|
|
*
|
|
* FIXME: hide/show owned popups when owner visibility changes.
|
|
*/
|
|
static HWND swp_owner_popups( HWND hwnd, HWND after )
|
|
{
|
|
HWND owner, *list = NULL;
|
|
unsigned int i;
|
|
|
|
TRACE( "(%p) after = %p\n", hwnd, after );
|
|
|
|
if (get_window_long( hwnd, GWL_STYLE ) & WS_CHILD) return after;
|
|
|
|
if ((owner = get_window_relative( hwnd, GW_OWNER )))
|
|
{
|
|
/* make sure this popup stays above the owner */
|
|
|
|
if (after != HWND_TOPMOST)
|
|
{
|
|
if (!(list = list_window_children( 0, get_desktop_window(), NULL, 0 ))) return after;
|
|
|
|
for (i = 0; list[i]; i++)
|
|
{
|
|
BOOL topmost = (get_window_long( list[i], GWL_EXSTYLE ) & WS_EX_TOPMOST) != 0;
|
|
|
|
if (list[i] == owner)
|
|
{
|
|
if (i > 0) after = list[i-1];
|
|
else after = topmost ? HWND_TOPMOST : HWND_TOP;
|
|
break;
|
|
}
|
|
|
|
if (after == HWND_TOP || after == HWND_NOTOPMOST)
|
|
{
|
|
if (!topmost) break;
|
|
}
|
|
else if (list[i] == after) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (after == HWND_BOTTOM) goto done;
|
|
if (!list && !(list = list_window_children( 0, get_desktop_window(), NULL, 0 ))) goto done;
|
|
|
|
i = 0;
|
|
if (after == HWND_TOP || after == HWND_NOTOPMOST)
|
|
{
|
|
if (after == HWND_NOTOPMOST ||
|
|
!(get_window_long( hwnd, GWL_EXSTYLE ) & WS_EX_TOPMOST))
|
|
{
|
|
/* skip all the topmost windows */
|
|
while (list[i] && (get_window_long( list[i], GWL_EXSTYLE ) & WS_EX_TOPMOST)) i++;
|
|
}
|
|
}
|
|
else if (after != HWND_TOPMOST)
|
|
{
|
|
/* skip windows that are already placed correctly */
|
|
for (i = 0; list[i]; i++)
|
|
{
|
|
if (list[i] == after) break;
|
|
if (list[i] == hwnd) goto done; /* nothing to do if window is moving backwards in z-order */
|
|
}
|
|
}
|
|
|
|
for ( ; list[i]; i++)
|
|
{
|
|
if (list[i] == hwnd) break;
|
|
if (get_window_relative( list[i], GW_OWNER ) != hwnd) continue;
|
|
TRACE( "moving %p owned by %p after %p\n", list[i], hwnd, after );
|
|
NtUserSetWindowPos( list[i], after, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE );
|
|
after = list[i];
|
|
}
|
|
|
|
done:
|
|
free( list );
|
|
return after;
|
|
}
|
|
|
|
/* NtUserSetWindowPos implementation */
|
|
BOOL set_window_pos( WINDOWPOS *winpos, int parent_x, int parent_y )
|
|
{
|
|
RECT old_window_rect, old_client_rect, new_window_rect, new_client_rect, valid_rects[2];
|
|
UINT orig_flags;
|
|
BOOL ret = FALSE;
|
|
DPI_AWARENESS_CONTEXT context;
|
|
|
|
orig_flags = winpos->flags;
|
|
|
|
/* First, check z-order arguments. */
|
|
if (!(winpos->flags & SWP_NOZORDER))
|
|
{
|
|
/* fix sign extension */
|
|
if (winpos->hwndInsertAfter == (HWND)0xffff) winpos->hwndInsertAfter = HWND_TOPMOST;
|
|
else if (winpos->hwndInsertAfter == (HWND)0xfffe) winpos->hwndInsertAfter = HWND_NOTOPMOST;
|
|
|
|
if (!(winpos->hwndInsertAfter == HWND_TOP ||
|
|
winpos->hwndInsertAfter == HWND_BOTTOM ||
|
|
winpos->hwndInsertAfter == HWND_TOPMOST ||
|
|
winpos->hwndInsertAfter == HWND_NOTOPMOST))
|
|
{
|
|
HWND parent = NtUserGetAncestor( winpos->hwnd, GA_PARENT );
|
|
HWND insertafter_parent = NtUserGetAncestor( winpos->hwndInsertAfter, GA_PARENT );
|
|
|
|
/* hwndInsertAfter must be a sibling of the window */
|
|
if (!insertafter_parent) return FALSE;
|
|
if (insertafter_parent != parent) return TRUE;
|
|
}
|
|
}
|
|
|
|
/* Make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
|
|
if (!(winpos->flags & SWP_NOMOVE))
|
|
{
|
|
if (winpos->x < -32768) winpos->x = -32768;
|
|
else if (winpos->x > 32767) winpos->x = 32767;
|
|
if (winpos->y < -32768) winpos->y = -32768;
|
|
else if (winpos->y > 32767) winpos->y = 32767;
|
|
}
|
|
if (!(winpos->flags & SWP_NOSIZE))
|
|
{
|
|
if (winpos->cx < 0) winpos->cx = 0;
|
|
else if (winpos->cx > 32767) winpos->cx = 32767;
|
|
if (winpos->cy < 0) winpos->cy = 0;
|
|
else if (winpos->cy > 32767) winpos->cy = 32767;
|
|
}
|
|
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( winpos->hwnd ));
|
|
|
|
if (!calc_winpos( winpos, &old_window_rect, &old_client_rect,
|
|
&new_window_rect, &new_client_rect )) goto done;
|
|
|
|
/* Fix redundant flags */
|
|
if (!fixup_swp_flags( winpos, &old_window_rect, parent_x, parent_y )) goto done;
|
|
|
|
if((winpos->flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER)
|
|
{
|
|
if (NtUserGetAncestor( winpos->hwnd, GA_PARENT ) == get_desktop_window())
|
|
winpos->hwndInsertAfter = swp_owner_popups( winpos->hwnd, winpos->hwndInsertAfter );
|
|
}
|
|
|
|
/* Common operations */
|
|
|
|
calc_ncsize( winpos, &old_window_rect, &old_client_rect,
|
|
&new_window_rect, &new_client_rect, valid_rects, parent_x, parent_y );
|
|
|
|
if (!apply_window_pos( winpos->hwnd, winpos->hwndInsertAfter, winpos->flags,
|
|
&new_window_rect, &new_client_rect, valid_rects ))
|
|
goto done;
|
|
|
|
if (user_callbacks)
|
|
{
|
|
if (winpos->flags & SWP_HIDEWINDOW)
|
|
user_callbacks->pHideCaret( winpos->hwnd );
|
|
else if (winpos->flags & SWP_SHOWWINDOW)
|
|
user_callbacks->pShowCaret( winpos->hwnd );
|
|
}
|
|
|
|
if (!(winpos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
|
|
{
|
|
/* child windows get WM_CHILDACTIVATE message */
|
|
if ((get_window_long( winpos->hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD)
|
|
send_message( winpos->hwnd, WM_CHILDACTIVATE, 0, 0 );
|
|
else if (user_callbacks)
|
|
set_foreground_window( winpos->hwnd, FALSE );
|
|
}
|
|
|
|
if(!(orig_flags & SWP_DEFERERASE))
|
|
{
|
|
/* erase parent when hiding or resizing child */
|
|
if ((orig_flags & SWP_HIDEWINDOW) ||
|
|
(!(orig_flags & SWP_SHOWWINDOW) &&
|
|
(winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOGEOMETRYCHANGE))
|
|
{
|
|
HWND parent = NtUserGetAncestor( winpos->hwnd, GA_PARENT );
|
|
if (!parent || parent == get_desktop_window()) parent = winpos->hwnd;
|
|
erase_now( parent, 0 );
|
|
}
|
|
|
|
/* Give newly shown windows a chance to redraw */
|
|
if(((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
|
|
&& !(orig_flags & SWP_AGG_NOCLIENTCHANGE) && (orig_flags & SWP_SHOWWINDOW))
|
|
{
|
|
erase_now(winpos->hwnd, 0);
|
|
}
|
|
}
|
|
|
|
/* And last, send the WM_WINDOWPOSCHANGED message */
|
|
|
|
TRACE( "\tstatus flags = %04x\n", winpos->flags & SWP_AGG_STATUSFLAGS );
|
|
|
|
if (((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
|
|
&& !((orig_flags & SWP_AGG_NOCLIENTCHANGE) && (orig_flags & SWP_SHOWWINDOW)))
|
|
{
|
|
/* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
|
|
and always contains final window position.
|
|
*/
|
|
winpos->x = new_window_rect.left;
|
|
winpos->y = new_window_rect.top;
|
|
winpos->cx = new_window_rect.right - new_window_rect.left;
|
|
winpos->cy = new_window_rect.bottom - new_window_rect.top;
|
|
send_message( winpos->hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)winpos );
|
|
}
|
|
ret = TRUE;
|
|
done:
|
|
set_thread_dpi_awareness_context( context );
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* NtUserSetWindowPos (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserSetWindowPos( HWND hwnd, HWND after, INT x, INT y, INT cx, INT cy, UINT flags )
|
|
{
|
|
WINDOWPOS winpos;
|
|
|
|
TRACE( "hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n", hwnd, after, x, y, cx, cy, flags );
|
|
if(TRACE_ON(win)) dump_winpos_flags(flags);
|
|
|
|
if (is_broadcast( hwnd ))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
winpos.hwnd = get_full_window_handle( hwnd );
|
|
winpos.hwndInsertAfter = get_full_window_handle( after );
|
|
winpos.x = x;
|
|
winpos.y = y;
|
|
winpos.cx = cx;
|
|
winpos.cy = cy;
|
|
winpos.flags = flags;
|
|
|
|
map_dpi_winpos( &winpos );
|
|
|
|
if (is_current_thread_window( hwnd ))
|
|
return set_window_pos( &winpos, 0, 0 );
|
|
|
|
if (flags & SWP_ASYNCWINDOWPOS)
|
|
return NtUserMessageCall( winpos.hwnd, WM_WINE_SETWINDOWPOS, 0, (LPARAM)&winpos,
|
|
0, FNID_SENDNOTIFYMESSAGE, FALSE );
|
|
else
|
|
return send_message( winpos.hwnd, WM_WINE_SETWINDOWPOS, 0, (LPARAM)&winpos );
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
struct user_object obj;
|
|
INT count;
|
|
INT suggested_count;
|
|
HWND parent;
|
|
WINDOWPOS *winpos;
|
|
} DWP;
|
|
|
|
/* see BeginDeferWindowPos */
|
|
HDWP begin_defer_window_pos( INT count )
|
|
{
|
|
HDWP handle = 0;
|
|
DWP *dwp;
|
|
|
|
TRACE( "%d\n", count );
|
|
|
|
if (count < 0)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
/* Windows allows zero count, in which case it allocates context for 8 moves */
|
|
if (count == 0) count = 8;
|
|
|
|
if (!(dwp = malloc( sizeof(DWP) ))) return 0;
|
|
|
|
dwp->count = 0;
|
|
dwp->parent = 0;
|
|
dwp->suggested_count = count;
|
|
|
|
if (!(dwp->winpos = malloc( count * sizeof(WINDOWPOS) )) ||
|
|
!(handle = alloc_user_handle( &dwp->obj, NTUSER_OBJ_WINPOS )))
|
|
{
|
|
free( dwp->winpos );
|
|
free( dwp );
|
|
}
|
|
|
|
TRACE( "returning %p\n", handle );
|
|
return handle;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserDeferWindowPosAndBand (win32u.@)
|
|
*/
|
|
HDWP WINAPI NtUserDeferWindowPosAndBand( HDWP hdwp, HWND hwnd, HWND after,
|
|
INT x, INT y, INT cx, INT cy,
|
|
UINT flags, UINT unk1, UINT unk2 )
|
|
{
|
|
HDWP retvalue = hdwp;
|
|
WINDOWPOS winpos;
|
|
DWP *dwp;
|
|
int i;
|
|
|
|
TRACE( "hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
|
|
hdwp, hwnd, after, x, y, cx, cy, flags );
|
|
|
|
winpos.hwnd = get_full_window_handle( hwnd );
|
|
if (is_desktop_window( winpos.hwnd ) || !is_window( winpos.hwnd ))
|
|
{
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return 0;
|
|
}
|
|
|
|
winpos.hwndInsertAfter = get_full_window_handle( after );
|
|
winpos.flags = flags;
|
|
winpos.x = x;
|
|
winpos.y = y;
|
|
winpos.cx = cx;
|
|
winpos.cy = cy;
|
|
map_dpi_winpos( &winpos );
|
|
|
|
if (!(dwp = get_user_handle_ptr( hdwp, NTUSER_OBJ_WINPOS ))) return 0;
|
|
if (dwp == OBJ_OTHER_PROCESS)
|
|
{
|
|
FIXME( "other process handle %p\n", hdwp );
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < dwp->count; i++)
|
|
{
|
|
if (dwp->winpos[i].hwnd == winpos.hwnd)
|
|
{
|
|
/* Merge with the other changes */
|
|
if (!(flags & SWP_NOZORDER))
|
|
{
|
|
dwp->winpos[i].hwndInsertAfter = winpos.hwndInsertAfter;
|
|
}
|
|
if (!(flags & SWP_NOMOVE))
|
|
{
|
|
dwp->winpos[i].x = winpos.x;
|
|
dwp->winpos[i].y = winpos.y;
|
|
}
|
|
if (!(flags & SWP_NOSIZE))
|
|
{
|
|
dwp->winpos[i].cx = winpos.cx;
|
|
dwp->winpos[i].cy = winpos.cy;
|
|
}
|
|
dwp->winpos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
|
|
SWP_NOZORDER | SWP_NOREDRAW |
|
|
SWP_NOACTIVATE | SWP_NOCOPYBITS|
|
|
SWP_NOOWNERZORDER);
|
|
dwp->winpos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
|
|
SWP_FRAMECHANGED);
|
|
goto done;
|
|
}
|
|
}
|
|
if (dwp->count >= dwp->suggested_count)
|
|
{
|
|
WINDOWPOS *newpos = realloc( dwp->winpos, dwp->suggested_count * 2 * sizeof(WINDOWPOS) );
|
|
if (!newpos)
|
|
{
|
|
retvalue = 0;
|
|
goto done;
|
|
}
|
|
dwp->suggested_count *= 2;
|
|
dwp->winpos = newpos;
|
|
}
|
|
dwp->winpos[dwp->count++] = winpos;
|
|
done:
|
|
release_user_handle_ptr( dwp );
|
|
return retvalue;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserEndDeferWindowPosEx (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserEndDeferWindowPosEx( HDWP hdwp, BOOL async )
|
|
{
|
|
WINDOWPOS *winpos;
|
|
DWP *dwp;
|
|
int i;
|
|
|
|
TRACE( "%p\n", hdwp );
|
|
|
|
if (async) FIXME( "async not supported\n" );
|
|
|
|
if (!(dwp = free_user_handle( hdwp, NTUSER_OBJ_WINPOS ))) return FALSE;
|
|
if (dwp == OBJ_OTHER_PROCESS)
|
|
{
|
|
FIXME( "other process handle %p\n", hdwp );
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0, winpos = dwp->winpos; i < dwp->count; i++, winpos++)
|
|
{
|
|
TRACE( "hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
|
|
winpos->hwnd, winpos->hwndInsertAfter, winpos->x, winpos->y,
|
|
winpos->cx, winpos->cy, winpos->flags );
|
|
|
|
if (is_current_thread_window( winpos->hwnd ))
|
|
set_window_pos( winpos, 0, 0 );
|
|
else
|
|
send_message( winpos->hwnd, WM_WINE_SETWINDOWPOS, 0, (LPARAM)winpos );
|
|
}
|
|
free( dwp->winpos );
|
|
free( dwp );
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* win_set_flags
|
|
*
|
|
* Set the flags of a window and return the previous value.
|
|
*/
|
|
UINT win_set_flags( HWND hwnd, UINT set_mask, UINT clear_mask )
|
|
{
|
|
WND *win = get_win_ptr( hwnd );
|
|
UINT ret;
|
|
|
|
if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) return 0;
|
|
ret = win->flags;
|
|
win->flags = (ret & ~clear_mask) | set_mask;
|
|
release_win_ptr( win );
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* can_activate_window
|
|
*
|
|
* Check if we can activate the specified window.
|
|
*/
|
|
static BOOL can_activate_window( HWND hwnd )
|
|
{
|
|
LONG style;
|
|
|
|
if (!hwnd) return FALSE;
|
|
style = get_window_long( hwnd, GWL_STYLE );
|
|
if (!(style & WS_VISIBLE)) return FALSE;
|
|
if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
|
|
return !(style & WS_DISABLED);
|
|
}
|
|
|
|
/*******************************************************************
|
|
* activate_other_window
|
|
*
|
|
* Activates window other than hwnd.
|
|
*/
|
|
static void activate_other_window( HWND hwnd )
|
|
{
|
|
HWND hwnd_to, fg;
|
|
|
|
if ((get_window_long( hwnd, GWL_STYLE ) & WS_POPUP) &&
|
|
(hwnd_to = get_window_relative( hwnd, GW_OWNER )))
|
|
{
|
|
hwnd_to = NtUserGetAncestor( hwnd_to, GA_ROOT );
|
|
if (can_activate_window( hwnd_to )) goto done;
|
|
}
|
|
|
|
hwnd_to = hwnd;
|
|
for (;;)
|
|
{
|
|
if (!(hwnd_to = get_window_relative( hwnd_to, GW_HWNDNEXT ))) break;
|
|
if (can_activate_window( hwnd_to )) goto done;
|
|
}
|
|
|
|
hwnd_to = get_window_relative( get_desktop_window(), GW_CHILD );
|
|
for (;;)
|
|
{
|
|
if (hwnd_to == hwnd)
|
|
{
|
|
hwnd_to = 0;
|
|
break;
|
|
}
|
|
if (can_activate_window( hwnd_to )) goto done;
|
|
if (!(hwnd_to = get_window_relative( hwnd_to, GW_HWNDNEXT ))) break;
|
|
}
|
|
|
|
done:
|
|
fg = NtUserGetForegroundWindow();
|
|
TRACE( "win = %p fg = %p\n", hwnd_to, fg );
|
|
if (!fg || hwnd == fg)
|
|
{
|
|
if (set_foreground_window( hwnd_to, FALSE )) return;
|
|
}
|
|
if (NtUserSetActiveWindow( hwnd_to )) NtUserSetActiveWindow( 0 );
|
|
}
|
|
|
|
/*******************************************************************
|
|
* send_parent_notify
|
|
*/
|
|
static void send_parent_notify( HWND hwnd, UINT msg )
|
|
{
|
|
if ((get_window_long( hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD &&
|
|
!(get_window_long( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY))
|
|
{
|
|
HWND parent = get_parent( hwnd );
|
|
if (parent && parent != get_desktop_window())
|
|
send_message( parent, WM_PARENTNOTIFY,
|
|
MAKEWPARAM( msg, get_window_long( hwnd, GWLP_ID )), (LPARAM)hwnd );
|
|
}
|
|
}
|
|
|
|
/*******************************************************************
|
|
* get_min_max_info
|
|
*
|
|
* Get the minimized and maximized information for a window.
|
|
*/
|
|
static MINMAXINFO get_min_max_info( HWND hwnd )
|
|
{
|
|
LONG style = get_window_long( hwnd, GWL_STYLE );
|
|
LONG exstyle = get_window_long( hwnd, GWL_EXSTYLE );
|
|
DPI_AWARENESS_CONTEXT context;
|
|
RECT rc_work, rc_primary;
|
|
LONG adjusted_style;
|
|
MINMAXINFO minmax;
|
|
INT xinc, yinc;
|
|
RECT rc;
|
|
WND *win;
|
|
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( hwnd ));
|
|
|
|
/* Compute default values */
|
|
|
|
get_window_rect( hwnd, &rc, get_thread_dpi() );
|
|
minmax.ptReserved.x = rc.left;
|
|
minmax.ptReserved.y = rc.top;
|
|
|
|
if ((style & WS_CAPTION) == WS_CAPTION)
|
|
adjusted_style = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
|
|
else
|
|
adjusted_style = style;
|
|
|
|
get_client_rect( NtUserGetAncestor( hwnd, GA_PARENT ), &rc );
|
|
if (user_callbacks)
|
|
user_callbacks->pAdjustWindowRectEx( &rc, adjusted_style,
|
|
(style & WS_POPUP) && get_menu( hwnd ), exstyle);
|
|
|
|
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 = get_system_metrics( SM_CXMINTRACK );
|
|
minmax.ptMinTrackSize.y = get_system_metrics( SM_CYMINTRACK );
|
|
}
|
|
else
|
|
{
|
|
minmax.ptMinTrackSize.x = 2 * xinc;
|
|
minmax.ptMinTrackSize.y = 2 * yinc;
|
|
}
|
|
minmax.ptMaxTrackSize.x = get_system_metrics( SM_CXMAXTRACK );
|
|
minmax.ptMaxTrackSize.y = get_system_metrics( SM_CYMAXTRACK );
|
|
minmax.ptMaxPosition.x = -xinc;
|
|
minmax.ptMaxPosition.y = -yinc;
|
|
|
|
if ((win = get_win_ptr( hwnd )) && win != WND_DESKTOP && win != WND_OTHER_PROCESS)
|
|
{
|
|
if (!empty_point( win->max_pos )) minmax.ptMaxPosition = win->max_pos;
|
|
release_win_ptr( win );
|
|
}
|
|
|
|
send_message( hwnd, WM_GETMINMAXINFO, 0, (LPARAM)&minmax );
|
|
|
|
/* if the app didn't change the values, adapt them for the current monitor */
|
|
|
|
if (get_work_rect( hwnd, &rc_work ))
|
|
{
|
|
rc_primary = get_primary_monitor_rect( get_thread_dpi() );
|
|
if (minmax.ptMaxSize.x == (rc_primary.right - rc_primary.left) + 2 * xinc &&
|
|
minmax.ptMaxSize.y == (rc_primary.bottom - rc_primary.top) + 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;
|
|
}
|
|
}
|
|
|
|
TRACE( "%d %d / %d %d / %d %d / %d %d\n",
|
|
minmax.ptMaxSize.x, minmax.ptMaxSize.y,
|
|
minmax.ptMaxPosition.x, minmax.ptMaxPosition.y,
|
|
minmax.ptMaxTrackSize.x, minmax.ptMaxTrackSize.y,
|
|
minmax.ptMinTrackSize.x, minmax.ptMinTrackSize.y );
|
|
|
|
minmax.ptMaxTrackSize.x = max( minmax.ptMaxTrackSize.x, minmax.ptMinTrackSize.x );
|
|
minmax.ptMaxTrackSize.y = max( minmax.ptMaxTrackSize.y, minmax.ptMinTrackSize.y );
|
|
|
|
set_thread_dpi_awareness_context( context );
|
|
return minmax;
|
|
}
|
|
|
|
static POINT get_first_minimized_child_pos( const RECT *parent, const MINIMIZEDMETRICS *mm,
|
|
int width, int height )
|
|
{
|
|
POINT ret;
|
|
|
|
if (mm->iArrange & ARW_STARTRIGHT)
|
|
ret.x = parent->right - mm->iHorzGap - width;
|
|
else
|
|
ret.x = parent->left + mm->iHorzGap;
|
|
if (mm->iArrange & ARW_STARTTOP)
|
|
ret.y = parent->top + mm->iVertGap;
|
|
else
|
|
ret.y = parent->bottom - mm->iVertGap - height;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void get_next_minimized_child_pos( const RECT *parent, const MINIMIZEDMETRICS *mm,
|
|
int width, int height, POINT *pos )
|
|
{
|
|
BOOL next;
|
|
|
|
if (mm->iArrange & ARW_UP) /* == ARW_DOWN */
|
|
{
|
|
if (mm->iArrange & ARW_STARTTOP)
|
|
{
|
|
pos->y += height + mm->iVertGap;
|
|
if ((next = pos->y + height > parent->bottom))
|
|
pos->y = parent->top + mm->iVertGap;
|
|
}
|
|
else
|
|
{
|
|
pos->y -= height + mm->iVertGap;
|
|
if ((next = pos->y < parent->top))
|
|
pos->y = parent->bottom - mm->iVertGap - height;
|
|
}
|
|
|
|
if (next)
|
|
{
|
|
if (mm->iArrange & ARW_STARTRIGHT)
|
|
pos->x -= width + mm->iHorzGap;
|
|
else
|
|
pos->x += width + mm->iHorzGap;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mm->iArrange & ARW_STARTRIGHT)
|
|
{
|
|
pos->x -= width + mm->iHorzGap;
|
|
if ((next = pos->x < parent->left))
|
|
pos->x = parent->right - mm->iHorzGap - width;
|
|
}
|
|
else
|
|
{
|
|
pos->x += width + mm->iHorzGap;
|
|
if ((next = pos->x + width > parent->right))
|
|
pos->x = parent->left + mm->iHorzGap;
|
|
}
|
|
|
|
if (next)
|
|
{
|
|
if (mm->iArrange & ARW_STARTTOP)
|
|
pos->y += height + mm->iVertGap;
|
|
else
|
|
pos->y -= height + mm->iVertGap;
|
|
}
|
|
}
|
|
}
|
|
|
|
static POINT get_minimized_pos( HWND hwnd, POINT pt )
|
|
{
|
|
RECT rect, parent_rect;
|
|
HWND parent, child;
|
|
HRGN hrgn, tmp;
|
|
MINIMIZEDMETRICS metrics;
|
|
int width, height;
|
|
|
|
parent = NtUserGetAncestor( hwnd, GA_PARENT );
|
|
if (parent == get_desktop_window())
|
|
{
|
|
MONITORINFO mon_info;
|
|
HMONITOR monitor = monitor_from_window( hwnd, MONITOR_DEFAULTTOPRIMARY, get_thread_dpi() );
|
|
|
|
mon_info.cbSize = sizeof( mon_info );
|
|
get_monitor_info( monitor, &mon_info );
|
|
parent_rect = mon_info.rcWork;
|
|
}
|
|
else get_client_rect( parent, &parent_rect );
|
|
|
|
if (pt.x >= parent_rect.left && (pt.x + get_system_metrics( SM_CXMINIMIZED ) < parent_rect.right) &&
|
|
pt.y >= parent_rect.top && (pt.y + get_system_metrics( SM_CYMINIMIZED ) < parent_rect.bottom))
|
|
return pt; /* The icon already has a suitable position */
|
|
|
|
width = get_system_metrics( SM_CXMINIMIZED );
|
|
height = get_system_metrics( SM_CYMINIMIZED );
|
|
|
|
metrics.cbSize = sizeof(metrics);
|
|
NtUserSystemParametersInfo( SPI_GETMINIMIZEDMETRICS, sizeof(metrics), &metrics, 0 );
|
|
|
|
/* Check if another icon already occupies this spot */
|
|
/* FIXME: this is completely inefficient */
|
|
|
|
hrgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
|
|
tmp = NtGdiCreateRectRgn( 0, 0, 0, 0 );
|
|
for (child = get_window_relative( parent, GW_CHILD );
|
|
child;
|
|
child = get_window_relative( child, GW_HWNDNEXT ))
|
|
{
|
|
if (child == hwnd) continue;
|
|
if ((get_window_long( child, GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE))
|
|
continue;
|
|
if (get_window_rects( child, COORDS_PARENT, &rect, NULL, get_thread_dpi() ))
|
|
{
|
|
NtGdiSetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom );
|
|
NtGdiCombineRgn( hrgn, hrgn, tmp, RGN_OR );
|
|
}
|
|
}
|
|
NtGdiDeleteObjectApp( tmp );
|
|
|
|
pt = get_first_minimized_child_pos( &parent_rect, &metrics, width, height );
|
|
for (;;)
|
|
{
|
|
set_rect( &rect, pt.x, pt.y, pt.x + width, pt.y + height );
|
|
if (!NtGdiRectInRegion( hrgn, &rect ))
|
|
break;
|
|
|
|
get_next_minimized_child_pos( &parent_rect, &metrics, width, height, &pt );
|
|
}
|
|
|
|
NtGdiDeleteObjectApp( hrgn );
|
|
return pt;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* window_min_maximize
|
|
*/
|
|
static UINT window_min_maximize( HWND hwnd, UINT cmd, RECT *rect )
|
|
{
|
|
UINT swp_flags = 0;
|
|
LONG old_style;
|
|
MINMAXINFO minmax;
|
|
WINDOWPLACEMENT wpl;
|
|
|
|
TRACE( "%p %u\n", hwnd, cmd );
|
|
|
|
wpl.length = sizeof(wpl);
|
|
get_window_placement( hwnd, &wpl );
|
|
|
|
if (call_hooks( WH_CBT, HCBT_MINMAX, (WPARAM)hwnd, cmd, TRUE ))
|
|
return SWP_NOSIZE | SWP_NOMOVE;
|
|
|
|
if (is_iconic( hwnd ))
|
|
{
|
|
switch (cmd)
|
|
{
|
|
case SW_SHOWMINNOACTIVE:
|
|
case SW_SHOWMINIMIZED:
|
|
case SW_FORCEMINIMIZE:
|
|
case SW_MINIMIZE:
|
|
wpl.ptMinPosition = get_minimized_pos( hwnd, wpl.ptMinPosition );
|
|
|
|
set_rect( rect, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
|
|
wpl.ptMinPosition.x + get_system_metrics( SM_CXMINIMIZED ),
|
|
wpl.ptMinPosition.y + get_system_metrics( SM_CYMINIMIZED ));
|
|
return SWP_NOSIZE | SWP_NOMOVE;
|
|
}
|
|
if (!send_message( hwnd, WM_QUERYOPEN, 0, 0 )) return SWP_NOSIZE | SWP_NOMOVE;
|
|
swp_flags |= SWP_NOCOPYBITS;
|
|
}
|
|
|
|
switch( cmd )
|
|
{
|
|
case SW_SHOWMINNOACTIVE:
|
|
case SW_SHOWMINIMIZED:
|
|
case SW_FORCEMINIMIZE:
|
|
case SW_MINIMIZE:
|
|
if (is_zoomed( hwnd )) win_set_flags( hwnd, WIN_RESTORE_MAX, 0 );
|
|
else win_set_flags( hwnd, 0, WIN_RESTORE_MAX );
|
|
|
|
if (get_focus() == hwnd)
|
|
{
|
|
if (get_window_long( hwnd, GWL_STYLE ) & WS_CHILD)
|
|
NtUserSetFocus( NtUserGetAncestor( hwnd, GA_PARENT ));
|
|
else
|
|
NtUserSetFocus( 0 );
|
|
}
|
|
|
|
old_style = set_window_style( hwnd, WS_MINIMIZE, WS_MAXIMIZE );
|
|
|
|
wpl.ptMinPosition = get_minimized_pos( hwnd, wpl.ptMinPosition );
|
|
|
|
if (!(old_style & WS_MINIMIZE)) swp_flags |= SWP_STATECHANGED;
|
|
set_rect( rect, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
|
|
wpl.ptMinPosition.x + get_system_metrics(SM_CXMINIMIZED),
|
|
wpl.ptMinPosition.y + get_system_metrics(SM_CYMINIMIZED) );
|
|
swp_flags |= SWP_NOCOPYBITS;
|
|
break;
|
|
|
|
case SW_MAXIMIZE:
|
|
old_style = get_window_long( hwnd, GWL_STYLE );
|
|
if ((old_style & WS_MAXIMIZE) && (old_style & WS_VISIBLE)) return SWP_NOSIZE | SWP_NOMOVE;
|
|
|
|
minmax = get_min_max_info( hwnd );
|
|
|
|
old_style = set_window_style( hwnd, WS_MAXIMIZE, WS_MINIMIZE );
|
|
if (old_style & WS_MINIMIZE)
|
|
win_set_flags( hwnd, WIN_RESTORE_MAX, 0 );
|
|
|
|
if (!(old_style & WS_MAXIMIZE)) swp_flags |= SWP_STATECHANGED;
|
|
set_rect( rect, minmax.ptMaxPosition.x, minmax.ptMaxPosition.y,
|
|
minmax.ptMaxPosition.x + minmax.ptMaxSize.x,
|
|
minmax.ptMaxPosition.y + minmax.ptMaxSize.y );
|
|
break;
|
|
|
|
case SW_SHOWNOACTIVATE:
|
|
win_set_flags( hwnd, 0, WIN_RESTORE_MAX );
|
|
/* fall through */
|
|
case SW_SHOWNORMAL:
|
|
case SW_RESTORE:
|
|
case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
|
|
old_style = set_window_style( hwnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
|
|
if (old_style & WS_MINIMIZE)
|
|
{
|
|
if (win_get_flags( hwnd ) & WIN_RESTORE_MAX)
|
|
{
|
|
/* Restore to maximized position */
|
|
minmax = get_min_max_info( hwnd );
|
|
set_window_style( hwnd, WS_MAXIMIZE, 0 );
|
|
swp_flags |= SWP_STATECHANGED;
|
|
set_rect( rect, minmax.ptMaxPosition.x, minmax.ptMaxPosition.y,
|
|
minmax.ptMaxPosition.x + minmax.ptMaxSize.x,
|
|
minmax.ptMaxPosition.y + minmax.ptMaxSize.y );
|
|
break;
|
|
}
|
|
}
|
|
else if (!(old_style & WS_MAXIMIZE)) break;
|
|
|
|
swp_flags |= SWP_STATECHANGED;
|
|
|
|
/* Restore to normal position */
|
|
|
|
*rect = wpl.rcNormalPosition;
|
|
break;
|
|
}
|
|
|
|
return swp_flags;
|
|
}
|
|
|
|
/* see ArrangeIconicWindows */
|
|
static UINT arrange_iconic_windows( HWND parent )
|
|
{
|
|
int width, height, count = 0;
|
|
MINIMIZEDMETRICS metrics;
|
|
RECT parent_rect;
|
|
HWND child;
|
|
POINT pt;
|
|
|
|
metrics.cbSize = sizeof(metrics);
|
|
NtUserSystemParametersInfo( SPI_GETMINIMIZEDMETRICS, sizeof(metrics), &metrics, 0 );
|
|
width = get_system_metrics( SM_CXMINIMIZED );
|
|
height = get_system_metrics( SM_CYMINIMIZED );
|
|
|
|
if (parent == get_desktop_window())
|
|
{
|
|
MONITORINFO mon_info;
|
|
HMONITOR monitor = monitor_from_window( 0, MONITOR_DEFAULTTOPRIMARY, get_thread_dpi() );
|
|
|
|
mon_info.cbSize = sizeof( mon_info );
|
|
get_monitor_info( monitor, &mon_info );
|
|
parent_rect = mon_info.rcWork;
|
|
}
|
|
else get_client_rect( parent, &parent_rect );
|
|
|
|
pt = get_first_minimized_child_pos( &parent_rect, &metrics, width, height );
|
|
|
|
child = get_window_relative( parent, GW_CHILD );
|
|
while (child)
|
|
{
|
|
if (is_iconic( child ))
|
|
{
|
|
NtUserSetWindowPos( child, 0, pt.x, pt.y, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
|
|
get_next_minimized_child_pos( &parent_rect, &metrics, width, height, &pt );
|
|
count++;
|
|
}
|
|
child = get_window_relative( child, GW_HWNDNEXT );
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/*******************************************************************
|
|
* update_window_state
|
|
*
|
|
* Trigger an update of the window's driver state and surface.
|
|
*/
|
|
void update_window_state( HWND hwnd )
|
|
{
|
|
DPI_AWARENESS_CONTEXT context;
|
|
RECT window_rect, client_rect, valid_rects[2];
|
|
|
|
if (!is_current_thread_window( hwnd ))
|
|
{
|
|
NtUserPostMessage( hwnd, WM_WINE_UPDATEWINDOWSTATE, 0, 0 );
|
|
return;
|
|
}
|
|
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( hwnd ));
|
|
get_window_rects( hwnd, COORDS_PARENT, &window_rect, &client_rect, get_thread_dpi() );
|
|
valid_rects[0] = valid_rects[1] = client_rect;
|
|
apply_window_pos( hwnd, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE |
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW,
|
|
&window_rect, &client_rect, valid_rects );
|
|
set_thread_dpi_awareness_context( context );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* show_window
|
|
*
|
|
* Implementation of ShowWindow and ShowWindowAsync.
|
|
*/
|
|
static BOOL show_window( HWND hwnd, INT cmd )
|
|
{
|
|
WND *win;
|
|
HWND parent;
|
|
DPI_AWARENESS_CONTEXT context;
|
|
LONG style = get_window_long( hwnd, GWL_STYLE );
|
|
BOOL was_visible = (style & WS_VISIBLE) != 0;
|
|
BOOL show_flag = TRUE;
|
|
RECT newPos = {0, 0, 0, 0};
|
|
UINT new_swp, swp = 0;
|
|
|
|
TRACE( "hwnd=%p, cmd=%d, was_visible %d\n", hwnd, cmd, was_visible );
|
|
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( hwnd ));
|
|
|
|
switch(cmd)
|
|
{
|
|
case SW_HIDE:
|
|
if (!was_visible) goto done;
|
|
show_flag = FALSE;
|
|
swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE;
|
|
if (style & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
|
|
break;
|
|
|
|
case SW_SHOWMINNOACTIVE:
|
|
case SW_MINIMIZE:
|
|
case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
|
|
swp |= SWP_NOACTIVATE | SWP_NOZORDER;
|
|
/* fall through */
|
|
case SW_SHOWMINIMIZED:
|
|
swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
|
|
swp |= window_min_maximize( hwnd, cmd, &newPos );
|
|
if ((style & WS_MINIMIZE) && was_visible) goto done;
|
|
break;
|
|
|
|
case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE */
|
|
if (!was_visible) swp |= SWP_SHOWWINDOW;
|
|
swp |= SWP_FRAMECHANGED;
|
|
swp |= window_min_maximize( hwnd, SW_MAXIMIZE, &newPos );
|
|
if ((style & WS_MAXIMIZE) && was_visible) goto done;
|
|
break;
|
|
|
|
case SW_SHOWNA:
|
|
swp |= SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
|
|
if (style & WS_CHILD) swp |= SWP_NOZORDER;
|
|
break;
|
|
|
|
case SW_SHOW:
|
|
if (was_visible) goto done;
|
|
swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
|
|
if (style & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
|
|
break;
|
|
|
|
case SW_SHOWNOACTIVATE:
|
|
swp |= SWP_NOACTIVATE | SWP_NOZORDER;
|
|
/* fall through */
|
|
case SW_RESTORE:
|
|
/* fall through */
|
|
case SW_SHOWNORMAL: /* same as SW_NORMAL: */
|
|
case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
|
|
if (!was_visible) swp |= SWP_SHOWWINDOW;
|
|
if (style & (WS_MINIMIZE | WS_MAXIMIZE))
|
|
{
|
|
swp |= SWP_FRAMECHANGED;
|
|
swp |= window_min_maximize( hwnd, cmd, &newPos );
|
|
}
|
|
else
|
|
{
|
|
if (was_visible) goto done;
|
|
swp |= SWP_NOSIZE | SWP_NOMOVE;
|
|
}
|
|
if (style & WS_CHILD && !(swp & SWP_STATECHANGED)) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
|
|
break;
|
|
|
|
default:
|
|
goto done;
|
|
}
|
|
|
|
if ((show_flag != was_visible || cmd == SW_SHOWNA) && cmd != SW_SHOWMAXIMIZED && !(swp & SWP_STATECHANGED))
|
|
{
|
|
send_message( hwnd, WM_SHOWWINDOW, show_flag, 0 );
|
|
if (!is_window( hwnd )) goto done;
|
|
}
|
|
|
|
if (IsRectEmpty( &newPos )) new_swp = swp;
|
|
else if ((new_swp = user_driver->pShowWindow( hwnd, cmd, &newPos, swp )) == ~0)
|
|
{
|
|
if (get_window_long( hwnd, GWL_STYLE ) & WS_CHILD) new_swp = swp;
|
|
else if (is_iconic( hwnd ) && (newPos.left != -32000 || newPos.top != -32000))
|
|
{
|
|
offset_rect( &newPos, -32000 - newPos.left, -32000 - newPos.top );
|
|
new_swp = swp & ~(SWP_NOMOVE | SWP_NOCLIENTMOVE);
|
|
}
|
|
else new_swp = swp;
|
|
}
|
|
swp = new_swp;
|
|
|
|
parent = NtUserGetAncestor( hwnd, GA_PARENT );
|
|
if (parent && !is_window_visible( parent ) && !(swp & SWP_STATECHANGED))
|
|
{
|
|
/* if parent is not visible simply toggle WS_VISIBLE and return */
|
|
if (show_flag) set_window_style( hwnd, WS_VISIBLE, 0 );
|
|
else set_window_style( hwnd, 0, WS_VISIBLE );
|
|
}
|
|
else
|
|
NtUserSetWindowPos( hwnd, HWND_TOP, newPos.left, newPos.top,
|
|
newPos.right - newPos.left, newPos.bottom - newPos.top, swp );
|
|
|
|
if (cmd == SW_HIDE)
|
|
{
|
|
HWND hFocus;
|
|
|
|
/* FIXME: This will cause the window to be activated irrespective
|
|
* of whether it is owned by the same thread. Has to be done
|
|
* asynchronously.
|
|
*/
|
|
|
|
if (hwnd == get_active_window()) activate_other_window( hwnd );
|
|
|
|
/* Revert focus to parent */
|
|
hFocus = get_focus();
|
|
if (hwnd == hFocus)
|
|
{
|
|
HWND parent = NtUserGetAncestor(hwnd, GA_PARENT);
|
|
if (parent == get_desktop_window()) parent = 0;
|
|
NtUserSetFocus(parent);
|
|
}
|
|
goto done;
|
|
}
|
|
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_OTHER_PROCESS) goto done;
|
|
|
|
if (win->flags & WIN_NEED_SIZE)
|
|
{
|
|
/* should happen only in CreateWindowEx() */
|
|
int wParam = SIZE_RESTORED;
|
|
RECT client;
|
|
LPARAM lparam;
|
|
|
|
get_window_rects( hwnd, COORDS_PARENT, NULL, &client, get_thread_dpi() );
|
|
lparam = MAKELONG( client.right - client.left, client.bottom - client.top );
|
|
win->flags &= ~WIN_NEED_SIZE;
|
|
if (win->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
|
|
else if (win->dwStyle & WS_MINIMIZE)
|
|
{
|
|
wParam = SIZE_MINIMIZED;
|
|
lparam = 0;
|
|
}
|
|
release_win_ptr( win );
|
|
|
|
send_message( hwnd, WM_SIZE, wParam, lparam );
|
|
send_message( hwnd, WM_MOVE, 0, MAKELONG( client.left, client.top ));
|
|
}
|
|
else release_win_ptr( win );
|
|
|
|
/* if previous state was minimized Windows sets focus to the window */
|
|
if (style & WS_MINIMIZE)
|
|
{
|
|
NtUserSetFocus( hwnd );
|
|
/* Send a WM_ACTIVATE message for a top level window, even if the window is already active */
|
|
if (NtUserGetAncestor( hwnd, GA_ROOT ) == hwnd && !(swp & SWP_NOACTIVATE))
|
|
send_message( hwnd, WM_ACTIVATE, WA_ACTIVE, 0 );
|
|
}
|
|
|
|
done:
|
|
set_thread_dpi_awareness_context( context );
|
|
return was_visible;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserShowWindowAsync (win32u.@)
|
|
*
|
|
* doesn't wait; returns immediately.
|
|
* used by threads to toggle windows in other (possibly hanging) threads
|
|
*/
|
|
BOOL WINAPI NtUserShowWindowAsync( HWND hwnd, INT cmd )
|
|
{
|
|
HWND full_handle;
|
|
|
|
if (is_broadcast(hwnd))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
if ((full_handle = is_current_thread_window( hwnd )))
|
|
return show_window( full_handle, cmd );
|
|
|
|
return NtUserMessageCall( hwnd, WM_WINE_SHOWWINDOW, cmd, 0, 0,
|
|
FNID_SENDNOTIFYMESSAGE, FALSE );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserShowWindow (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserShowWindow( HWND hwnd, INT cmd )
|
|
{
|
|
HWND full_handle;
|
|
|
|
if (is_broadcast(hwnd))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
if ((full_handle = is_current_thread_window( hwnd )))
|
|
return show_window( full_handle, cmd );
|
|
|
|
if ((cmd == SW_HIDE) && !(get_window_long( hwnd, GWL_STYLE ) & WS_VISIBLE))
|
|
return FALSE;
|
|
|
|
if ((cmd == SW_SHOW) && (get_window_long( hwnd, GWL_STYLE ) & WS_VISIBLE))
|
|
return TRUE;
|
|
|
|
return send_message( hwnd, WM_WINE_SHOWWINDOW, cmd, 0 );
|
|
}
|
|
|
|
/*******************************************************************
|
|
* NtUserFlashWindowEx (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserFlashWindowEx( FLASHWINFO *info )
|
|
{
|
|
WND *win;
|
|
|
|
TRACE( "%p\n", info );
|
|
|
|
if (!info)
|
|
{
|
|
SetLastError( ERROR_NOACCESS );
|
|
return FALSE;
|
|
}
|
|
|
|
if (!info->hwnd || info->cbSize != sizeof(FLASHWINFO) || !is_window( info->hwnd ))
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
FIXME( "%p - semi-stub\n", info );
|
|
|
|
if (is_iconic( info->hwnd ))
|
|
{
|
|
NtUserRedrawWindow( info->hwnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
|
|
|
|
win = get_win_ptr( info->hwnd );
|
|
if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) return FALSE;
|
|
if (info->dwFlags && !(win->flags & WIN_NCACTIVATED))
|
|
{
|
|
win->flags |= WIN_NCACTIVATED;
|
|
}
|
|
else
|
|
{
|
|
win->flags &= ~WIN_NCACTIVATED;
|
|
}
|
|
release_win_ptr( win );
|
|
user_driver->pFlashWindowEx( info );
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
WPARAM wparam;
|
|
HWND hwnd = info->hwnd;
|
|
|
|
win = get_win_ptr( hwnd );
|
|
if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) return FALSE;
|
|
hwnd = win->obj.handle; /* make it a full handle */
|
|
|
|
if (info->dwFlags) wparam = !(win->flags & WIN_NCACTIVATED);
|
|
else wparam = (hwnd == NtUserGetForegroundWindow());
|
|
|
|
release_win_ptr( win );
|
|
send_message( hwnd, WM_NCACTIVATE, wparam, 0 );
|
|
user_driver->pFlashWindowEx( info );
|
|
return wparam;
|
|
}
|
|
}
|
|
|
|
/* see GetWindowContextHelpId */
|
|
static DWORD get_window_context_help_id( HWND hwnd )
|
|
{
|
|
DWORD retval;
|
|
WND *win = get_win_ptr( hwnd );
|
|
if (!win || win == WND_DESKTOP) return 0;
|
|
if (win == WND_OTHER_PROCESS)
|
|
{
|
|
if (is_window( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
|
|
return 0;
|
|
}
|
|
retval = win->helpContext;
|
|
release_win_ptr( win );
|
|
return retval;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* send_destroy_message
|
|
*/
|
|
static void send_destroy_message( HWND hwnd )
|
|
{
|
|
GUITHREADINFO info;
|
|
|
|
info.cbSize = sizeof(info);
|
|
if (NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ))
|
|
{
|
|
if (hwnd == info.hwndCaret && user_callbacks) user_callbacks->pDestroyCaret();
|
|
if (hwnd == info.hwndActive) activate_other_window( hwnd );
|
|
}
|
|
|
|
if (hwnd == NtUserGetClipboardOwner()) release_clipboard_owner( hwnd );
|
|
|
|
send_message( hwnd, WM_DESTROY, 0, 0);
|
|
|
|
/*
|
|
* This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
|
|
* make sure that the window still exists when we come back.
|
|
*/
|
|
if (is_window(hwnd))
|
|
{
|
|
HWND *children;
|
|
int i;
|
|
|
|
if (!(children = list_window_children( 0, hwnd, NULL, 0 ))) return;
|
|
|
|
for (i = 0; children[i]; i++)
|
|
{
|
|
if (is_window( children[i] )) send_destroy_message( children[i] );
|
|
}
|
|
free( children );
|
|
}
|
|
else
|
|
WARN( "\tdestroyed itself while in WM_DESTROY!\n" );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* free_window_handle
|
|
*
|
|
* Free a window handle.
|
|
*/
|
|
static void free_window_handle( HWND hwnd )
|
|
{
|
|
WND *win;
|
|
|
|
TRACE( "\n" );
|
|
|
|
if ((win = get_user_handle_ptr( hwnd, NTUSER_OBJ_WINDOW )) && win != OBJ_OTHER_PROCESS)
|
|
{
|
|
SERVER_START_REQ( destroy_window )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
wine_server_call( req );
|
|
set_user_handle_ptr( hwnd, NULL );
|
|
}
|
|
SERVER_END_REQ;
|
|
user_unlock();
|
|
if (user_callbacks) user_callbacks->free_win_ptr( win );
|
|
free( win );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* destroy_window
|
|
*/
|
|
LRESULT destroy_window( HWND hwnd )
|
|
{
|
|
struct window_surface *surface;
|
|
HMENU menu = 0, sys_menu;
|
|
WND *win;
|
|
HWND *children;
|
|
|
|
TRACE( "%p\n", hwnd );
|
|
|
|
/* destroy default IME window */
|
|
if (win_set_flags( hwnd, 0, WIN_HAS_IME_WIN ) & WIN_HAS_IME_WIN)
|
|
{
|
|
TRACE("unregister IME window for %p\n", hwnd);
|
|
if (user_callbacks) user_callbacks->unregister_imm( hwnd );
|
|
}
|
|
|
|
/* free child windows */
|
|
if ((children = list_window_children( 0, hwnd, NULL, 0 )))
|
|
{
|
|
int i;
|
|
for (i = 0; children[i]; i++)
|
|
{
|
|
if (is_current_thread_window( children[i] ))
|
|
destroy_window( children[i] );
|
|
else
|
|
NtUserMessageCall( children[i], WM_WINE_DESTROYWINDOW, 0, 0,
|
|
0, FNID_SENDNOTIFYMESSAGE, FALSE );
|
|
}
|
|
free( children );
|
|
}
|
|
|
|
/* Unlink now so we won't bother with the children later on */
|
|
SERVER_START_REQ( set_parent )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->parent = 0;
|
|
wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
send_message( hwnd, WM_NCDESTROY, 0, 0 );
|
|
|
|
/* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
|
|
|
|
/* free resources associated with the window */
|
|
|
|
if (!(win = get_win_ptr( hwnd )) || win == WND_OTHER_PROCESS) return 0;
|
|
if ((win->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
|
|
menu = (HMENU)win->wIDmenu;
|
|
sys_menu = win->hSysMenu;
|
|
free_dce( win->dce, hwnd );
|
|
win->dce = NULL;
|
|
NtUserDestroyCursor( win->hIconSmall2, 0 );
|
|
surface = win->surface;
|
|
win->surface = NULL;
|
|
release_win_ptr( win );
|
|
|
|
NtUserDestroyMenu( menu );
|
|
NtUserDestroyMenu( sys_menu );
|
|
if (surface)
|
|
{
|
|
register_window_surface( surface, NULL );
|
|
window_surface_release( surface );
|
|
}
|
|
|
|
user_driver->pDestroyWindow( hwnd );
|
|
|
|
free_window_handle( hwnd );
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserDestroyWindow (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserDestroyWindow( HWND hwnd )
|
|
{
|
|
BOOL is_child;
|
|
|
|
if (!(hwnd = is_current_thread_window( hwnd )) || is_desktop_window( hwnd ))
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return FALSE;
|
|
}
|
|
|
|
TRACE( "(%p)\n", hwnd );
|
|
|
|
if (call_hooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE;
|
|
|
|
if (user_callbacks && user_callbacks->is_menu_active() == hwnd)
|
|
user_callbacks->pEndMenu();
|
|
|
|
is_child = (get_window_long( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
|
|
|
|
if (is_child)
|
|
{
|
|
if (!is_exiting_thread( GetCurrentThreadId() ))
|
|
send_parent_notify( hwnd, WM_DESTROY );
|
|
}
|
|
else if (!get_window_relative( hwnd, GW_OWNER ))
|
|
{
|
|
call_hooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
|
|
/* FIXME: clean up palette - see "Internals" p.352 */
|
|
}
|
|
|
|
if (!is_window( hwnd )) return TRUE;
|
|
|
|
/* Hide the window */
|
|
if (get_window_long( hwnd, GWL_STYLE ) & WS_VISIBLE)
|
|
{
|
|
/* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
|
|
if (is_child)
|
|
NtUserShowWindow( hwnd, SW_HIDE );
|
|
else
|
|
NtUserSetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
|
|
SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW );
|
|
}
|
|
|
|
if (!is_window( hwnd )) return TRUE;
|
|
|
|
/* Recursively destroy child windows */
|
|
if (!is_child)
|
|
{
|
|
for (;;)
|
|
{
|
|
BOOL got_one = FALSE;
|
|
HWND *children;
|
|
unsigned int i;
|
|
|
|
if (!(children = list_window_children( 0, get_desktop_window(), NULL, 0 ))) break;
|
|
|
|
for (i = 0; children[i]; i++)
|
|
{
|
|
if (get_window_relative( children[i], GW_OWNER ) != hwnd) continue;
|
|
if (is_current_thread_window( children[i] ))
|
|
{
|
|
NtUserDestroyWindow( children[i] );
|
|
got_one = TRUE;
|
|
continue;
|
|
}
|
|
set_window_owner( children[i], 0 );
|
|
}
|
|
free( children );
|
|
if (!got_one) break;
|
|
}
|
|
}
|
|
|
|
send_destroy_message( hwnd );
|
|
if (!is_window( hwnd )) return TRUE;
|
|
|
|
destroy_window( hwnd );
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* destroy_thread_windows
|
|
*
|
|
* Destroy all window owned by the current thread.
|
|
*/
|
|
void destroy_thread_windows(void)
|
|
{
|
|
WND *win, *free_list = NULL;
|
|
HWND hwnd = 0;
|
|
|
|
user_lock();
|
|
while ((win = next_thread_window_ptr( &hwnd )))
|
|
{
|
|
free_dce( win->dce, win->obj.handle );
|
|
set_user_handle_ptr( hwnd, NULL );
|
|
win->obj.handle = free_list;
|
|
free_list = win;
|
|
}
|
|
if (free_list)
|
|
{
|
|
SERVER_START_REQ( destroy_window )
|
|
{
|
|
req->handle = 0; /* destroy all thread windows */
|
|
wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
}
|
|
user_unlock();
|
|
|
|
while ((win = free_list))
|
|
{
|
|
free_list = win->obj.handle;
|
|
TRACE( "destroying %p\n", win );
|
|
|
|
if ((win->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD && win->wIDmenu)
|
|
NtUserDestroyMenu( UlongToHandle(win->wIDmenu) );
|
|
if (win->hSysMenu) NtUserDestroyMenu( win->hSysMenu );
|
|
if (win->surface)
|
|
{
|
|
register_window_surface( win->surface, NULL );
|
|
window_surface_release( win->surface );
|
|
}
|
|
if (user_callbacks) user_callbacks->free_win_ptr( win );
|
|
free( win );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* create_window_handle
|
|
*
|
|
* Create a window handle with the server.
|
|
*/
|
|
static WND *create_window_handle( HWND parent, HWND owner, UNICODE_STRING *name,
|
|
HINSTANCE instance, BOOL ansi,
|
|
DWORD style, DWORD ex_style )
|
|
{
|
|
DPI_AWARENESS awareness = get_thread_dpi_awareness();
|
|
HWND handle = 0, full_parent = 0, full_owner = 0;
|
|
struct tagCLASS *class = NULL;
|
|
int extra_bytes = 0;
|
|
UINT dpi = 0;
|
|
WND *win;
|
|
|
|
SERVER_START_REQ( create_window )
|
|
{
|
|
req->parent = wine_server_user_handle( parent );
|
|
req->owner = wine_server_user_handle( owner );
|
|
req->instance = wine_server_client_ptr( instance );
|
|
req->dpi = get_system_dpi();
|
|
req->awareness = awareness;
|
|
req->style = style;
|
|
req->ex_style = ex_style;
|
|
if (!(req->atom = get_int_atom_value( name )) && name->Length)
|
|
wine_server_add_data( req, name->Buffer, name->Length );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
handle = wine_server_ptr_handle( reply->handle );
|
|
full_parent = wine_server_ptr_handle( reply->parent );
|
|
full_owner = wine_server_ptr_handle( reply->owner );
|
|
extra_bytes = reply->extra;
|
|
dpi = reply->dpi;
|
|
awareness = reply->awareness;
|
|
class = wine_server_get_ptr( reply->class_ptr );
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (!handle)
|
|
{
|
|
WARN( "error %d creating window\n", GetLastError() );
|
|
return NULL;
|
|
}
|
|
|
|
if (!(win = calloc( 1, FIELD_OFFSET(WND, wExtra) + extra_bytes )))
|
|
{
|
|
SERVER_START_REQ( destroy_window )
|
|
{
|
|
req->handle = wine_server_user_handle( handle );
|
|
wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
return NULL;
|
|
}
|
|
|
|
if (!parent) /* if parent is 0 we don't have a desktop window yet */
|
|
{
|
|
struct user_thread_info *thread_info = get_user_thread_info();
|
|
|
|
if (name->Buffer == (const WCHAR *)DESKTOP_CLASS_ATOM)
|
|
{
|
|
if (!thread_info->top_window) thread_info->top_window = full_parent ? full_parent : handle;
|
|
else assert( full_parent == thread_info->top_window );
|
|
if (full_parent && !user_driver->pCreateDesktopWindow( thread_info->top_window ))
|
|
ERR( "failed to create desktop window\n" );
|
|
if (user_callbacks) user_callbacks->register_builtin_classes();
|
|
}
|
|
else /* HWND_MESSAGE parent */
|
|
{
|
|
if (!thread_info->msg_window && !full_parent) thread_info->msg_window = handle;
|
|
}
|
|
}
|
|
|
|
user_lock();
|
|
|
|
win->obj.handle = handle;
|
|
win->obj.type = NTUSER_OBJ_WINDOW;
|
|
win->parent = full_parent;
|
|
win->owner = full_owner;
|
|
win->class = class;
|
|
win->winproc = get_class_winproc( class );
|
|
win->cbWndExtra = extra_bytes;
|
|
win->dpi = dpi;
|
|
win->dpi_awareness = awareness;
|
|
set_user_handle_ptr( handle, &win->obj );
|
|
if (is_winproc_unicode( win->winproc, !ansi )) win->flags |= WIN_ISUNICODE;
|
|
return win;
|
|
}
|
|
|
|
static BOOL is_default_coord( int x )
|
|
{
|
|
return x == CW_USEDEFAULT || x == 0x8000;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* fix_cs_coordinates
|
|
*
|
|
* Fix the coordinates and return default show mode in sw.
|
|
*/
|
|
static void fix_cs_coordinates( CREATESTRUCTW *cs, INT *sw )
|
|
{
|
|
if (cs->style & (WS_CHILD | WS_POPUP))
|
|
{
|
|
if (is_default_coord(cs->x)) cs->x = cs->y = 0;
|
|
if (is_default_coord(cs->cx)) cs->cx = cs->cy = 0;
|
|
}
|
|
else /* overlapped window */
|
|
{
|
|
RTL_USER_PROCESS_PARAMETERS *params = NtCurrentTeb()->Peb->ProcessParameters;
|
|
HMONITOR monitor;
|
|
MONITORINFO mon_info;
|
|
|
|
if (!is_default_coord( cs->x ) && !is_default_coord( cs->cx ) && !is_default_coord( cs->cy ))
|
|
return;
|
|
|
|
monitor = monitor_from_window( cs->hwndParent, MONITOR_DEFAULTTOPRIMARY, get_thread_dpi() );
|
|
mon_info.cbSize = sizeof(mon_info);
|
|
get_monitor_info( monitor, &mon_info );
|
|
|
|
if (is_default_coord( cs->x ))
|
|
{
|
|
if (!is_default_coord( cs->y )) *sw = cs->y;
|
|
cs->x = (params->dwFlags & STARTF_USEPOSITION) ? params->dwX : mon_info.rcWork.left;
|
|
cs->y = (params->dwFlags & STARTF_USEPOSITION) ? params->dwY : mon_info.rcWork.top;
|
|
}
|
|
|
|
if (is_default_coord( cs->cx ))
|
|
{
|
|
if (params->dwFlags & STARTF_USESIZE)
|
|
{
|
|
cs->cx = params->dwXSize;
|
|
cs->cy = params->dwYSize;
|
|
}
|
|
else
|
|
{
|
|
cs->cx = (mon_info.rcWork.right - mon_info.rcWork.left) * 3 / 4 - cs->x;
|
|
cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
|
|
}
|
|
}
|
|
/* neither x nor cx are default. Check the y values.
|
|
* In the trace we see Outlook and Outlook Express using
|
|
* cy set to CW_USEDEFAULT when opening the address book.
|
|
*/
|
|
else if (is_default_coord( cs->cy ))
|
|
{
|
|
FIXME( "Strange use of CW_USEDEFAULT in cy\n" );
|
|
cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
|
|
}
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* map_dpi_create_struct
|
|
*/
|
|
static void map_dpi_create_struct( CREATESTRUCTW *cs, UINT dpi_from, UINT dpi_to )
|
|
{
|
|
if (!dpi_from && !dpi_to) return;
|
|
if (!dpi_from || !dpi_to)
|
|
{
|
|
POINT pt = { cs->x, cs->y };
|
|
UINT mon_dpi = get_monitor_dpi( monitor_from_point( pt, MONITOR_DEFAULTTONEAREST, dpi_from ));
|
|
if (!dpi_from) dpi_from = mon_dpi;
|
|
else dpi_to = mon_dpi;
|
|
}
|
|
if (dpi_from == dpi_to) return;
|
|
cs->x = muldiv( cs->x, dpi_to, dpi_from );
|
|
cs->y = muldiv( cs->y, dpi_to, dpi_from );
|
|
cs->cx = muldiv( cs->cx, dpi_to, dpi_from );
|
|
cs->cy = muldiv( cs->cy, dpi_to, dpi_from );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserCreateWindowEx (win32u.@)
|
|
*/
|
|
HWND WINAPI NtUserCreateWindowEx( DWORD ex_style, UNICODE_STRING *class_name,
|
|
UNICODE_STRING *version, UNICODE_STRING *window_name,
|
|
DWORD style, INT x, INT y, INT cx, INT cy,
|
|
HWND parent, HMENU menu, HINSTANCE instance, void *params,
|
|
DWORD flags, CBT_CREATEWNDW *cbtc, DWORD unk, BOOL ansi )
|
|
{
|
|
CREATESTRUCTW cs, *client_cs = cbtc->lpcs;
|
|
UINT win_dpi, thread_dpi = get_thread_dpi();
|
|
DPI_AWARENESS_CONTEXT context;
|
|
HWND hwnd, owner = 0;
|
|
INT sw = SW_SHOW;
|
|
RECT rect;
|
|
WND *win;
|
|
|
|
static const WCHAR messageW[] = {'M','e','s','s','a','g','e'};
|
|
|
|
cs.lpCreateParams = params;
|
|
cs.hInstance = client_cs->hInstance; /* may be different than instance for win16 */
|
|
cs.hMenu = menu;
|
|
cs.hwndParent = parent;
|
|
cs.style = style;
|
|
cs.dwExStyle = ex_style;
|
|
cs.x = x;
|
|
cs.y = y;
|
|
cs.cx = cx;
|
|
cs.cy = cy;
|
|
/* We use client_cs to pass original class and name pointers,
|
|
* that's probably not how native handles it. */
|
|
cs.lpszName = client_cs->lpszName;
|
|
cs.lpszClass = client_cs->lpszClass;
|
|
|
|
/* Find the parent window */
|
|
if (parent == HWND_MESSAGE)
|
|
{
|
|
cs.hwndParent = parent = get_hwnd_message_parent();
|
|
}
|
|
else if (parent)
|
|
{
|
|
if ((cs.style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
|
|
{
|
|
owner = parent;
|
|
parent = get_desktop_window();
|
|
}
|
|
else
|
|
{
|
|
DWORD parent_style = get_window_long( parent, GWL_EXSTYLE );
|
|
if ((parent_style & WS_EX_LAYOUTRTL) && !(parent_style & WS_EX_NOINHERITLAYOUT))
|
|
cs.dwExStyle |= WS_EX_LAYOUTRTL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((cs.style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
|
|
{
|
|
WARN( "No parent for child window\n" );
|
|
SetLastError( ERROR_TLW_WITH_WSCHILD );
|
|
return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
|
|
}
|
|
|
|
/* are we creating the desktop or HWND_MESSAGE parent itself? */
|
|
if (class_name->Buffer != (LPCWSTR)DESKTOP_CLASS_ATOM &&
|
|
(class_name->Length != sizeof(messageW) ||
|
|
wcsnicmp( class_name->Buffer, messageW, ARRAYSIZE(messageW) )))
|
|
{
|
|
parent = get_desktop_window();
|
|
}
|
|
}
|
|
|
|
fix_cs_coordinates( &cs, &sw );
|
|
cs.dwExStyle = fix_exstyle( cs.style, cs.dwExStyle );
|
|
|
|
/* Create the window structure */
|
|
|
|
style = cs.style & ~WS_VISIBLE;
|
|
ex_style = cs.dwExStyle & ~WS_EX_LAYERED;
|
|
if (!(win = create_window_handle( parent, owner, class_name, instance, ansi, style, ex_style )))
|
|
return 0;
|
|
hwnd = win->obj.handle;
|
|
|
|
/* Fill the window structure */
|
|
|
|
win->tid = GetCurrentThreadId();
|
|
win->hInstance = cs.hInstance;
|
|
win->text = NULL;
|
|
win->dwStyle = style;
|
|
win->dwExStyle = ex_style;
|
|
win->wIDmenu = 0;
|
|
win->helpContext = 0;
|
|
win->pScroll = NULL;
|
|
win->userdata = 0;
|
|
win->hIcon = 0;
|
|
win->hIconSmall = 0;
|
|
win->hIconSmall2 = 0;
|
|
win->hSysMenu = 0;
|
|
|
|
win->min_pos.x = win->min_pos.y = -1;
|
|
win->max_pos.x = win->max_pos.y = -1;
|
|
SetRect( &win->normal_rect, cs.x, cs.y, cs.x + cs.cx, cs.y + cs.cy );
|
|
|
|
if (win->dwStyle & WS_SYSMENU) NtUserSetSystemMenu( hwnd, 0 );
|
|
|
|
/* call the WH_CBT hook */
|
|
|
|
release_win_ptr( win );
|
|
*client_cs = cs;
|
|
cbtc->hwndInsertAfter = HWND_TOP;
|
|
if (call_hooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)cbtc, !ansi ))
|
|
{
|
|
free_window_handle( hwnd );
|
|
return 0;
|
|
}
|
|
if (!(win = get_win_ptr( hwnd ))) return 0;
|
|
|
|
/*
|
|
* Correct the window styles.
|
|
*
|
|
* It affects only the style loaded into the WND structure.
|
|
*/
|
|
|
|
if ((win->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
|
|
{
|
|
win->dwStyle |= WS_CLIPSIBLINGS;
|
|
if (!(win->dwStyle & WS_POPUP)) win->dwStyle |= WS_CAPTION;
|
|
}
|
|
|
|
win->dwExStyle = cs.dwExStyle;
|
|
/* WS_EX_WINDOWEDGE depends on some other styles */
|
|
if ((win->dwStyle & (WS_DLGFRAME | WS_THICKFRAME)) &&
|
|
!(win->dwStyle & (WS_CHILD | WS_POPUP)))
|
|
win->dwExStyle |= WS_EX_WINDOWEDGE;
|
|
|
|
if (!(win->dwStyle & (WS_CHILD | WS_POPUP))) win->flags |= WIN_NEED_SIZE;
|
|
|
|
SERVER_START_REQ( set_window_info )
|
|
{
|
|
req->handle = wine_server_user_handle( hwnd );
|
|
req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE | SET_WIN_UNICODE;
|
|
req->style = win->dwStyle;
|
|
req->ex_style = win->dwExStyle;
|
|
req->instance = wine_server_client_ptr( win->hInstance );
|
|
req->is_unicode = (win->flags & WIN_ISUNICODE) != 0;
|
|
req->extra_offset = -1;
|
|
wine_server_call( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
/* Set the window menu */
|
|
|
|
if ((win->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
|
|
{
|
|
if (cs.hMenu && user_callbacks && !user_callbacks->set_menu( hwnd, cs.hMenu ))
|
|
{
|
|
release_win_ptr( win );
|
|
free_window_handle( hwnd );
|
|
return 0;
|
|
}
|
|
}
|
|
else NtUserSetWindowLongPtr( hwnd, GWLP_ID, (ULONG_PTR)cs.hMenu, FALSE );
|
|
|
|
win_dpi = win->dpi;
|
|
release_win_ptr( win );
|
|
|
|
if (parent) map_dpi_create_struct( &cs, thread_dpi, win_dpi );
|
|
|
|
context = set_thread_dpi_awareness_context( get_window_dpi_awareness_context( hwnd ));
|
|
|
|
/* send the WM_GETMINMAXINFO message and fix the size if needed */
|
|
|
|
cx = cs.cx;
|
|
cy = cs.cy;
|
|
if ((cs.style & WS_THICKFRAME) || !(cs.style & (WS_POPUP | WS_CHILD)))
|
|
{
|
|
MINMAXINFO info = get_min_max_info( hwnd );
|
|
cx = max( min( cx, info.ptMaxTrackSize.x ), info.ptMinTrackSize.x );
|
|
cy = max( min( cy, info.ptMaxTrackSize.y ), info.ptMinTrackSize.y );
|
|
}
|
|
|
|
if (cx < 0) cx = 0;
|
|
if (cy < 0) cy = 0;
|
|
set_rect( &rect, cs.x, cs.y, cs.x + cx, cs.y + cy );
|
|
/* check for wraparound */
|
|
if (cs.x > 0x7fffffff - cx) rect.right = 0x7fffffff;
|
|
if (cs.y > 0x7fffffff - cy) rect.bottom = 0x7fffffff;
|
|
if (!apply_window_pos( hwnd, 0, SWP_NOZORDER | SWP_NOACTIVATE, &rect, &rect, NULL )) goto failed;
|
|
|
|
/* send WM_NCCREATE */
|
|
|
|
TRACE( "hwnd %p cs %d,%d %dx%d %s\n", hwnd, cs.x, cs.y, cs.cx, cs.cy, wine_dbgstr_rect(&rect) );
|
|
*client_cs = cs;
|
|
if (!NtUserMessageCall( hwnd, WM_NCCREATE, 0, (LPARAM)client_cs, NULL, FNID_SENDMESSAGE, ansi ))
|
|
{
|
|
WARN( "%p: aborted by WM_NCCREATE\n", hwnd );
|
|
goto failed;
|
|
}
|
|
|
|
/* create default IME window */
|
|
|
|
if (!is_desktop_window( hwnd ) && parent != get_hwnd_message_parent() &&
|
|
user_callbacks && user_callbacks->register_imm( hwnd ))
|
|
{
|
|
TRACE( "register IME window for %p\n", hwnd );
|
|
win_set_flags( hwnd, WIN_HAS_IME_WIN, 0 );
|
|
}
|
|
|
|
/* send WM_NCCALCSIZE */
|
|
|
|
if (get_window_rects( hwnd, COORDS_PARENT, &rect, NULL, win_dpi ))
|
|
{
|
|
/* yes, even if the CBT hook was called with HWND_TOP */
|
|
HWND insert_after = (get_window_long( hwnd, GWL_STYLE ) & WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
|
|
RECT client_rect = rect;
|
|
|
|
/* the rectangle is in screen coords for WM_NCCALCSIZE when wparam is FALSE */
|
|
map_window_points( parent, 0, (POINT *)&client_rect, 2, win_dpi );
|
|
send_message( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&client_rect );
|
|
map_window_points( 0, parent, (POINT *)&client_rect, 2, win_dpi );
|
|
apply_window_pos( hwnd, insert_after, SWP_NOACTIVATE, &rect, &client_rect, NULL );
|
|
}
|
|
else goto failed;
|
|
|
|
/* send WM_CREATE */
|
|
if (NtUserMessageCall( hwnd, WM_CREATE, 0, (LPARAM)client_cs, 0, FNID_SENDMESSAGE, ansi ) == -1)
|
|
goto failed;
|
|
cs = *client_cs;
|
|
|
|
/* call the driver */
|
|
|
|
if (!user_driver->pCreateWindow( hwnd )) goto failed;
|
|
|
|
NtUserNotifyWinEvent( EVENT_OBJECT_CREATE, hwnd, OBJID_WINDOW, 0 );
|
|
|
|
/* send the size messages */
|
|
|
|
if (!(win_get_flags( hwnd ) & WIN_NEED_SIZE))
|
|
{
|
|
get_window_rects( hwnd, COORDS_PARENT, NULL, &rect, win_dpi );
|
|
send_message( hwnd, WM_SIZE, SIZE_RESTORED,
|
|
MAKELONG(rect.right-rect.left, rect.bottom-rect.top));
|
|
send_message( hwnd, WM_MOVE, 0, MAKELONG( rect.left, rect.top ) );
|
|
}
|
|
|
|
/* Show the window, maximizing or minimizing if needed */
|
|
|
|
style = set_window_style( hwnd, 0, WS_MAXIMIZE | WS_MINIMIZE );
|
|
if (style & (WS_MINIMIZE | WS_MAXIMIZE))
|
|
{
|
|
RECT new_pos;
|
|
UINT sw_flags = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
|
|
|
|
sw_flags = window_min_maximize( hwnd, sw_flags, &new_pos );
|
|
sw_flags |= SWP_FRAMECHANGED; /* Frame always gets changed */
|
|
if (!(style & WS_VISIBLE) || (style & WS_CHILD) || get_active_window())
|
|
sw_flags |= SWP_NOACTIVATE;
|
|
NtUserSetWindowPos( hwnd, 0, new_pos.left, new_pos.top, new_pos.right - new_pos.left,
|
|
new_pos.bottom - new_pos.top, sw_flags );
|
|
}
|
|
|
|
/* Notify the parent window only */
|
|
|
|
send_parent_notify( hwnd, WM_CREATE );
|
|
if (!is_window( hwnd ))
|
|
{
|
|
set_thread_dpi_awareness_context( context );
|
|
return 0;
|
|
}
|
|
|
|
if (parent == get_desktop_window())
|
|
NtUserPostMessage( parent, WM_PARENTNOTIFY, WM_CREATE, (LPARAM)hwnd );
|
|
|
|
if (cs.style & WS_VISIBLE)
|
|
{
|
|
if (cs.style & WS_MAXIMIZE)
|
|
sw = SW_SHOW;
|
|
else if (cs.style & WS_MINIMIZE)
|
|
sw = SW_SHOWMINIMIZED;
|
|
|
|
NtUserShowWindow( hwnd, sw );
|
|
if (cs.dwExStyle & WS_EX_MDICHILD)
|
|
{
|
|
send_message( cs.hwndParent, WM_MDIREFRESHMENU, 0, 0 );
|
|
/* ShowWindow won't activate child windows */
|
|
NtUserSetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE );
|
|
}
|
|
}
|
|
|
|
/* Call WH_SHELL hook */
|
|
|
|
if (!(get_window_long( hwnd, GWL_STYLE ) & WS_CHILD) && !get_window_relative( hwnd, GW_OWNER ))
|
|
call_hooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE );
|
|
|
|
TRACE( "created window %p\n", hwnd );
|
|
set_thread_dpi_awareness_context( context );
|
|
return hwnd;
|
|
|
|
failed:
|
|
destroy_window( hwnd );
|
|
set_thread_dpi_awareness_context( context );
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserCallHwnd (win32u.@)
|
|
*/
|
|
ULONG_PTR WINAPI NtUserCallHwnd( HWND hwnd, DWORD code )
|
|
{
|
|
switch (code)
|
|
{
|
|
case NtUserArrangeIconicWindows:
|
|
return arrange_iconic_windows( hwnd );
|
|
case NtUserGetDpiForWindow:
|
|
return get_dpi_for_window( hwnd );
|
|
case NtUserGetParent:
|
|
return HandleToUlong( get_parent( hwnd ));
|
|
case NtUserGetWindowContextHelpId:
|
|
return get_window_context_help_id( hwnd );
|
|
case NtUserGetWindowDpiAwarenessContext:
|
|
return (ULONG_PTR)get_window_dpi_awareness_context( hwnd );
|
|
case NtUserGetWindowTextLength:
|
|
return get_server_window_text( hwnd, NULL, 0 );
|
|
case NtUserIsWindow:
|
|
return is_window( hwnd );
|
|
case NtUserIsWindowUnicode:
|
|
return is_window_unicode( hwnd );
|
|
case NtUserIsWindowVisible:
|
|
return is_window_visible( hwnd );
|
|
default:
|
|
FIXME( "invalid code %u\n", code );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* NtUserCallHwndParam (win32u.@)
|
|
*/
|
|
ULONG_PTR WINAPI NtUserCallHwndParam( HWND hwnd, DWORD_PTR param, DWORD code )
|
|
{
|
|
switch (code)
|
|
{
|
|
case NtUserGetClassLongA:
|
|
return get_class_long( hwnd, param, TRUE );
|
|
case NtUserGetClassLongW:
|
|
return get_class_long( hwnd, param, FALSE );
|
|
case NtUserGetClassLongPtrA:
|
|
return get_class_long_ptr( hwnd, param, TRUE );
|
|
case NtUserGetClassLongPtrW:
|
|
return get_class_long_ptr( hwnd, param, FALSE );
|
|
case NtUserGetClassWord:
|
|
return get_class_word( hwnd, param );
|
|
case NtUserGetClientRect:
|
|
return get_client_rect( hwnd, (RECT *)param );
|
|
case NtUserGetMinMaxInfo:
|
|
*(MINMAXINFO *)param = get_min_max_info( hwnd );
|
|
return 0;
|
|
case NtUserGetWindowInfo:
|
|
return get_window_info( hwnd, (WINDOWINFO *)param );
|
|
case NtUserGetWindowLongA:
|
|
return get_window_long_size( hwnd, param, sizeof(LONG), TRUE );
|
|
case NtUserGetWindowLongW:
|
|
return get_window_long( hwnd, param );
|
|
case NtUserGetWindowLongPtrA:
|
|
return get_window_long_ptr( hwnd, param, TRUE );
|
|
case NtUserGetWindowLongPtrW:
|
|
return get_window_long_ptr( hwnd, param, FALSE );
|
|
case NtUserGetWindowPlacement:
|
|
return get_window_placement( hwnd, (WINDOWPLACEMENT *)param );
|
|
case NtUserGetWindowRect:
|
|
return get_window_rect( hwnd, (RECT *)param, get_thread_dpi() );
|
|
case NtUserGetWindowRelative:
|
|
return HandleToUlong( get_window_relative( hwnd, param ));
|
|
case NtUserGetWindowThread:
|
|
return get_window_thread( hwnd, (DWORD *)param );
|
|
case NtUserGetWindowWord:
|
|
return get_window_word( hwnd, param );
|
|
case NtUserIsChild:
|
|
return is_child( hwnd, UlongToHandle(param) );
|
|
case NtUserKillSystemTimer:
|
|
return kill_system_timer( hwnd, param );
|
|
case NtUserMonitorFromWindow:
|
|
return HandleToUlong( monitor_from_window( hwnd, param, NtUserMonitorFromWindow ));
|
|
case NtUserScreenToClient:
|
|
return screen_to_client( hwnd, (POINT *)param );
|
|
case NtUserSetCaptureWindow:
|
|
return set_capture_window( hwnd, param, NULL );
|
|
case NtUserSetForegroundWindow:
|
|
return set_foreground_window( hwnd, param );
|
|
case NtUserSetWindowPixelFormat:
|
|
return set_window_pixel_format( hwnd, param );
|
|
/* temporary exports */
|
|
case NtUserIsWindowDrawable:
|
|
return is_window_drawable( hwnd, param );
|
|
case NtUserSetWindowStyle:
|
|
{
|
|
STYLESTRUCT *style = (void *)param;
|
|
return set_window_style( hwnd, style->styleNew, style->styleOld );
|
|
}
|
|
case NtUserSpyGetMsgName:
|
|
return (UINT_PTR)debugstr_msg_name( param, hwnd );
|
|
default:
|
|
FIXME( "invalid code %u\n", code );
|
|
return 0;
|
|
}
|
|
}
|