#include "precomp.h"

Include dependency graph for win.c:

Classes
struct	wm_gettext_override_data

struct	create_window_thread_params

struct	dialog_param

struct	dlg_parent_param

struct	parentdc_stat

struct	parentdc_test

struct	window_attributes

struct	smresult_thread_data

struct	set_foreground_thread_params

Macros
#define	SPI_GETDESKWALLPAPER 0x0073

#define	WM_SYSTIMER 0x0118

#define	LONG_PTR INT_PTR

#define	ULONG_PTR UINT_PTR

#define	COUNTOF(arr) (sizeof(arr)/sizeof(arr[0]))

#define	check_wnd_state(a, b, c, d) check_wnd_state_(__FILE__,__LINE__,a,b,c,d)

#define	check_active_state(a, b, c) check_active_state_(__FILE__,__LINE__,a,b,c)

#define	check_z_order(hwnd, next, prev, owner, topmost)

#define	TEST_MOUSEACTIVATE(A, B)

#define	SHOWSYSMETRIC(SM) trace(#SM "=%d\n", GetSystemMetrics(SM))

#define	parentdc_field_ok(t, w, r, f, got)

#define	parentdc_todo_field_ok(t, w, r, f, got)

#define	parentdc_rect_ok(t, w, r, got)

#define	parentdc_win_ok(t, w, got)

#define	parentdc_ok(t, got)

#define	nothing_todo {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}

#define	expect_menu(window, menu)

#define	expect_style(window, style) ok((ULONG)GetWindowLongA(window, GWL_STYLE) == (style), "expected style %x != %x\n", (LONG)(style), GetWindowLongA(window, GWL_STYLE))

#define	expect_ex_style(window, ex_style) ok((ULONG)GetWindowLongA(window, GWL_EXSTYLE) == (ex_style), "expected ex_style %x != %x\n", (LONG)(ex_style), GetWindowLongA(window, GWL_EXSTYLE))

#define	expect_gle_broken_9x(gle)

#define	NUMBER_OF_THICK_CHILD_TESTS 16

#define	SET_FOREGROUND_STEAL_1 0x01

#define	SET_FOREGROUND_SET_1 0x02

#define	SET_FOREGROUND_STEAL_2 0x04

#define	SET_FOREGROUND_SET_2 0x08

#define	SET_FOREGROUND_INJECT 0x10

Functions
void	dump_region (HRGN hrgn)

static	HWND (WINAPI *pGetAncestor)(HWND

static	BOOL (WINAPI *pGetWindowInfo)(HWND

static WINDOWINFO *static	UINT (WINAPI *pGetWindowModuleFileNameA)(HWND

static	HMONITOR (WINAPI *pMonitorFromPoint)(POINT

static	int (WINAPI *pGetWindowRgnBox)(HWND

static	DWORD (WINAPI *pSetLayout)(HDC hdc

static void	dump_minmax_info (const MINMAXINFO *minmax)

static void	flush_events (BOOL remove_messages)

static BOOL	wait_for_event (HANDLE event, int timeout)

static void	check_parents (HWND hwnd, HWND ga_parent, HWND gwl_parent, HWND get_parent, HWND gw_owner, HWND ga_root, HWND ga_root_owner)

static void	check_wnd_state_ (const char *file, int line, HWND active, HWND foreground, HWND focus, HWND capture)

static void	check_active_state_ (const char *file, int line, HWND active, HWND foreground, HWND focus)

static BOOL	ignore_message (UINT message)

static BOOL CALLBACK	EnumChildProc (HWND hwndChild, LPARAM lParam)

static BOOL CALLBACK	EnumChildProc1 (HWND hwndChild, LPARAM lParam)

static HWND	create_tool_window (LONG style, HWND parent)

static void	test_parent_owner (void)

static BOOL CALLBACK	enum_proc (HWND hwnd, LPARAM lParam)

static DWORD CALLBACK	enum_thread (void *arg)

static void	test_enum_thread_windows (void)

static LRESULT WINAPI	main_window_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	main_window_procW (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	tool_window_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static BOOL	RegisterWindowClasses (void)

static void	verify_window_info (const char hook, HWND hwnd, const WINDOWINFO info)

static void	FixedAdjustWindowRectEx (RECT *rc, LONG style, BOOL menu, LONG exstyle)

static void	wine_AdjustWindowRectEx (RECT *rect, LONG style, BOOL menu, LONG exStyle)

static void	test_nonclient_area (HWND hwnd)

static LRESULT CALLBACK	cbt_hook_proc (int nCode, WPARAM wParam, LPARAM lParam)

static void	test_shell_window (void)

static void	test_MDI_create (HWND parent, HWND mdi_client, INT_PTR first_id)

static void	test_MDI_child_stack (HWND mdi_client)

static void	MDI_ChildGetMinMaxInfo (HWND client, HWND hwnd, MINMAXINFO *lpMinMax)

static LRESULT WINAPI	mdi_child_wnd_proc_1 (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	mdi_child_wnd_proc_2 (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	mdi_main_wnd_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static BOOL	mdi_RegisterWindowClasses (void)

static void	test_mdi (void)

static void	test_icons (void)

static LRESULT WINAPI	nccalcsize_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_SetWindowPos (HWND hwnd, HWND hwnd2)

static void	test_SetMenu (HWND parent)

static void	test_window_tree (HWND parent, const DWORD style, const int order, int total)

static void	test_children_zorder (HWND parent)

static void	check_z_order_debug (HWND hwnd, HWND next, HWND prev, HWND owner, BOOL topmost, const char *file, int line)

static void	test_popup_zorder (HWND hwnd_D, HWND hwnd_E, DWORD style)

static void	test_vis_rgn (HWND hwnd)

static LRESULT WINAPI	set_focus_on_activate_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	test_SetFocus (HWND hwnd)

static void	test_SetActiveWindow (HWND hwnd)

static DWORD WINAPI	create_window_thread (void *param)

static void	test_SetForegroundWindow (HWND hwnd)

static LRESULT WINAPI	button_hook_proc (HWND button, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_capture_1 (void)

static void	test_capture_2 (void)

static void	test_capture_3 (HWND hwnd1, HWND hwnd2)

static LRESULT CALLBACK	test_capture_4_proc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

static void	test_capture_4 (void)

static BOOL	peek_message (MSG *msg)

static void	test_keyboard_input (HWND hwnd)

static BOOL	wait_for_message (MSG *msg)

static void	test_mouse_input (HWND hwnd)

static void	test_validatergn (HWND hwnd)

static void	nccalchelper (HWND hwnd, INT x, INT y, RECT *prc)

static void	test_nccalcscroll (HWND parent)

static void	test_SetParent (void)

static LRESULT WINAPI	StyleCheckProc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	register_style_check_class (void)

static void	check_window_style (DWORD dwStyleIn, DWORD dwExStyleIn, DWORD dwStyleOut, DWORD dwExStyleOut)

static void	test_window_styles (void)

static HWND	root_dialog (HWND hwnd)

static INT_PTR WINAPI	empty_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static INT_PTR WINAPI	empty_dlg_proc3 (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static INT_PTR WINAPI	empty_dlg_proc2 (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	check_dialog_style (DWORD style_in, DWORD ex_style_in, DWORD style_out, DWORD ex_style_out)

static void	test_dialog_styles (void)

static INT_PTR WINAPI	parent_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static INT_PTR WINAPI	reparent_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static INT_PTR WINAPI	reparent_owned_dlg_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	reparent_dialog_owner_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	post_quit_dialog_owner_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	destroy_dialog_owner_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_dialog_parent (void)

static void	test_scrollwindow (HWND hwnd)

static void	test_scrollvalidate (HWND parent)

static void	test_scroll (void)

static void	test_scrolldc (HWND parent)

static void	test_params (void)

static void	test_AWRwindow (LPCSTR class, LONG style, LONG exStyle, BOOL menu)

static BOOL	AWR_init (void)

static void	test_AWR_window_size (BOOL menu)

static void	test_AWR_flags (void)

static void	test_AdjustWindowRect (void)

static LRESULT WINAPI	redraw_window_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_redrawnow (void)

static LRESULT WINAPI	parentdc_window_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	zero_parentdc_stat (struct parentdc_stat *t)

static void	zero_parentdc_test (struct parentdc_test *t)

static void	test_csparentdc (void)

static LRESULT WINAPI	def_window_procA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	def_window_procW (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_IsWindowUnicode (void)

static LRESULT CALLBACK	minmax_wnd_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static LRESULT CALLBACK	winsizes_wnd_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	test_CreateWindow (void)

static int	check_error (DWORD actual, DWORD expected)

static void	test_SetWindowLong (void)

static LRESULT WINAPI	check_style_wnd_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

static void	test_set_window_style (void)

static void	test_ShowWindow (void)

static DWORD CALLBACK	gettext_msg_thread (LPVOID arg)

static DWORD CALLBACK	settext_msg_thread (LPVOID arg)

static void	test_gettext (void)

static void	test_GetUpdateRect (void)

static LRESULT CALLBACK	TestExposedRegion_WndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

static void	test_Expose (void)

static LRESULT CALLBACK	TestNCRedraw_WndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

static void	run_NCRedrawLoop (UINT flags)

static void	test_NCRedraw (void)

static void	test_GetWindowModuleFileName (void)

static void	test_hwnd_message (void)

static void	test_layered_window (void)

static LRESULT CALLBACK	fullscreen_wnd_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	test_fullscreen (void)

static LRESULT WINAPI	test_thick_child_size_winproc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_thick_child_size (HWND parentWindow)

static void	test_handles (HWND full_hwnd)

static void	test_winregion (void)

static void	test_rtl_layout (void)

static void	test_FlashWindow (void)

static void	test_FlashWindowEx (void)

static void	test_FindWindowEx (void)

static void	test_GetLastActivePopup (void)

static LRESULT WINAPI	my_httrasparent_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static LRESULT WINAPI	my_window_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	create_window_tree (HWND parent, HWND *window, int size)

static void	get_window_attributes (HWND hwnd, struct window_attributes *attrs)

static int	window_to_index (HWND hwnd, HWND *window, int size)

static void	test_child_window_from_point (void)

static void	simulate_click (int x, int y)

static LRESULT WINAPI	static_hook_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	window_from_point_proc (HWND parent)

static void	test_window_from_point (const char *argv0)

static void	test_map_points (void)

static void	test_update_region (void)

static void	test_window_without_child_style (void)

static LRESULT WINAPI	smresult_wndproc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static DWORD WINAPI	smresult_thread_proc (void *param)

static void	test_smresult (void)

static void	test_GetMessagePos (void)

static DWORD WINAPI	set_foreground_thread (void *params)

static void	test_activateapp (HWND window1)

static LRESULT WINAPI	winproc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	winproc_convA (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static LRESULT WINAPI	winproc_convW (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	test_winproc_handles (const char *argv0)

static void	test_winproc_limit (void)

static void	test_deferwindowpos (void)

	START_TEST (win)

Variables
static	UINT

static WINDOWINFO *static	LPSTR

static COLORREF BYTE DWORD *static	COLORREF

static COLORREF BYTE DWORD *static	BYTE

static COLORREF BYTE DWORD *static	DWORD

static	HDC

static const UPDATELAYEREDWINDOWINFO *static	LPMONITORINFO

static	LPRECT

static BOOL	bInvert

static DWORD	layout

static HRGN	hrgn

static BOOL	test_lbuttondown_flag

static DWORD	num_gettext_msgs

static DWORD	num_settext_msgs

static HWND	hwndMessage

static HWND	hwndMain

static HWND	hwndMain2

static HHOOK	hhook

static BOOL	app_activated

static BOOL	app_deactivated

static const char *	szAWRClass = "Winsize"

static HMENU	hmenu

static DWORD	our_pid

static BOOL	is_win9x = FALSE

static struct wm_gettext_override_data	g_wm_gettext_override

static const WCHAR	mainclassW [] = {'M','a','i','n','W','i','n','d','o','w','C','l','a','s','s','W',0}

static char	mdi_lParam_test_message [] = "just a test string"

static WNDPROC	old_button_proc

static ATOM	atomStyleCheckClass

static LRESULT	expected_id

static int	redrawComplete

static int	WMPAINT_count

static int	expected_cx

static int	expected_cy

static RECT	expected_rect

static RECT	broken_rect

static MONITORINFO	mi

static BOOL	test_thick_child_got_minmax

static const char *	test_thick_child_name

static LONG	test_thick_child_style

static LONG	test_thick_child_exStyle

static WNDPROC	def_static_proc

static BOOL	got_hittest

static const WCHAR	textW [] = {'t','e','x','t',0}

Macro Definition Documentation

◆ check_active_state

#define check_active_state	(	a,
		b,
		c
	)	check_active_state_(__FILE__,__LINE__,a,b,c)

Definition at line 159 of file win.c.

◆ check_wnd_state

#define check_wnd_state	(	a,
		b,
		c,
		d
	)	check_wnd_state_(__FILE__,__LINE__,a,b,c,d)

Definition at line 143 of file win.c.

◆ check_z_order

#define check_z_order	(	hwnd,
		next,
		prev,
		owner,
		topmost
	)

Value:

check_z_order_debug((hwnd), (next), (prev), (owner), (topmost), \

__FILE__, __LINE__)

Definition: rand_nt.c:6

check_z_order_debug

static void check_z_order_debug(HWND hwnd, HWND next, HWND prev, HWND owner, BOOL topmost, const char *file, int line)

Definition: win.c:2795

hwnd

_In_ LONG _In_ HWND hwnd

Definition: winddi.h:4023

Definition at line 2791 of file win.c.

◆ COUNTOF

#define COUNTOF ( arr ) (sizeof(arr)/sizeof(arr[0]))

Definition at line 71 of file win.c.

◆ expect_ex_style

#define expect_ex_style	(	window,
		ex_style
	)	ok((ULONG)GetWindowLongA(window, GWL_EXSTYLE) == (ex_style), "expected ex_style %x != %x\n", (LONG)(ex_style), GetWindowLongA(window, GWL_EXSTYLE))

◆ expect_gle_broken_9x

#define expect_gle_broken_9x ( gle )

Value:

    ok(GetLastError() == gle ||\
       broken(GetLastError() == 0xdeadbeef),\
       "IsMenu set error %d\n", GetLastError())

◆ expect_menu

#define expect_menu	(	window,
		menu
	)

Value:

    SetLastError(0xdeadbeef); \
    res = (GetMenu(window) == (HMENU)menu); \
    ok(res, "GetMenu error %d\n", GetLastError())

◆ expect_style

#define expect_style	(	window,
		style
	)	ok((ULONG)GetWindowLongA(window, GWL_STYLE) == (style), "expected style %x != %x\n", (LONG)(style), GetWindowLongA(window, GWL_STYLE))

◆ LONG_PTR

#define LONG_PTR INT_PTR

Definition at line 33 of file win.c.

◆ nothing_todo

#define nothing_todo {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}

◆ NUMBER_OF_THICK_CHILD_TESTS

#define NUMBER_OF_THICK_CHILD_TESTS 16

Definition at line 7609 of file win.c.

◆ parentdc_field_ok

#define parentdc_field_ok	(	t,
		w,
		r,
		f,
		got
	)

Value:

  ok (t.w.r.f==got.w.r.f, "window " #w ", rect " #r ", field " #f \
      ": expected %d, got %d\n", \
      t.w.r.f, got.w.r.f)

Definition at line 5485 of file win.c.

◆ parentdc_ok

#define parentdc_ok	(	t,
		got
	)

Value:

  parentdc_win_ok(t, main, got); \
  parentdc_win_ok(t, child1, got); \
  parentdc_win_ok(t, child2, got);

Definition at line 5505 of file win.c.

◆ parentdc_rect_ok

#define parentdc_rect_ok	(	t,
		w,
		r,
		got
	)

Value:

  parentdc_todo_field_ok(t, w, r, left, got); \
  parentdc_todo_field_ok(t, w, r, top, got); \
  parentdc_todo_field_ok(t, w, r, right, got); \
  parentdc_todo_field_ok(t, w, r, bottom, got);

Definition at line 5494 of file win.c.

◆ parentdc_todo_field_ok

#define parentdc_todo_field_ok	(	t,
		w,
		r,
		f,
		got
	)

Value:

todo_wine_if (t.w##_todo.r.f) \

parentdc_field_ok(t, w, r, f, got);

todo_wine_if

#define todo_wine_if(is_todo)

Definition: custom.c:76

Definition at line 5490 of file win.c.

◆ parentdc_win_ok

#define parentdc_win_ok	(	t,
		w,
		got
	)

Value:

  parentdc_rect_ok(t, w, client, got); \
  parentdc_rect_ok(t, w, clip, got); \
  parentdc_rect_ok(t, w, paint, got);

Definition at line 5500 of file win.c.

◆ SET_FOREGROUND_INJECT

#define SET_FOREGROUND_INJECT 0x10

Definition at line 9011 of file win.c.

◆ SET_FOREGROUND_SET_1

#define SET_FOREGROUND_SET_1 0x02

Definition at line 9008 of file win.c.

◆ SET_FOREGROUND_SET_2

#define SET_FOREGROUND_SET_2 0x08

Definition at line 9010 of file win.c.

◆ SET_FOREGROUND_STEAL_1

#define SET_FOREGROUND_STEAL_1 0x01

Definition at line 9007 of file win.c.

◆ SET_FOREGROUND_STEAL_2

#define SET_FOREGROUND_STEAL_2 0x04

Definition at line 9009 of file win.c.

◆ SHOWSYSMETRIC

#define SHOWSYSMETRIC ( SM ) trace(#SM "=%d\n", GetSystemMetrics(SM))

Definition at line 5343 of file win.c.

◆ SPI_GETDESKWALLPAPER

#define SPI_GETDESKWALLPAPER 0x0073

Definition at line 26 of file win.c.

◆ TEST_MOUSEACTIVATE

#define TEST_MOUSEACTIVATE	(	A,
		B
	)

Value:

res = SendMessageA(hwnd, WM_MOUSEACTIVATE, (WPARAM)hwnd, (LPARAM)MAKELRESULT(A,0)); \

ok(res == B, "WM_MOUSEACTIVATE for %s returned %ld\n", #A, res);

A

Definition: ehthrow.cxx:93

B

Definition: ehthrow.cxx:54

LPARAM

LONG_PTR LPARAM

Definition: windef.h:208

WPARAM

UINT_PTR WPARAM

Definition: windef.h:207

SendMessageA

LRESULT WINAPI SendMessageA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

MAKELRESULT

#define MAKELRESULT(l, h)

Definition: winuser.h:4009

WM_MOUSEACTIVATE

#define WM_MOUSEACTIVATE

Definition: winuser.h:1636

◆ ULONG_PTR

#define ULONG_PTR UINT_PTR

Definition at line 34 of file win.c.

◆ WM_SYSTIMER

#define WM_SYSTIMER 0x0118

Definition at line 30 of file win.c.

Function Documentation

◆ AWR_init()

static BOOL AWR_init ( void )

static

Definition at line 5262 of file win.c.

{
    WNDCLASSA class;
 
    class.style         = CS_HREDRAW | CS_VREDRAW;
    class.lpfnWndProc     = DefWindowProcA;
    class.cbClsExtra    = 0;
    class.cbWndExtra    = 0;
    class.hInstance     = 0;
    class.hIcon         = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
    class.hCursor       = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    class.hbrBackground = 0;
    class.lpszMenuName  = 0;
    class.lpszClassName = szAWRClass;
 
    if (!RegisterClassA(&class)) {
    ok(FALSE, "RegisterClass failed\n");
    return FALSE;
    }
 
    hmenu = CreateMenu();
    if (!hmenu)
    return FALSE;
    ok(hmenu != 0, "Failed to create menu\n");
    ok(AppendMenuA(hmenu, MF_STRING, 1, "Test!"), "Failed to create menu item\n");
 
    return TRUE;
}

Referenced by test_AdjustWindowRect().

◆ BOOL()

static BOOL ( WINAPI * pGetWindowInfo )

static

◆ button_hook_proc()

static LRESULT WINAPI button_hook_proc	(	HWND	button,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 3291 of file win.c.

{
    LRESULT ret;
    USHORT key_state;
 
    key_state = GetKeyState(VK_LBUTTON);
    ok(!(key_state & 0x8000), "VK_LBUTTON should not be pressed, state %04x\n", key_state);
 
    ret = CallWindowProcA(old_button_proc, button, msg, wparam, lparam);
 
    if (msg == WM_LBUTTONDOWN)
    {
    HWND hwnd, capture;
 
    check_wnd_state(button, button, button, button);
 
    hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL);
    assert(hwnd);
    trace("hwnd %p\n", hwnd);
 
    check_wnd_state(button, button, button, button);
 
    ShowWindow(hwnd, SW_SHOWNOACTIVATE);
 
    check_wnd_state(button, button, button, button);
 
    DestroyWindow(hwnd);
 
    hwnd = CreateWindowExA(0, "static", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL);
    assert(hwnd);
    trace("hwnd %p\n", hwnd);
 
    check_wnd_state(button, button, button, button);
 
    /* button wnd proc should release capture on WM_KILLFOCUS if it does
     * match internal button state.
     */
    SendMessageA(button, WM_KILLFOCUS, 0, 0);
    check_wnd_state(button, button, button, 0);
 
    ShowWindow(hwnd, SW_SHOW);
    check_wnd_state(hwnd, hwnd, hwnd, 0);
 
    capture = SetCapture(hwnd);
    ok(capture == 0, "SetCapture() = %p\n", capture);
 
    check_wnd_state(hwnd, hwnd, hwnd, hwnd);
 
    DestroyWindow(hwnd);
 
    check_wnd_state(button, 0, button, 0);
    }
 
    return ret;
}

Referenced by test_capture_1().

◆ cbt_hook_proc()

static LRESULT CALLBACK cbt_hook_proc	(	int	nCode,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 1118 of file win.c.

{ 
    static const char *CBT_code_name[10] = {
    "HCBT_MOVESIZE",
    "HCBT_MINMAX",
    "HCBT_QS",
    "HCBT_CREATEWND",
    "HCBT_DESTROYWND",
    "HCBT_ACTIVATE",
    "HCBT_CLICKSKIPPED",
    "HCBT_KEYSKIPPED",
    "HCBT_SYSCOMMAND",
    "HCBT_SETFOCUS" };
    const char *code_name = (nCode >= 0 && nCode <= HCBT_SETFOCUS) ? CBT_code_name[nCode] : "Unknown";
    HWND hwnd = (HWND)wParam;
 
    switch (nCode)
    {
    case HCBT_CREATEWND:
    {
        static const RECT rc_null;
        RECT rc;
        LONG style;
        CBT_CREATEWNDA *createwnd = (CBT_CREATEWNDA *)lParam;
        ok(createwnd->hwndInsertAfter == HWND_TOP, "hwndInsertAfter should be always HWND_TOP\n");
 
            if (pGetWindowInfo)
            {
                WINDOWINFO info;
                info.cbSize = sizeof(WINDOWINFO);
                ok(pGetWindowInfo(hwnd, &info), "GetWindowInfo should not fail\n");
                verify_window_info(code_name, hwnd, &info);
            }
 
        /* WS_VISIBLE should be turned off yet */
        style = createwnd->lpcs->style & ~WS_VISIBLE;
        ok(style == GetWindowLongA(hwnd, GWL_STYLE),
        "style of hwnd and style in the CREATESTRUCT do not match: %08x != %08x\n",
        GetWindowLongA(hwnd, GWL_STYLE), style);
 
            if (0)
            {
            /* Uncomment this once the test succeeds in all cases */
        if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
        {
        ok(GetParent(hwnd) == hwndMessage,
           "wrong result from GetParent %p: message window %p\n",
           GetParent(hwnd), hwndMessage);
        }
        else
        ok(!GetParent(hwnd), "GetParent should return 0 at this point\n");
 
        ok(!GetWindow(hwnd, GW_OWNER), "GW_OWNER should be set to 0 at this point\n");
            }
            if (0)
            {
        /* while NT assigns GW_HWNDFIRST/LAST some values at this point,
         * Win9x still has them set to 0.
         */
        ok(GetWindow(hwnd, GW_HWNDFIRST) != 0, "GW_HWNDFIRST should not be set to 0 at this point\n");
        ok(GetWindow(hwnd, GW_HWNDLAST) != 0, "GW_HWNDLAST should not be set to 0 at this point\n");
            }
        ok(!GetWindow(hwnd, GW_HWNDPREV), "GW_HWNDPREV should be set to 0 at this point\n");
        ok(!GetWindow(hwnd, GW_HWNDNEXT), "GW_HWNDNEXT should be set to 0 at this point\n");
 
            if (0)
            {
            /* Uncomment this once the test succeeds in all cases */
        if (pGetAncestor)
        {
        ok(pGetAncestor(hwnd, GA_PARENT) == hwndMessage, "GA_PARENT should be set to hwndMessage at this point\n");
        ok(pGetAncestor(hwnd, GA_ROOT) == hwnd,
           "GA_ROOT is set to %p, expected %p\n", pGetAncestor(hwnd, GA_ROOT), hwnd);
 
        if ((style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
            ok(pGetAncestor(hwnd, GA_ROOTOWNER) == hwndMessage,
               "GA_ROOTOWNER should be set to hwndMessage at this point\n");
        else
            ok(pGetAncestor(hwnd, GA_ROOTOWNER) == hwnd,
               "GA_ROOTOWNER is set to %p, expected %p\n", pGetAncestor(hwnd, GA_ROOTOWNER), hwnd);
            }
 
        ok(GetWindowRect(hwnd, &rc), "GetWindowRect failed\n");
        ok(EqualRect(&rc, &rc_null), "window rect should be set to 0 HCBT_CREATEWND\n");
        ok(GetClientRect(hwnd, &rc), "GetClientRect failed\n");
        ok(EqualRect(&rc, &rc_null), "client rect should be set to 0 on HCBT_CREATEWND\n");
            }
        break;
    }
    case HCBT_MOVESIZE:
    case HCBT_MINMAX:
    case HCBT_ACTIVATE:
    if (pGetWindowInfo && IsWindow(hwnd))
    {
        WINDOWINFO info;
 
        /* Win98 actually does check the info.cbSize and doesn't allow
         * it to be anything except sizeof(WINDOWINFO), while Win95, Win2k,
         * WinXP do not check it at all.
         */
        info.cbSize = sizeof(WINDOWINFO);
        ok(pGetWindowInfo(hwnd, &info), "GetWindowInfo should not fail\n");
        verify_window_info(code_name, hwnd, &info);
    }
        break;
    /* window state is undefined */
    case HCBT_SETFOCUS:
    case HCBT_DESTROYWND:
        break;
    default:
        break;
    }
 
    return CallNextHookEx(hhook, nCode, wParam, lParam);
}

Referenced by START_TEST().

◆ check_active_state_()

static void check_active_state_	(	const char *	file,
		int	line,
		HWND	active,
		HWND	foreground,
		HWND	focus
	)

static

Definition at line 160 of file win.c.

{
    ok_(file, line)(active == GetActiveWindow(), "GetActiveWindow() = %p\n", GetActiveWindow());
    /* only check foreground if it belongs to the current thread */
    /* foreground can be moved to a different app pretty much at any time */
    if (foreground && GetForegroundWindow() &&
        GetWindowThreadProcessId(GetForegroundWindow(), NULL) == GetCurrentThreadId())
        disable_success_count
        ok_(file, line)(foreground == GetForegroundWindow(), "GetForegroundWindow() = %p\n", GetForegroundWindow());
    ok_(file, line)(focus == GetFocus(), "GetFocus() = %p\n", GetFocus());
}

◆ check_dialog_style()

static void check_dialog_style	(	DWORD	style_in,
		DWORD	ex_style_in,
		DWORD	style_out,
		DWORD	ex_style_out
	)

static

Definition at line 4470 of file win.c.

{
    struct
    {
        DLGTEMPLATE dt;
        WORD menu_name;
        WORD class_id;
        WORD class_atom;
        WCHAR caption[1];
    } dlg_data;
    DWORD style, ex_style;
    HWND hwnd, grand_parent = 0, parent = 0;
    struct dialog_param param;
    LRESULT id, ret;
 
    if (style_in & WS_CHILD)
    {
        grand_parent = CreateWindowExA(0, "static", NULL, WS_OVERLAPPEDWINDOW,
                                0, 0, 0, 0, NULL, NULL, NULL, NULL);
        ok(grand_parent != 0, "grand_parent creation failed\n");
    }
 
    parent = CreateWindowExA(0, "static", NULL, style_in,
                             0, 0, 0, 0, grand_parent, NULL, NULL, NULL);
    ok(parent != 0, "parent creation failed, style %#x\n", style_in);
 
    dlg_data.dt.style = style_in;
    dlg_data.dt.dwExtendedStyle = ex_style_in;
    dlg_data.dt.cdit = 0;
    dlg_data.dt.x = 0;
    dlg_data.dt.y = 0;
    dlg_data.dt.cx = 100;
    dlg_data.dt.cy = 100;
    dlg_data.menu_name = 0;
    dlg_data.class_id = 0;
    dlg_data.class_atom = 0;
    dlg_data.caption[0] = 0;
 
    hwnd = CreateDialogIndirectParamA(GetModuleHandleA(NULL), &dlg_data.dt, parent, empty_dlg_proc, 0);
    ok(hwnd != 0, "dialog creation failed, style %#x, exstyle %#x\n", style_in, ex_style_in);
 
    id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
    ok(id == MAKELONG(IDOK,DC_HASDEFID), "expected (IDOK,DC_HASDEFID), got %08lx\n", id);
    ret = DefDlgProcA(hwnd, DM_SETDEFID, 0x1111, 0);
    ok(ret, "DefDlgProc(DM_SETDEFID) failed\n");
    id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
    ok(id == MAKELONG(0x1111,DC_HASDEFID), "expected (0x1111,DC_HASDEFID), got %08lx\n", id);
 
    flush_events( TRUE );
 
    style = GetWindowLongA(hwnd, GWL_STYLE);
    ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok(style == (style_out | DS_3DLOOK), "got %#x\n", style);
    ok(ex_style == ex_style_out, "expected ex_style %#x, got %#x\n", ex_style_out, ex_style);
 
    ok(IsWindowEnabled(parent), "wrong parent state (dialog style %#x)\n", style_in);
 
    /* try setting the styles explicitly */
    SetWindowLongA(hwnd, GWL_EXSTYLE, ex_style_in);
    style = GetWindowLongA(hwnd, GWL_STYLE);
    ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok(style == (style_out | DS_3DLOOK), "got %#x\n", style);
    /* WS_EX_WINDOWEDGE can't always be changed */
    if (ex_style_in & WS_EX_DLGMODALFRAME)
        ex_style_out = ex_style_in | WS_EX_WINDOWEDGE;
    else if ((style & (WS_DLGFRAME | WS_THICKFRAME)) && !(ex_style_in & WS_EX_STATICEDGE))
        ex_style_out = ex_style_in | WS_EX_WINDOWEDGE;
    else
        ex_style_out = ex_style_in & ~WS_EX_WINDOWEDGE;
    ok(ex_style == ex_style_out, "expected ex_style %#x, got %#x\n", ex_style_out, ex_style);
 
    SetWindowLongA(hwnd, GWL_STYLE, style_in);
    style = GetWindowLongA(hwnd, GWL_STYLE);
    ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
    /* WS_CLIPSIBLINGS can't be reset on top-level windows */
    if ((style_in & (WS_CHILD | WS_POPUP)) == WS_CHILD) style_out = style_in;
    else style_out = style_in | WS_CLIPSIBLINGS;
    ok(style == style_out, "expected style %#x, got %#x\n", style_out, style);
    /* WS_EX_WINDOWEDGE can't always be changed */
    if (ex_style_in & WS_EX_DLGMODALFRAME)
        ex_style_out = ex_style_in | WS_EX_WINDOWEDGE;
    else if ((style & (WS_DLGFRAME | WS_THICKFRAME)) && !(ex_style_in & WS_EX_STATICEDGE))
        ex_style_out = ex_style_in | WS_EX_WINDOWEDGE;
    else
        ex_style_out = ex_style_in & ~WS_EX_WINDOWEDGE;
    /* FIXME: Remove the condition below once Wine is fixed */
    todo_wine_if (ex_style != ex_style_out)
        ok(ex_style == ex_style_out, "expected ex_style %#x, got %#x\n", ex_style_out, ex_style);
 
    DestroyWindow(hwnd);
 
    param.parent = parent;
    param.grand_parent = grand_parent;
    param.dlg_data = &dlg_data.dt;
    DialogBoxIndirectParamA(GetModuleHandleA(NULL), &dlg_data.dt, parent, empty_dlg_proc2, (LPARAM)&param);
 
    ok(IsWindowEnabled(parent), "wrong parent state (dialog style %#x)\n", style_in);
    if (grand_parent)
        ok(IsWindowEnabled(grand_parent), "wrong grand parent state (dialog style %#x)\n", style_in);
 
    DestroyWindow(parent);
    DestroyWindow(grand_parent);
}

Referenced by test_dialog_styles().

◆ check_error()

static int check_error	(	DWORD	actual,
		DWORD	expected
	)

static

Definition at line 6298 of file win.c.

{
    static int sets_last_error = -1;
    if (sets_last_error == -1)
        sets_last_error = (actual != 0xdeadbeef);
    return (!sets_last_error && (actual == 0xdeadbeef)) || (actual == expected);
}

◆ check_parents()

static void check_parents	(	HWND	hwnd,
		HWND	ga_parent,
		HWND	gwl_parent,
		HWND	get_parent,
		HWND	gw_owner,
		HWND	ga_root,
		HWND	ga_root_owner
	)

static

Definition at line 118 of file win.c.

{
    HWND res;
 
    if (pGetAncestor)
    {
        res = pGetAncestor( hwnd, GA_PARENT );
        ok( res == ga_parent, "Wrong result for GA_PARENT %p expected %p\n", res, ga_parent );
    }
    res = (HWND)GetWindowLongPtrA( hwnd, GWLP_HWNDPARENT );
    ok( res == gwl_parent, "Wrong result for GWL_HWNDPARENT %p expected %p\n", res, gwl_parent );
    res = GetParent( hwnd );
    ok( res == get_parent, "Wrong result for GetParent %p expected %p\n", res, get_parent );
    res = GetWindow( hwnd, GW_OWNER );
    ok( res == gw_owner, "Wrong result for GW_OWNER %p expected %p\n", res, gw_owner );
    if (pGetAncestor)
    {
        res = pGetAncestor( hwnd, GA_ROOT );
        ok( res == ga_root, "Wrong result for GA_ROOT %p expected %p\n", res, ga_root );
        res = pGetAncestor( hwnd, GA_ROOTOWNER );
        ok( res == ga_root_owner, "Wrong result for GA_ROOTOWNER %p expected %p\n", res, ga_root_owner );
    }
}

Referenced by parent_dlg_proc(), test_dialog_parent(), test_parent_owner(), and test_SetParent().

◆ check_style_wnd_proc()

static LRESULT WINAPI check_style_wnd_proc	(	HWND	hwnd,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

static

Definition at line 6349 of file win.c.

{
    const STYLESTRUCT *expected = (STYLESTRUCT *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
    const STYLESTRUCT *got = (STYLESTRUCT *)lParam;
 
    if (message == WM_STYLECHANGING && wParam == GWL_STYLE)
    {
        ok(got->styleOld == expected[0].styleOld, "expected old style %#x, got %#x\n",
            expected[0].styleOld, got->styleOld);
        ok(got->styleNew == expected[0].styleNew, "expected new style %#x, got %#x\n",
            expected[0].styleNew, got->styleNew);
    }
    else if (message == WM_STYLECHANGED && wParam == GWL_STYLE)
    {
        ok(got->styleOld == expected[1].styleOld, "expected old style %#x, got %#x\n",
            expected[1].styleOld, got->styleOld);
        ok(got->styleNew == expected[1].styleNew, "expected new style %#x, got %#x\n",
            expected[1].styleNew, got->styleNew);
    }
 
    return DefWindowProcA(hwnd, message, wParam, lParam);
}

Referenced by test_set_window_style().

◆ check_window_style()

static void check_window_style	(	DWORD	dwStyleIn,
		DWORD	dwExStyleIn,
		DWORD	dwStyleOut,
		DWORD	dwExStyleOut
	)

static

Definition at line 4206 of file win.c.

{
    DWORD dwActualStyle;
    DWORD dwActualExStyle;
    STYLESTRUCT ss;
    HWND hwnd;
    HWND hwndParent = NULL;
 
    ss.styleNew = dwStyleIn;
    ss.styleOld = dwExStyleIn;
 
    if (dwStyleIn & WS_CHILD)
    {
        hwndParent = CreateWindowExA(0, (LPCSTR)MAKEINTATOM(atomStyleCheckClass), NULL,
            WS_OVERLAPPEDWINDOW, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
    }
 
    hwnd = CreateWindowExA(dwExStyleIn, (LPCSTR)MAKEINTATOM(atomStyleCheckClass), NULL,
                    dwStyleIn, 0, 0, 0, 0, hwndParent, NULL, NULL, &ss);
    assert(hwnd);
 
    flush_events( TRUE );
 
    dwActualStyle = GetWindowLongA(hwnd, GWL_STYLE);
    dwActualExStyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok(dwActualStyle == dwStyleOut, "expected style %#x, got %#x\n", dwStyleOut, dwActualStyle);
    ok(dwActualExStyle == dwExStyleOut, "expected ex_style %#x, got %#x\n", dwExStyleOut, dwActualExStyle);
 
    /* try setting the styles explicitly */
    SetWindowLongA( hwnd, GWL_EXSTYLE, dwExStyleIn );
    dwActualStyle = GetWindowLongA(hwnd, GWL_STYLE);
    dwActualExStyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
    /* WS_EX_WINDOWEDGE can't always be changed */
    if (dwExStyleIn & WS_EX_DLGMODALFRAME)
        dwExStyleOut = dwExStyleIn | WS_EX_WINDOWEDGE;
    else if ((dwActualStyle & (WS_DLGFRAME | WS_THICKFRAME)) && !(dwExStyleIn & WS_EX_STATICEDGE))
        dwExStyleOut = dwExStyleIn | WS_EX_WINDOWEDGE;
    else
        dwExStyleOut = dwExStyleIn & ~WS_EX_WINDOWEDGE;
    ok(dwActualStyle == dwStyleOut, "expected style %#x, got %#x\n", dwStyleOut, dwActualStyle);
    ok(dwActualExStyle == dwExStyleOut, "expected ex_style %#x, got %#x\n", dwExStyleOut, dwActualExStyle);
 
    SetWindowLongA( hwnd, GWL_STYLE, dwStyleIn );
    dwActualStyle = GetWindowLongA(hwnd, GWL_STYLE);
    dwActualExStyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
    /* WS_CLIPSIBLINGS can't be reset on top-level windows */
    if ((dwStyleIn & (WS_CHILD|WS_POPUP)) == WS_CHILD) dwStyleOut = dwStyleIn;
    else dwStyleOut = dwStyleIn | WS_CLIPSIBLINGS;
    /* WS_EX_WINDOWEDGE can't always be changed */
    if (dwExStyleIn & WS_EX_DLGMODALFRAME)
        dwExStyleOut = dwExStyleIn | WS_EX_WINDOWEDGE;
    else if ((dwActualStyle & (WS_DLGFRAME | WS_THICKFRAME)) && !(dwExStyleIn & WS_EX_STATICEDGE))
        dwExStyleOut = dwExStyleIn | WS_EX_WINDOWEDGE;
    else
        dwExStyleOut = dwExStyleIn & ~WS_EX_WINDOWEDGE;
    ok(dwActualStyle == dwStyleOut, "expected style %#x, got %#x\n", dwStyleOut, dwActualStyle);
    /* FIXME: Remove the condition below once Wine is fixed */
    todo_wine_if (dwActualExStyle != dwExStyleOut)
        ok(dwActualExStyle == dwExStyleOut, "expected ex_style %#x, got %#x\n", dwExStyleOut, dwActualExStyle);
 
    DestroyWindow(hwnd);
    if (hwndParent) DestroyWindow(hwndParent);
}

Referenced by test_window_styles().

◆ check_wnd_state_()

static void check_wnd_state_	(	const char *	file,
		int	line,
		HWND	active,
		HWND	foreground,
		HWND	focus,
		HWND	capture
	)

static

Definition at line 144 of file win.c.

{
    ok_(file, line)(active == GetActiveWindow(), "GetActiveWindow() = %p\n", GetActiveWindow());
    /* only check foreground if it belongs to the current thread */
    /* foreground can be moved to a different app pretty much at any time */
    if (foreground && GetForegroundWindow() &&
        GetWindowThreadProcessId(GetForegroundWindow(), NULL) == GetCurrentThreadId())
        disable_success_count
        ok_(file, line)(foreground == GetForegroundWindow(), "GetForegroundWindow() = %p\n", GetForegroundWindow());
    ok_(file, line)(focus == GetFocus(), "GetFocus() = %p\n", GetFocus());
    ok_(file, line)(capture == GetCapture(), "GetCapture() = %p\n", GetCapture());
}

◆ check_z_order_debug()

static void check_z_order_debug	(	HWND	hwnd,
		HWND	next,
		HWND	prev,
		HWND	owner,
		BOOL	topmost,
		const char *	file,
		int	line
	)

static

Definition at line 2795 of file win.c.

{
    HWND test;
    DWORD ex_style;
 
    test = GetWindow(hwnd, GW_HWNDNEXT);
    /* skip foreign windows */
    while (test && test != next &&
           (GetWindowThreadProcessId(test, NULL) != our_pid ||
            UlongToHandle(GetWindowLongPtrA(test, GWLP_HINSTANCE)) != GetModuleHandleA(NULL) ||
            GetWindow(test, GW_OWNER) == next))
    {
        /*trace("skipping next %p (%p)\n", test, UlongToHandle(GetWindowLongPtr(test, GWLP_HINSTANCE)));*/
        test = GetWindow(test, GW_HWNDNEXT);
    }
    ok_(file, line)(next == test, "%p: expected next %p, got %p\n", hwnd, next, test);
 
    test = GetWindow(hwnd, GW_HWNDPREV);
    /* skip foreign windows */
    while (test && test != prev &&
           (GetWindowThreadProcessId(test, NULL) != our_pid ||
            UlongToHandle(GetWindowLongPtrA(test, GWLP_HINSTANCE)) != GetModuleHandleA(NULL) ||
            GetWindow(test, GW_OWNER) == hwnd))
    {
        /*trace("skipping prev %p (%p)\n", test, UlongToHandle(GetWindowLongPtr(test, GWLP_HINSTANCE)));*/
        test = GetWindow(test, GW_HWNDPREV);
    }
    ok_(file, line)(prev == test, "%p: expected prev %p, got %p\n", hwnd, prev, test);
 
    test = GetWindow(hwnd, GW_OWNER);
    ok_(file, line)(owner == test, "%p: expected owner %p, got %p\n", hwnd, owner, test);
 
    ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
    ok_(file, line)(!(ex_style & WS_EX_TOPMOST) == !topmost, "%p: expected %stopmost\n",
                    hwnd, topmost ? "" : "NOT ");
}

◆ create_tool_window()

static HWND create_tool_window	(	LONG	style,
		HWND	parent
	)

static

Definition at line 201 of file win.c.

{
    HWND ret = CreateWindowExA(0, "ToolWindowClass", "Tool window 1", style,
                               0, 0, 100, 100, parent, 0, 0, NULL );
    ok( ret != 0, "Creation failed\n" );
    return ret;
}

Referenced by test_parent_owner(), and test_SetWindowPos().

◆ create_window_thread()

static DWORD WINAPI create_window_thread ( void * param )

static

Definition at line 3146 of file win.c.

{
    struct create_window_thread_params *p = param;
    DWORD res;
    BOOL ret;
 
    p->window = CreateWindowA("static", NULL, WS_POPUP | WS_VISIBLE, 0, 0, 0, 0, 0, 0, 0, 0);
 
    ret = SetEvent(p->window_created);
    ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());
 
    res = WaitForSingleObject(p->test_finished, INFINITE);
    ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
 
    DestroyWindow(p->window);
    return 0;
}

Referenced by test_SetForegroundWindow().

◆ create_window_tree()

static void create_window_tree	(	HWND	parent,
		HWND *	window,
		int	size
	)

static

Definition at line 8088 of file win.c.

{
    static const DWORD style[] = { 0, WS_VISIBLE, WS_DISABLED, WS_VISIBLE | WS_DISABLED };
    int i, pos;
 
    memset(window, 0, size * sizeof(window[0]));
 
    pos = 0;
    for (i = 0; i < sizeof(style)/sizeof(style[0]); i++)
    {
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "my_window", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "my_window", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
 
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "my_httrasparent", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "my_httrasparent", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
 
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "my_button", NULL, style[i] | WS_CHILD | BS_GROUPBOX,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "my_button", NULL, style[i] | WS_CHILD | BS_GROUPBOX,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "my_button", NULL, style[i] | WS_CHILD | BS_PUSHBUTTON,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "my_button", NULL, style[i] | WS_CHILD | BS_PUSHBUTTON,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
 
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "Button", NULL, style[i] | WS_CHILD | BS_GROUPBOX,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "Button", NULL, style[i] | WS_CHILD | BS_GROUPBOX,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "Button", NULL, style[i] | WS_CHILD | BS_PUSHBUTTON,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "Button", NULL, style[i] | WS_CHILD | BS_PUSHBUTTON,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
 
        assert(pos < size);
        window[pos] = CreateWindowExA(0, "Static", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
        assert(pos < size);
        window[pos] = CreateWindowExA(WS_EX_TRANSPARENT, "Static", NULL, style[i] | WS_CHILD,
                                     0, 0, 100, 100, parent, 0, 0, NULL);
        ok(window[pos] != 0, "CreateWindowEx failed\n");
        pos++;
    }
}

Referenced by test_child_window_from_point().

◆ def_window_procA()

static LRESULT WINAPI def_window_procA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 5664 of file win.c.

{
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by test_IsWindowUnicode().

◆ def_window_procW()

static LRESULT WINAPI def_window_procW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 5669 of file win.c.

{
    return DefWindowProcW(hwnd, msg, wparam, lparam);
}

Referenced by test_IsWindowUnicode().

◆ destroy_dialog_owner_proc()

static LRESULT WINAPI destroy_dialog_owner_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4735 of file win.c.

{
    if (msg == WM_ENTERIDLE) {
        HWND dialog = (HWND)lparam;
        DestroyWindow(dialog);
    }
    return DefWindowProcA( hwnd, msg, wparam, lparam );
}

Referenced by test_dialog_parent().

◆ dump_minmax_info()

static void dump_minmax_info ( const MINMAXINFO * minmax )

static

Definition at line 73 of file win.c.

{
    trace("Reserved=%d,%d MaxSize=%d,%d MaxPos=%d,%d MinTrack=%d,%d MaxTrack=%d,%d\n",
          minmax->ptReserved.x, minmax->ptReserved.y,
          minmax->ptMaxSize.x, minmax->ptMaxSize.y,
          minmax->ptMaxPosition.x, minmax->ptMaxPosition.y,
          minmax->ptMinTrackSize.x, minmax->ptMinTrackSize.y,
          minmax->ptMaxTrackSize.x, minmax->ptMaxTrackSize.y);
}

Referenced by mdi_child_wnd_proc_1(), mdi_child_wnd_proc_2(), and test_thick_child_size_winproc().

◆ dump_region()

void dump_region ( HRGN hrgn )

Definition at line 7695 of file msg.c.

{
    DWORD i, size;
    RGNDATA *data = NULL;
    RECT *rect;
 
    if (!hrgn)
    {
        printf( "null region\n" );
        return;
    }
    if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
    if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
    GetRegionData( hrgn, size, data );
    printf("%d rects:", data->rdh.nCount );
    for (i = 0, rect = (RECT *)data->Buffer; i < data->rdh.nCount; i++, rect++)
        printf( " %s", wine_dbgstr_rect( rect ));
    printf("\n");
    HeapFree( GetProcessHeap(), 0, data );
}

Referenced by check_update_rgn_(), test_scrolldc(), and test_scrollvalidate().

◆ DWORD()

static DWORD ( WINAPI * pSetLayout )

static

◆ empty_dlg_proc()

static INT_PTR WINAPI empty_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4338 of file win.c.

{
    return 0;
}

Referenced by check_dialog_style(), and test_dialog_parent().

◆ empty_dlg_proc2()

static INT_PTR WINAPI empty_dlg_proc2	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4387 of file win.c.

{
    if (msg == WM_INITDIALOG)
    {
        DWORD style = GetWindowLongA(hwnd, GWL_STYLE);
        struct dialog_param *param = (struct dialog_param *)lparam;
        BOOL parent_is_child;
        HWND disabled_hwnd;
        LRESULT id, ret;
 
        id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
        ok(id == MAKELONG(IDOK,DC_HASDEFID), "expected (IDOK,DC_HASDEFID), got %08lx\n", id);
        ret = DefDlgProcA(hwnd, DM_SETDEFID, 0x2222, 0);
        ok(ret, "DefDlgProc(DM_SETDEFID) failed\n");
        id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
        ok(id == MAKELONG(0x2222,DC_HASDEFID), "expected (0x2222,DC_HASDEFID), got %08lx\n", id);
 
        expected_id = MAKELONG(0x2222,DC_HASDEFID);
 
        parent_is_child = (GetWindowLongA(param->parent, GWL_STYLE) & (WS_POPUP | WS_CHILD)) == WS_CHILD;
 
        ok(IsWindowEnabled(hwnd), "wrong state for %p\n", hwnd);
        if (parent_is_child)
        {
            ok(IsWindowEnabled(param->parent), "wrong state for %08x\n", style);
            disabled_hwnd = param->grand_parent;
        }
        else
        {
            ok(!IsWindowEnabled(param->parent), "wrong state for %08x\n", style);
            disabled_hwnd = param->parent;
        }
 
        if (param->grand_parent)
        {
            if (parent_is_child)
                ok(!IsWindowEnabled(param->grand_parent), "wrong state for %08x\n", style);
            else
                ok(IsWindowEnabled(param->grand_parent), "wrong state for %08x\n", style);
        }
 
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, disabled_hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(disabled_hwnd), "wrong state for %08x\n", style);
 
        ok(IsWindowEnabled(hwnd), "wrong state for %p\n", hwnd);
        ok(IsWindowEnabled(param->parent), "wrong state for %p\n", param->parent);
        if (param->grand_parent)
            ok(IsWindowEnabled(param->grand_parent), "wrong state for %p (%08x)\n", param->grand_parent, style);
 
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p\n", hwnd);
        ok(IsWindowEnabled(param->parent), "wrong state for %p\n", param->parent);
        if (param->grand_parent)
            ok(IsWindowEnabled(param->grand_parent), "wrong state for %p (%08x)\n", param->grand_parent, style);
 
        param->dlg_data->style |= WS_CHILD;
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p (%08x)\n", hwnd, style);
 
        param->dlg_data->style |= DS_CONTROL;
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p (%08x)\n", hwnd, style);
 
        param->dlg_data->dwExtendedStyle |= WS_EX_CONTROLPARENT;
        SetWindowLongA(hwnd, GWL_EXSTYLE, GetWindowLongA(hwnd, GWL_EXSTYLE) | WS_EX_CONTROLPARENT);
        SetWindowLongA(hwnd, GWL_STYLE, style & ~DS_CONTROL);
        param->dlg_data->style &= ~DS_CONTROL;
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p (%08x)\n", hwnd, style);
 
        SetWindowLongA(hwnd, GWL_STYLE, style | DS_CONTROL);
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p (%08x)\n", hwnd, style);
 
        param->dlg_data->style |= DS_CONTROL;
        DialogBoxIndirectParamA(GetModuleHandleA(NULL), param->dlg_data, hwnd, empty_dlg_proc3, 0);
        ok(IsWindowEnabled(hwnd), "wrong state for %p (%08x)\n", hwnd, style);
 
        EndDialog(hwnd, 0);
    }
    return 0;
}

Referenced by check_dialog_style().

◆ empty_dlg_proc3()

static INT_PTR WINAPI empty_dlg_proc3	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4345 of file win.c.

{
    if (msg == WM_INITDIALOG)
    {
        HWND parent = GetParent(hwnd);
        LRESULT id, ret;
 
        id = DefDlgProcA(parent, DM_GETDEFID, 0, 0);
        if (!id || root_dialog(hwnd) == hwnd)
            parent = 0;
 
        id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
        if (!parent)
            ok(id == MAKELONG(IDOK,DC_HASDEFID), "expected (IDOK,DC_HASDEFID), got %08lx\n", id);
        else
            ok(id == expected_id, "expected %08lx, got %08lx\n", expected_id, id);
 
        ret = DefDlgProcA(hwnd, DM_SETDEFID, 0x3333, 0);
        ok(ret, "DefDlgProc(DM_SETDEFID) failed\n");
        id = DefDlgProcA(hwnd, DM_GETDEFID, 0, 0);
        ok(id == MAKELONG(0x3333,DC_HASDEFID), "expected (0x3333,DC_HASDEFID), got %08lx\n", id);
 
        if (parent)
        {
            id = DefDlgProcA(parent, DM_GETDEFID, 0, 0);
            ok(id == MAKELONG(0x3333,DC_HASDEFID), "expected (0x3333,DC_HASDEFID), got %08lx\n", id);
 
            expected_id = MAKELONG(0x3333,DC_HASDEFID);
        }
 
        EndDialog(hwnd, 0);
    }
 
    return 0;
}

Referenced by empty_dlg_proc2().

◆ enum_proc()

static BOOL CALLBACK enum_proc	(	HWND	hwnd,
		LPARAM	lParam
	)

static

Definition at line 671 of file win.c.

{
    (*(LPINT)lParam)++;
    if (*(LPINT)lParam > 2) return FALSE;
    return TRUE;
}

Referenced by enum_thread().

◆ enum_thread()

static DWORD CALLBACK enum_thread ( void * arg )

static

Definition at line 677 of file win.c.

{
    INT count;
    HWND hwnd[3];
    BOOL ret;
    MSG msg;
 
    if (pGetGUIThreadInfo)
    {
        GUITHREADINFO info;
        info.cbSize = sizeof(info);
        ret = pGetGUIThreadInfo( GetCurrentThreadId(), &info );
        ok( ret || broken(!ret), /* win9x */
            "GetGUIThreadInfo failed without message queue\n" );
        SetLastError( 0xdeadbeef );
        info.cbSize = sizeof(info) + 1;
        ret = pGetGUIThreadInfo( GetCurrentThreadId(), &info );
        ok( !ret, "GetGUIThreadInfo succeeded with wrong size\n" );
        ok( GetLastError() == ERROR_INVALID_PARAMETER ||
            broken(GetLastError() == 0xdeadbeef), /* win9x */
            "wrong error %u\n", GetLastError() );
    }
 
    PeekMessageA( &msg, 0, 0, 0, PM_NOREMOVE );  /* make sure we have a message queue */
 
    count = 0;
    ret = EnumThreadWindows( GetCurrentThreadId(), enum_proc, (LPARAM)&count );
    ok( ret, "EnumThreadWindows should have returned TRUE\n" );
    ok( count == 0, "count should be 0 got %d\n", count );
 
    hwnd[0] = CreateWindowExA(0, "ToolWindowClass", "Tool window 1", WS_POPUP,
                              0, 0, 100, 100, 0, 0, 0, NULL );
    count = 0;
    ret = EnumThreadWindows( GetCurrentThreadId(), enum_proc, (LPARAM)&count );
    ok( ret, "EnumThreadWindows should have returned TRUE\n" );
    if (count != 2)  /* Vista gives us two windows for the price of one */
    {
        ok( count == 1, "count should be 1 got %d\n", count );
        hwnd[2] = CreateWindowExA(0, "ToolWindowClass", "Tool window 2", WS_POPUP,
                                  0, 0, 100, 100, 0, 0, 0, NULL );
    }
    else hwnd[2] = 0;
 
    hwnd[1] = CreateWindowExA(0, "ToolWindowClass", "Tool window 3", WS_POPUP,
                              0, 0, 100, 100, 0, 0, 0, NULL );
    count = 0;
    ret = EnumThreadWindows( GetCurrentThreadId(), enum_proc, (LPARAM)&count );
    ok( !ret, "EnumThreadWindows should have returned FALSE\n" );
    ok( count == 3, "count should be 3 got %d\n", count );
 
    if (hwnd[2]) DestroyWindow(hwnd[2]);
    DestroyWindow(hwnd[1]);
    DestroyWindow(hwnd[0]);
    return 0;
}

Referenced by test_enum_thread_windows().

◆ EnumChildProc()

static BOOL CALLBACK EnumChildProc	(	HWND	hwndChild,
		LPARAM	lParam
	)

static

Definition at line 185 of file win.c.

{
    (*(LPINT)lParam)++;
    trace("EnumChildProc on %p\n", hwndChild);
    if (*(LPINT)lParam > 1) return FALSE;
    return TRUE;
}

Referenced by test_parent_owner().

◆ EnumChildProc1()

static BOOL CALLBACK EnumChildProc1	(	HWND	hwndChild,
		LPARAM	lParam
	)

static

Definition at line 194 of file win.c.

{
    trace("EnumChildProc1 on %p\n", hwndChild);
    if ((HWND)lParam == hwndChild) return FALSE;
    return TRUE;
}

Referenced by test_parent_owner().

◆ FixedAdjustWindowRectEx()

static void FixedAdjustWindowRectEx	(	RECT *	rc,
		LONG	style,
		BOOL	menu,
		LONG	exstyle
	)

static

Definition at line 994 of file win.c.

{
    AdjustWindowRectEx(rc, style, menu, exstyle);
    /* AdjustWindowRectEx does not include scroll bars */
    if (style & WS_VSCROLL)
    {
        if(exstyle & WS_EX_LEFTSCROLLBAR)
            rc->left  -= GetSystemMetrics(SM_CXVSCROLL);
        else
            rc->right += GetSystemMetrics(SM_CXVSCROLL);
    }
    if (style & WS_HSCROLL)
    rc->bottom += GetSystemMetrics(SM_CYHSCROLL);
}

Referenced by test_nonclient_area().

◆ flush_events()

static void flush_events ( BOOL remove_messages )

static

Definition at line 84 of file win.c.

{
    MSG msg;
    int diff = 200;
    int min_timeout = 100;
    DWORD time = GetTickCount() + diff;
 
    while (diff > 0)
    {
        if (MsgWaitForMultipleObjects( 0, NULL, FALSE, min_timeout, QS_ALLINPUT ) == WAIT_TIMEOUT) break;
        if (remove_messages)
            while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageA( &msg );
        diff = time - GetTickCount();
        min_timeout = 50;
    }
}

◆ fullscreen_wnd_proc()

static LRESULT CALLBACK fullscreen_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 7340 of file win.c.

{
    switch (msg)
    {
        case WM_NCCREATE:
        {
            CREATESTRUCTA *cs = (CREATESTRUCTA *)lp;
            ok(cs->x == mi.rcMonitor.left && cs->y == mi.rcMonitor.top &&
               cs->cx == mi.rcMonitor.right && cs->cy == mi.rcMonitor.bottom,
               "expected %s, got (%d,%d)-(%d,%d)\n", wine_dbgstr_rect(&mi.rcMonitor),
               cs->x, cs->y, cs->cx, cs->cy);
            break;
        }
        case WM_GETMINMAXINFO:
        {
            MINMAXINFO *minmax = (MINMAXINFO *)lp;
            ok(minmax->ptMaxPosition.x <= mi.rcMonitor.left, "%d <= %d\n", minmax->ptMaxPosition.x, mi.rcMonitor.left);
            ok(minmax->ptMaxPosition.y <= mi.rcMonitor.top, "%d <= %d\n", minmax->ptMaxPosition.y, mi.rcMonitor.top);
            ok(minmax->ptMaxSize.x >= mi.rcMonitor.right, "%d >= %d\n", minmax->ptMaxSize.x, mi.rcMonitor.right);
            ok(minmax->ptMaxSize.y >= mi.rcMonitor.bottom, "%d >= %d\n", minmax->ptMaxSize.y, mi.rcMonitor.bottom);
            break;
        }
    }
    return DefWindowProcA(hwnd, msg, wp, lp);
}

Referenced by test_fullscreen().

◆ get_window_attributes()

static void get_window_attributes	(	HWND	hwnd,
		struct window_attributes *	attrs
	)

static

Definition at line 8181 of file win.c.

{
    DWORD style, ex_style, hittest;
 
    style = GetWindowLongA(hwnd, GWL_STYLE);
    ex_style = GetWindowLongA(hwnd, GWL_EXSTYLE);
    attrs->class_name[0] = 0;
    GetClassNameA(hwnd, attrs->class_name, sizeof(attrs->class_name));
    hittest = SendMessageA(hwnd, WM_NCHITTEST, 0, 0);
 
    attrs->is_visible = (style & WS_VISIBLE) != 0;
    attrs->is_enabled = (style & WS_DISABLED) == 0;
    attrs->is_groupbox = !lstrcmpiA(attrs->class_name, "Button") && (style & BS_TYPEMASK) == BS_GROUPBOX;
    attrs->is_httransparent = hittest == HTTRANSPARENT;
    attrs->is_extransparent = (ex_style & WS_EX_TRANSPARENT) != 0;
}

Referenced by test_child_window_from_point().

◆ gettext_msg_thread()

static DWORD CALLBACK gettext_msg_thread ( LPVOID arg )

static

Definition at line 6577 of file win.c.

{
    HWND hwnd = arg;
    char buf[32];
    INT buf_len;
 
    /* test GetWindowTextA */
    num_gettext_msgs = 0;
    memset( buf, 0, sizeof(buf) );
    buf_len = GetWindowTextA( hwnd, buf, sizeof(buf) );
    ok( buf_len != 0, "expected a nonempty window text\n" );
    ok( !strcmp(buf, "another_caption"), "got wrong window text '%s'\n", buf );
    ok( num_gettext_msgs == 1, "got %u WM_GETTEXT messages\n", num_gettext_msgs );
 
    return 0;
}

Referenced by test_gettext().

◆ HMONITOR()

static HMONITOR ( WINAPI * pMonitorFromPoint )

static

◆ HWND()

static HWND ( WINAPI * pGetAncestor )

static

◆ ignore_message()

static BOOL ignore_message ( UINT message )

static

Definition at line 173 of file win.c.

{
    /* these are always ignored */
    return (message >= 0xc000 ||
            message == WM_GETICON ||
            message == WM_GETOBJECT ||
            message == WM_TIMER ||
            message == WM_SYSTIMER ||
            message == WM_TIMECHANGE ||
            message == WM_DEVICECHANGE);
}

Referenced by peek_message(), and test_mouse_input().

◆ int()

static int ( WINAPI * pGetWindowRgnBox )

static

◆ main_window_procA()

static LRESULT WINAPI main_window_procA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 749 of file win.c.

{
    switch (msg)
    {
    case WM_GETMINMAXINFO:
    {
        SetWindowLongPtrA(hwnd, GWLP_USERDATA, 0x20031021);
        break;
    }
    case WM_WINDOWPOSCHANGING:
    {
        WINDOWPOS *winpos = (WINDOWPOS *)lparam;
        if (!(winpos->flags & SWP_NOMOVE))
        {
        ok(winpos->x >= -32768 && winpos->x <= 32767, "bad winpos->x %d\n", winpos->x);
        ok(winpos->y >= -32768 && winpos->y <= 32767, "bad winpos->y %d\n", winpos->y);
        }
        /* Win9x does not fixup cx/xy for WM_WINDOWPOSCHANGING */
        if (!(winpos->flags & SWP_NOSIZE) && !is_win9x)
        {
        ok((winpos->cx >= 0 && winpos->cx <= 32767) ||
                   winpos->cx == 32768, /* win7 doesn't truncate */
                   "bad winpos->cx %d\n", winpos->cx);
        ok((winpos->cy >= 0 && winpos->cy <= 32767) ||
                   winpos->cy == 40000, /* win7 doesn't truncate */
                   "bad winpos->cy %d\n", winpos->cy);
        }
        break;
    }
    case WM_WINDOWPOSCHANGED:
    disable_success_count
    {
            RECT rc1, rc2;
        WINDOWPOS *winpos = (WINDOWPOS *)lparam;
        ok(winpos->x >= -32768 && winpos->x <= 32767, "bad winpos->x %d\n", winpos->x);
        ok(winpos->y >= -32768 && winpos->y <= 32767, "bad winpos->y %d\n", winpos->y);
 
            ok((winpos->cx >= 0 && winpos->cx <= 32767) ||
               winpos->cx == 32768, /* win7 doesn't truncate */
               "bad winpos->cx %d\n", winpos->cx);
            ok((winpos->cy >= 0 && winpos->cy <= 32767) ||
               winpos->cy == 40000, /* win7 doesn't truncate */
               "bad winpos->cy %d\n", winpos->cy);
 
            GetWindowRect(hwnd, &rc1);
            SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
            /* note: winpos coordinates are relative to parent */
            MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
            if (0)
            {
            /* Uncomment this once the test succeeds in all cases */
            ok(EqualRect(&rc1, &rc2), "rects do not match %s / %s\n", wine_dbgstr_rect(&rc1),
               wine_dbgstr_rect(&rc2));
 
            GetClientRect(hwnd, &rc2);
            DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
            MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
            ok(EqualRect(&rc1, &rc2), "rects do not match %s / %s\n", wine_dbgstr_rect(&rc1),
               wine_dbgstr_rect(&rc2));
            }
        break;
    }
    case WM_NCCREATE:
    {
        BOOL got_getminmaxinfo = GetWindowLongPtrA(hwnd, GWLP_USERDATA) == 0x20031021;
        CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
 
        if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
        ok(got_getminmaxinfo, "main: WM_GETMINMAXINFO should have been received before WM_NCCREATE\n");
        else
        ok(!got_getminmaxinfo, "main: WM_GETMINMAXINFO should NOT have been received before WM_NCCREATE\n");
        break;
    }
        case WM_COMMAND:
            if (test_lbuttondown_flag)
            {
                ShowWindow((HWND)wparam, SW_SHOW);
                flush_events( FALSE );
            }
            break;
        case WM_GETTEXT:
            num_gettext_msgs++;
            if (g_wm_gettext_override.enabled)
            {
                char *text = (char*)lparam;
                ok(g_wm_gettext_override.buff == text, "expected buffer %p, got %p\n", g_wm_gettext_override.buff, text);
                ok(*text == 0, "expected empty string buffer %x\n", *text);
                return 0;
            }
            break;
        case WM_SETTEXT:
            num_settext_msgs++;
            break;
        case WM_ACTIVATEAPP:
            if (wparam) app_activated = TRUE;
            else app_deactivated = TRUE;
            break;
    }
 
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by RegisterWindowClasses(), and test_SetWindowLong().

◆ main_window_procW()

static LRESULT WINAPI main_window_procW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 851 of file win.c.

{
    switch (msg)
    {
        case WM_GETTEXT:
            num_gettext_msgs++;
            if (g_wm_gettext_override.enabled)
            {
                WCHAR *text = (WCHAR*)lparam;
                ok(g_wm_gettext_override.buffW == text, "expected buffer %p, got %p\n", g_wm_gettext_override.buffW, text);
                ok(*text == 0, "expected empty string buffer %x\n", *text);
                return 0;
            }
            break;
    }
 
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by RegisterWindowClasses().

◆ mdi_child_wnd_proc_1()

static LRESULT WINAPI mdi_child_wnd_proc_1	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 1808 of file win.c.

{
    switch (msg)
    {
        case WM_NCCREATE:
        case WM_CREATE:
        {
            CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
            MDICREATESTRUCTA *mdi_cs = cs->lpCreateParams;
 
            ok(cs->dwExStyle & WS_EX_MDICHILD, "WS_EX_MDICHILD should be set\n");
            ok(mdi_cs->lParam == (LPARAM)mdi_lParam_test_message, "wrong mdi_cs->lParam\n");
 
            ok(!lstrcmpA(cs->lpszClass, "MDI_child_Class_1"), "wrong class name\n");
            ok(!lstrcmpA(cs->lpszClass, mdi_cs->szClass), "class name does not match\n");
            ok(!lstrcmpA(cs->lpszName, "MDI child"), "wrong title\n");
            ok(!lstrcmpA(cs->lpszName, mdi_cs->szTitle), "title does not match\n");
            ok(cs->hInstance == mdi_cs->hOwner, "%p != %p\n", cs->hInstance, mdi_cs->hOwner);
 
            /* MDICREATESTRUCT should have original values */
            ok(mdi_cs->style == 0 || mdi_cs->style == 0x7fffffff || mdi_cs->style == 0xffffffff || mdi_cs->style == WS_MAXIMIZE,
                "mdi_cs->style does not match (%08x)\n", mdi_cs->style);
            ok(mdi_cs->x == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->x);
            ok(mdi_cs->y == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->y);
            ok(mdi_cs->cx == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->cx);
            ok(mdi_cs->cy == CW_USEDEFAULT, "%d != CW_USEDEFAULT\n", mdi_cs->cy);
 
            /* CREATESTRUCT should have fixed values */
            ok(cs->x != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->x);
            ok(cs->y != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->y);
 
            /* cx/cy == CW_USEDEFAULT are translated to NOT zero values */
            ok(cs->cx != CW_USEDEFAULT && cs->cx != 0, "%d == CW_USEDEFAULT\n", cs->cx);
            ok(cs->cy != CW_USEDEFAULT && cs->cy != 0, "%d == CW_USEDEFAULT\n", cs->cy);
 
            ok(!(cs->style & WS_POPUP), "WS_POPUP is not allowed\n");
 
            if (GetWindowLongA(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
            {
                LONG style = mdi_cs->style | WS_CHILD | WS_CLIPSIBLINGS;
                ok(cs->style == style,
                   "cs->style does not match (%08x)\n", cs->style);
            }
            else
            {
                LONG style = mdi_cs->style;
                style &= ~WS_POPUP;
                style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
                    WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
                ok(cs->style == style,
                   "cs->style does not match (%08x)\n", cs->style);
            }
            break;
        }
 
        case WM_GETMINMAXINFO:
        {
            HWND client = GetParent(hwnd);
            RECT rc;
            MINMAXINFO *minmax = (MINMAXINFO *)lparam;
            MINMAXINFO my_minmax;
            LONG style, exstyle;
 
            style = GetWindowLongA(hwnd, GWL_STYLE);
            exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
 
            GetClientRect(client, &rc);
 
            GetClientRect(client, &rc);
            if ((style & WS_CAPTION) == WS_CAPTION)
                style &= ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
            AdjustWindowRectEx(&rc, style, 0, exstyle);
            trace("MDI child: calculated max window size = (%d x %d)\n", rc.right-rc.left, rc.bottom-rc.top);
            dump_minmax_info( minmax );
 
            ok(minmax->ptMaxSize.x == rc.right - rc.left, "default width of maximized child %d != %d\n",
               minmax->ptMaxSize.x, rc.right - rc.left);
            ok(minmax->ptMaxSize.y == rc.bottom - rc.top, "default height of maximized child %d != %d\n",
               minmax->ptMaxSize.y, rc.bottom - rc.top);
 
            DefMDIChildProcA(hwnd, msg, wparam, lparam);
 
            trace("DefMDIChildProc returned:\n");
            dump_minmax_info( minmax );
 
            MDI_ChildGetMinMaxInfo(client, hwnd, &my_minmax);
            ok(minmax->ptMaxSize.x == my_minmax.ptMaxSize.x, "default width of maximized child %d != %d\n",
               minmax->ptMaxSize.x, my_minmax.ptMaxSize.x);
            ok(minmax->ptMaxSize.y == my_minmax.ptMaxSize.y, "default height of maximized child %d != %d\n",
               minmax->ptMaxSize.y, my_minmax.ptMaxSize.y);
 
            return 1;
        }
 
        case WM_MDIACTIVATE:
        {
            HWND active, client = GetParent(hwnd);
            /*trace("%p WM_MDIACTIVATE %08x %08lx\n", hwnd, wparam, lparam);*/
            active = (HWND)SendMessageA(client, WM_MDIGETACTIVE, 0, 0);
            if (hwnd == (HWND)lparam) /* if we are being activated */
                ok (active == (HWND)lparam, "new active %p != active %p\n", (HWND)lparam, active);
            else
                ok (active == (HWND)wparam, "old active %p != active %p\n", (HWND)wparam, active);
            break;
        }
    }
    return DefMDIChildProcA(hwnd, msg, wparam, lparam);
}

Referenced by mdi_RegisterWindowClasses().

◆ mdi_child_wnd_proc_2()

static LRESULT WINAPI mdi_child_wnd_proc_2	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 1917 of file win.c.

{
    switch (msg)
    {
        case WM_NCCREATE:
        case WM_CREATE:
        {
            CREATESTRUCTA *cs = (CREATESTRUCTA *)lparam;
 
            trace("%s: x %d, y %d, cx %d, cy %d\n", (msg == WM_NCCREATE) ? "WM_NCCREATE" : "WM_CREATE",
                cs->x, cs->y, cs->cx, cs->cy);
 
            ok(!(cs->dwExStyle & WS_EX_MDICHILD), "WS_EX_MDICHILD should not be set\n");
            ok(cs->lpCreateParams == mdi_lParam_test_message, "wrong cs->lpCreateParams\n");
 
            ok(!lstrcmpA(cs->lpszClass, "MDI_child_Class_2"), "wrong class name\n");
            ok(!lstrcmpA(cs->lpszName, "MDI child"), "wrong title\n");
 
            /* CREATESTRUCT should have fixed values */
            /* For some reason Win9x doesn't translate cs->x from CW_USEDEFAULT,
               while NT does. */
            /*ok(cs->x != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->x);*/
            ok(cs->y != CW_USEDEFAULT, "%d == CW_USEDEFAULT\n", cs->y);
 
            /* cx/cy == CW_USEDEFAULT are translated to 0 */
            /* For some reason Win98 doesn't translate cs->cx from CW_USEDEFAULT,
               while Win95, Win2k, WinXP do. */
            /*ok(cs->cx == 0, "%d != 0\n", cs->cx);*/
            ok(cs->cy == 0, "%d != 0\n", cs->cy);
            break;
        }
 
        case WM_GETMINMAXINFO:
        {
            HWND parent = GetParent(hwnd);
            RECT rc;
            MINMAXINFO *minmax = (MINMAXINFO *)lparam;
            LONG style, exstyle;
 
            style = GetWindowLongA(hwnd, GWL_STYLE);
            exstyle = GetWindowLongA(hwnd, GWL_EXSTYLE);
 
            GetClientRect(parent, &rc);
            trace("WM_GETMINMAXINFO: parent %p client size = (%d x %d)\n", parent, rc.right, rc.bottom);
 
            GetClientRect(parent, &rc);
            if ((style & WS_CAPTION) == WS_CAPTION)
                style &= ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
            AdjustWindowRectEx(&rc, style, 0, exstyle);
            dump_minmax_info( minmax );
 
            ok(minmax->ptMaxSize.x == rc.right - rc.left, "default width of maximized child %d != %d\n",
               minmax->ptMaxSize.x, rc.right - rc.left);
            ok(minmax->ptMaxSize.y == rc.bottom - rc.top, "default height of maximized child %d != %d\n",
               minmax->ptMaxSize.y, rc.bottom - rc.top);
            break;
        }
 
        case WM_WINDOWPOSCHANGED:
        {
            WINDOWPOS *winpos = (WINDOWPOS *)lparam;
            RECT rc1, rc2;
 
            GetWindowRect(hwnd, &rc1);
            SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
            /* note: winpos coordinates are relative to parent */
            MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
            ok(EqualRect(&rc1, &rc2), "rects do not match, window=%s pos=%s\n",
               wine_dbgstr_rect(&rc1), wine_dbgstr_rect(&rc2));
            GetWindowRect(hwnd, &rc1);
            GetClientRect(hwnd, &rc2);
            DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
            MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
            ok(EqualRect(&rc1, &rc2), "rects do not match, window=%s client=%s\n",
               wine_dbgstr_rect(&rc1), wine_dbgstr_rect(&rc2));
        }
        /* fall through */
        case WM_WINDOWPOSCHANGING:
        {
            WINDOWPOS *winpos = (WINDOWPOS *)lparam;
            WINDOWPOS my_winpos = *winpos;
 
            trace("%s: %p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
                  (msg == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED",
                  winpos->hwnd, winpos->hwndInsertAfter,
                  winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
 
            DefWindowProcA(hwnd, msg, wparam, lparam);
 
            ok(!memcmp(&my_winpos, winpos, sizeof(WINDOWPOS)),
               "DefWindowProc should not change WINDOWPOS: %p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
                  winpos->hwnd, winpos->hwndInsertAfter,
                  winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
 
            return 1;
        }
    }
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by mdi_RegisterWindowClasses().

◆ MDI_ChildGetMinMaxInfo()

static void MDI_ChildGetMinMaxInfo	(	HWND	client,
		HWND	hwnd,
		MINMAXINFO *	lpMinMax
	)

static

Definition at line 1789 of file win.c.

{
    RECT rect;
 
    GetClientRect( client, &rect );
    AdjustWindowRectEx( &rect, GetWindowLongA( hwnd, GWL_STYLE ),
                        0, GetWindowLongA( hwnd, GWL_EXSTYLE ));
 
    rect.right -= rect.left;
    rect.bottom -= rect.top;
    lpMinMax->ptMaxSize.x = rect.right;
    lpMinMax->ptMaxSize.y = rect.bottom;
 
    lpMinMax->ptMaxPosition.x = rect.left;
    lpMinMax->ptMaxPosition.y = rect.top;
 
    trace("max rect %s\n", wine_dbgstr_rect(&rect));
}

Referenced by mdi_child_wnd_proc_1().

◆ mdi_main_wnd_procA()

static LRESULT WINAPI mdi_main_wnd_procA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 2017 of file win.c.

{
    static HWND mdi_client;
 
    switch (msg)
    {
        case WM_CREATE:
            return 1;
 
        case WM_WINDOWPOSCHANGED:
        {
            WINDOWPOS *winpos = (WINDOWPOS *)lparam;
            RECT rc1, rc2;
 
            GetWindowRect(hwnd, &rc1);
            trace("window: %s\n", wine_dbgstr_rect(&rc1));
            SetRect(&rc2, winpos->x, winpos->y, winpos->x + winpos->cx, winpos->y + winpos->cy);
            /* note: winpos coordinates are relative to parent */
            MapWindowPoints(GetParent(hwnd), 0, (LPPOINT)&rc2, 2);
            trace("pos: %s\n", wine_dbgstr_rect(&rc2));
            ok(EqualRect(&rc1, &rc2), "rects do not match\n");
 
            GetWindowRect(hwnd, &rc1);
            GetClientRect(hwnd, &rc2);
            DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)&rc1);
            MapWindowPoints(0, hwnd, (LPPOINT)&rc1, 2);
            ok(EqualRect(&rc1, &rc2), "rects do not match\n");
        }
        /* fall through */
        case WM_WINDOWPOSCHANGING:
        {
            WINDOWPOS *winpos = (WINDOWPOS *)lparam;
            WINDOWPOS my_winpos = *winpos;
 
            trace("%s\n", (msg == WM_WINDOWPOSCHANGING) ? "WM_WINDOWPOSCHANGING" : "WM_WINDOWPOSCHANGED");
            trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
                  winpos->hwnd, winpos->hwndInsertAfter,
                  winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
 
            DefWindowProcA(hwnd, msg, wparam, lparam);
 
            trace("%p after %p, x %d, y %d, cx %d, cy %d flags %08x\n",
                  winpos->hwnd, winpos->hwndInsertAfter,
                  winpos->x, winpos->y, winpos->cx, winpos->cy, winpos->flags);
 
            ok(!memcmp(&my_winpos, winpos, sizeof(WINDOWPOS)),
               "DefWindowProc should not change WINDOWPOS values\n");
 
            return 1;
        }
 
        case WM_CLOSE:
            PostQuitMessage(0);
            break;
    }
    return DefFrameProcA(hwnd, mdi_client, msg, wparam, lparam);
}

Referenced by mdi_RegisterWindowClasses().

◆ mdi_RegisterWindowClasses()

static BOOL mdi_RegisterWindowClasses ( void )

static

Definition at line 2075 of file win.c.

{
    WNDCLASSA cls;
 
    cls.style = 0;
    cls.lpfnWndProc = mdi_main_wnd_procA;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleA(0);
    cls.hIcon = 0;
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszMenuName = NULL;
    cls.lpszClassName = "MDI_parent_Class";
    if(!RegisterClassA(&cls)) return FALSE;
 
    cls.lpfnWndProc = mdi_child_wnd_proc_1;
    cls.lpszClassName = "MDI_child_Class_1";
    if(!RegisterClassA(&cls)) return FALSE;
 
    cls.lpfnWndProc = mdi_child_wnd_proc_2;
    cls.lpszClassName = "MDI_child_Class_2";
    if(!RegisterClassA(&cls)) return FALSE;
 
    return TRUE;
}

Referenced by test_mdi().

◆ minmax_wnd_proc()

static LRESULT CALLBACK minmax_wnd_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5793 of file win.c.

{
    MINMAXINFO *minmax;
 
    if (msg != WM_GETMINMAXINFO)
        return DefWindowProcA(hwnd, msg, wp, lp);
 
    minmax = (MINMAXINFO *)lp;
 
    if ((GetWindowLongA(hwnd, GWL_STYLE) & WS_CHILD))
    {
        minmax->ptReserved.x = 0;
        minmax->ptReserved.y = 0;
        minmax->ptMaxSize.x = 400;
        minmax->ptMaxSize.y = 400;
        minmax->ptMaxPosition.x = 300;
        minmax->ptMaxPosition.y = 300;
        minmax->ptMaxTrackSize.x = 200;
        minmax->ptMaxTrackSize.y = 200;
        minmax->ptMinTrackSize.x = 100;
        minmax->ptMinTrackSize.y = 100;
    }
    else
        DefWindowProcA(hwnd, msg, wp, lp);
    return 1;
}

Referenced by test_CreateWindow().

◆ my_httrasparent_proc()

static LRESULT WINAPI my_httrasparent_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 8077 of file win.c.

{
    if (msg == WM_NCHITTEST) return HTTRANSPARENT;
    return DefWindowProcA(hwnd, msg, wp, lp);
}

Referenced by test_child_window_from_point().

◆ my_window_proc()

static LRESULT WINAPI my_window_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 8083 of file win.c.

{
    return DefWindowProcA(hwnd, msg, wp, lp);
}

Referenced by test_child_window_from_point().

◆ nccalchelper()

static void nccalchelper	(	HWND	hwnd,
		INT	x,
		INT	y,
		RECT *	prc
	)

static

Definition at line 3921 of file win.c.

{
    RECT rc;
    MoveWindow( hwnd, 0, 0, x, y, 0);
    GetWindowRect( hwnd, prc);
    rc = *prc;
    DefWindowProcA(hwnd, WM_NCCALCSIZE, 0, (LPARAM)prc);
    trace("window rect is %s, nccalc rect is %s\n", wine_dbgstr_rect(&rc), wine_dbgstr_rect(prc));
}

Referenced by test_nccalcscroll().

◆ nccalcsize_proc()

static LRESULT WINAPI nccalcsize_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 2423 of file win.c.

{
    if (msg == WM_NCCALCSIZE)
    {
        RECT *rect = (RECT *)lparam;
        /* first time around increase the rectangle, next time decrease it */
        if (rect->left == 100) InflateRect( rect, 10, 10 );
        else InflateRect( rect, -10, -10 );
        return 0;
    }
    return DefWindowProcA( hwnd, msg, wparam, lparam );
}

Referenced by test_SetWindowPos().

◆ parent_dlg_proc()

static INT_PTR WINAPI parent_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4671 of file win.c.

{
    if (msg == WM_INITDIALOG) {
        struct dlg_parent_param *param = (void*)lparam;
        check_parents(hwnd, param->ga_parent, param->gwl_parent, param->get_parent, param->owner,
                      param->root ? param->root : hwnd, param->ga_root_owner ? param->ga_root_owner : hwnd);
 
        ok(!IsWindowEnabled(param->gwl_parent), "parent is not disabled\n");
        EndDialog(hwnd, 2);
        ok(IsWindowEnabled(param->gwl_parent), "parent is not enabled\n");
    }
 
    return 0;
}

Referenced by test_dialog_parent().

◆ parentdc_window_procA()

static LRESULT WINAPI parentdc_window_procA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 5444 of file win.c.

{
    RECT rc;
    PAINTSTRUCT ps;
 
    struct parentdc_stat *t = (struct parentdc_stat *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
 
    switch (msg)
    {
    case WM_PAINT:
        GetClientRect(hwnd, &rc);
        t->client = rc;
        GetWindowRect(hwnd, &rc);
        trace("WM_PAINT: hwnd %p, client rect %s, window rect %s\n", hwnd,
              wine_dbgstr_rect(&t->client), wine_dbgstr_rect(&rc));
        BeginPaint(hwnd, &ps);
        t->paint = ps.rcPaint;
        GetClipBox(ps.hdc, &rc);
        t->clip = rc;
        trace("clip rect %s, paint rect %s\n", wine_dbgstr_rect(&rc),
              wine_dbgstr_rect(&ps.rcPaint));
        EndPaint(hwnd, &ps);
        return 0;
    }
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by test_csparentdc().

◆ peek_message()

static BOOL peek_message ( MSG * msg )

static

Definition at line 3578 of file win.c.

{
    BOOL ret;
    do
    {
        ret = PeekMessageA(msg, 0, 0, 0, PM_REMOVE);
    } while (ret && ignore_message(msg->message));
    return ret;
}

Referenced by test_keyboard_input(), test_mouse_input(), and wait_for_message().

◆ post_quit_dialog_owner_proc()

static LRESULT WINAPI post_quit_dialog_owner_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4726 of file win.c.

{
    if (msg == WM_ENTERIDLE) {
        HWND dialog = (HWND)lparam;
        PostMessageA(dialog, WM_QUIT, 0, 0);
    }
    return DefWindowProcA( hwnd, msg, wparam, lparam );
}

Referenced by test_dialog_parent().

◆ redraw_window_procA()

static LRESULT WINAPI redraw_window_procA	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 5376 of file win.c.

{
    switch (msg)
    {
    case WM_PAINT:
        trace("doing WM_PAINT %d\n", WMPAINT_count);
        WMPAINT_count++;
        if (WMPAINT_count > 10 && redrawComplete == 0) {
            PAINTSTRUCT ps;
            BeginPaint(hwnd, &ps);
            EndPaint(hwnd, &ps);
            return 1;
        }
        return 0;
    }
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by test_redrawnow().

◆ register_style_check_class()

static void register_style_check_class ( void )

static

Definition at line 4186 of file win.c.

{
    WNDCLASSA wc =
    {
        0,
        StyleCheckProc,
        0,
        0,
        GetModuleHandleA(NULL),
        NULL,
        LoadCursorA(0, (LPCSTR)IDC_ARROW),
        (HBRUSH)(COLOR_BTNFACE+1),
        NULL,
        "WineStyleCheck",
    };
 
    atomStyleCheckClass = RegisterClassA(&wc);
    assert(atomStyleCheckClass);
}

Referenced by test_window_styles().

◆ RegisterWindowClasses()

static BOOL RegisterWindowClasses ( void )

static

Definition at line 897 of file win.c.

{
    WNDCLASSW clsW;
    WNDCLASSA cls;
 
    cls.style = CS_DBLCLKS;
    cls.lpfnWndProc = main_window_procA;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleA(0);
    cls.hIcon = 0;
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszMenuName = NULL;
    cls.lpszClassName = "MainWindowClass";
 
    if(!RegisterClassA(&cls)) return FALSE;
 
    clsW.style = CS_DBLCLKS;
    clsW.lpfnWndProc = main_window_procW;
    clsW.cbClsExtra = 0;
    clsW.cbWndExtra = 0;
    clsW.hInstance = GetModuleHandleA(0);
    clsW.hIcon = 0;
    clsW.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    clsW.hbrBackground = GetStockObject(WHITE_BRUSH);
    clsW.lpszMenuName = NULL;
    clsW.lpszClassName = mainclassW;
 
    if(!RegisterClassW(&clsW)) return FALSE;
 
    cls.style = 0;
    cls.lpfnWndProc = tool_window_procA;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleA(0);
    cls.hIcon = 0;
    cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
    cls.hbrBackground = GetStockObject(WHITE_BRUSH);
    cls.lpszMenuName = NULL;
    cls.lpszClassName = "ToolWindowClass";
 
    if(!RegisterClassA(&cls)) return FALSE;
 
    return TRUE;
}

Referenced by START_TEST().

◆ reparent_dialog_owner_proc()

static LRESULT WINAPI reparent_dialog_owner_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4711 of file win.c.

{
    if (msg == WM_ENTERIDLE) {
        HWND dialog = (HWND)lparam;
        HWND owner = GetParent(dialog);
        /* EndDialog will enable owner */
        EnableWindow(owner, FALSE);
        EndDialog(dialog, 2);
        ok(IsWindowEnabled(owner), "owner is not enabled\n");
        /* ...but it won't be enabled on dialog exit */
        EnableWindow(owner, FALSE);
    }
    return DefWindowProcA( hwnd, msg, wparam, lparam );
}

Referenced by test_dialog_parent().

◆ reparent_dlg_proc()

static INT_PTR WINAPI reparent_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4686 of file win.c.

{
    if (msg == WM_INITDIALOG) {
        ok(!IsWindowEnabled(GetParent(hwnd)), "parent is not disabled\n");
        SetParent(hwnd, (HWND)lparam);
    }
 
    return 0;
}

Referenced by test_dialog_parent().

◆ reparent_owned_dlg_proc()

static INT_PTR WINAPI reparent_owned_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 4696 of file win.c.

{
    if (msg == WM_INITDIALOG) {
        HWND new_parent = (HWND)lparam;
        HWND owner = GetWindow(hwnd, GW_OWNER);
        ok(!IsWindowEnabled(owner), "owner is not disabled\n");
        SetWindowLongA(hwnd, GWL_STYLE, GetWindowLongA(hwnd, GWL_STYLE) | WS_CHILD);
        SetParent(hwnd, new_parent);
        ok(GetParent(hwnd) == new_parent, "GetParent(hwnd) = %p, expected %p\n", GetParent(hwnd), new_parent);
        PostMessageA(hwnd, WM_QUIT, 0, 0);
    }
 
    return 0;
}

Referenced by test_dialog_parent().

◆ root_dialog()

static HWND root_dialog ( HWND hwnd )

static

Definition at line 4318 of file win.c.

{
    while ((GetWindowLongA(hwnd, GWL_EXSTYLE) & WS_EX_CONTROLPARENT) &&
           (GetWindowLongA(hwnd, GWL_STYLE) & (WS_CHILD|WS_POPUP)) == WS_CHILD)
    {
        HWND parent = GetParent(hwnd);
 
        /* simple detector for a window being a dialog */
        if (!DefDlgProcA(parent, DM_GETDEFID, 0, 0))
            break;
 
        hwnd = parent;
 
        if (!(GetWindowLongA(hwnd, GWL_STYLE) & DS_CONTROL))
            break;
    }
 
    return hwnd;
}

Referenced by empty_dlg_proc3().

◆ run_NCRedrawLoop()

static void run_NCRedrawLoop ( UINT flags )

static

Definition at line 6970 of file win.c.

{
    HWND hwnd;
    MSG msg;
 
    UINT loopcount = 0;
 
    hwnd = CreateWindowA("TestNCRedrawClass", "MainWindow",
                         WS_OVERLAPPEDWINDOW, 0, 0, 200, 100,
                         NULL, NULL, 0, &flags);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    flush_events( FALSE );
    while (PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE))
    {
        if (msg.message == WM_PAINT) loopcount++;
        if (loopcount >= 100) break;
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
        MsgWaitForMultipleObjects(0, NULL, FALSE, 100, QS_ALLINPUT);
    }
    todo_wine_if (flags == (RDW_INVALIDATE | RDW_FRAME))
        ok(loopcount < 100, "Detected infinite WM_PAINT loop (%x).\n", flags);
    DestroyWindow(hwnd);
}

Referenced by test_NCRedraw().

◆ set_focus_on_activate_proc()

static LRESULT WINAPI set_focus_on_activate_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 2960 of file win.c.

{
    if (msg == WM_ACTIVATE && LOWORD(wp) == WA_ACTIVE)
    {
        HWND child = GetWindow(hwnd, GW_CHILD);
        ok(child != 0, "couldn't find child window\n");
        SetFocus(child);
        ok(GetFocus() == child, "Focus should be on child %p\n", child);
        return 0;
    }
    return DefWindowProcA(hwnd, msg, wp, lp);
}

Referenced by test_SetFocus().

◆ set_foreground_thread()

static DWORD WINAPI set_foreground_thread ( void * params )

static

Definition at line 9020 of file win.c.

{
    struct set_foreground_thread_params *p = params;
    MSG msg;
 
    p->thread_window = CreateWindowExA(0, "static", "thread window", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
            0, 0, 10, 10, 0, 0, 0, NULL);
    SetEvent(p->command_executed);
 
    while(GetMessageA(&msg, 0, 0, 0))
    {
        if (msg.message == p->msg_quit)
            break;
 
        if (msg.message == p->msg_command)
        {
            if (msg.wParam & SET_FOREGROUND_STEAL_1)
            {
                SetForegroundWindow(p->thread_window);
                check_wnd_state(p->thread_window, p->thread_window, p->thread_window, 0);
            }
            if (msg.wParam & SET_FOREGROUND_INJECT)
            {
                SendNotifyMessageA(p->window1, WM_ACTIVATEAPP, 0, 0);
            }
            if (msg.wParam & SET_FOREGROUND_SET_1)
            {
                SetForegroundWindow(p->window1);
                check_wnd_state(0, p->window1, 0, 0);
            }
            if (msg.wParam & SET_FOREGROUND_STEAL_2)
            {
                SetForegroundWindow(p->thread_window);
                check_wnd_state(p->thread_window, p->thread_window, p->thread_window, 0);
            }
            if (msg.wParam & SET_FOREGROUND_SET_2)
            {
                SetForegroundWindow(p->window2);
                check_wnd_state(0, p->window2, 0, 0);
            }
 
            SetEvent(p->command_executed);
            continue;
        }
 
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
 
    DestroyWindow(p->thread_window);
    return 0;
}

Referenced by test_activateapp().

◆ settext_msg_thread()

static DWORD CALLBACK settext_msg_thread ( LPVOID arg )

static

Definition at line 6594 of file win.c.

{
    HWND hwnd = arg;
    BOOL success;
 
    /* test SetWindowTextA */
    num_settext_msgs = 0;
    success = SetWindowTextA( hwnd, "thread_caption" );
    ok( success, "SetWindowTextA failed\n" );
    ok( num_settext_msgs == 1, "got %u WM_SETTEXT messages\n", num_settext_msgs );
 
    return 0;
}

Referenced by test_gettext().

◆ simulate_click()

static void simulate_click	(	int	x,
		int	y
	)

static

Definition at line 8307 of file win.c.

{
    INPUT input[2];
    UINT events_no;
 
    SetCursorPos(x, y);
    memset(input, 0, sizeof(input));
    input[0].type = INPUT_MOUSE;
    U(input[0]).mi.dx = x;
    U(input[0]).mi.dy = y;
    U(input[0]).mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
    input[1].type = INPUT_MOUSE;
    U(input[1]).mi.dx = x;
    U(input[1]).mi.dy = y;
    U(input[1]).mi.dwFlags = MOUSEEVENTF_LEFTUP;
    events_no = SendInput(2, input, sizeof(input[0]));
    ok(events_no == 2, "SendInput returned %d\n", events_no);
}

Referenced by START_TEST(), and test_window_from_point().

◆ smresult_thread_proc()

static DWORD WINAPI smresult_thread_proc ( void * param )

static

Definition at line 8846 of file win.c.

{
    MSG msg;
    struct smresult_thread_data *data = param;
 
    data->thread_hwnd = CreateWindowExA(0, "SmresultClass", "window caption text", WS_OVERLAPPEDWINDOW,
                                      100, 100, 200, 200, 0, 0, 0, NULL);
    ok(data->thread_hwnd != 0, "Failed to create overlapped window\n");
 
    SetEvent(data->thread_started);
 
    /* Loop until we've processed WM_APP. */
    while (WaitForSingleObject(data->thread_got_wm_app, 0) != WAIT_OBJECT_0)
    {
        if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessageA(&msg);
        }
        else
        {
            MsgWaitForMultipleObjects(1, &data->thread_got_wm_app, FALSE, INFINITE, QS_SENDMESSAGE);
        }
    }
 
    /* Notify the main thread that we replied to its WM_APP message. */
    SetEvent(data->thread_replied);
 
    while (GetMessageA(&msg, 0, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
 
    return 0;
}

Referenced by test_smresult().

◆ smresult_wndproc()

static LRESULT WINAPI smresult_wndproc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 8789 of file win.c.

{
    switch (msg)
    {
    case WM_APP:
    {
        struct smresult_thread_data *data = (struct smresult_thread_data*)lparam;
 
        ok(hwnd == data->thread_hwnd, "unexpected hwnd %p\n", hwnd);
 
        SendNotifyMessageA(data->main_hwnd, WM_APP+1, 0, lparam);
 
        /* Don't return until the main thread is processing our sent message. */
        ok(WaitForSingleObject(data->main_in_wm_app_1, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
 
        /* Break the PeekMessage loop so we can notify the main thread after we return. */
        SetEvent(data->thread_got_wm_app);
 
        return 0x240408ea;
    }
    case WM_APP+1:
    {
        struct smresult_thread_data *data = (struct smresult_thread_data*)lparam;
        LRESULT res;
 
        ok(hwnd == data->main_hwnd, "unexpected hwnd %p\n", hwnd);
 
        /* Ask the thread to reply to our WM_APP message. */
        SetEvent(data->main_in_wm_app_1);
 
        /* Wait until the thread has sent a reply. */
        ok(WaitForSingleObject(data->thread_replied, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
 
        /* Send another message while we have a reply queued for the current one. */
        res = SendMessageA(data->thread_hwnd, WM_APP+2, 0, lparam);
        ok(res == 0x449b0190, "unexpected result %lx\n", res);
 
        return 0;
    }
    case WM_APP+2:
    {
        struct smresult_thread_data *data = (struct smresult_thread_data*)lparam;
 
        ok(hwnd == data->thread_hwnd, "unexpected hwnd %p\n", hwnd);
 
        /* Don't return until we know the main thread is processing sent messages. */
        SendMessageA(data->main_hwnd, WM_NULL, 0, 0);
 
        return 0x449b0190;
    }
    case WM_CLOSE:
        PostQuitMessage(0);
        break;
    }
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

Referenced by test_smresult().

◆ START_TEST()

START_TEST ( win )

Definition at line 9405 of file win.c.

{
    char **argv;
    int argc = winetest_get_mainargs( &argv );
    HMODULE user32 = GetModuleHandleA( "user32.dll" );
    HMODULE gdi32 = GetModuleHandleA("gdi32.dll");
    pGetAncestor = (void *)GetProcAddress( user32, "GetAncestor" );
    pGetWindowInfo = (void *)GetProcAddress( user32, "GetWindowInfo" );
    pGetWindowModuleFileNameA = (void *)GetProcAddress( user32, "GetWindowModuleFileNameA" );
    pGetLayeredWindowAttributes = (void *)GetProcAddress( user32, "GetLayeredWindowAttributes" );
    pSetLayeredWindowAttributes = (void *)GetProcAddress( user32, "SetLayeredWindowAttributes" );
    pUpdateLayeredWindow = (void *)GetProcAddress( user32, "UpdateLayeredWindow" );
    pUpdateLayeredWindowIndirect = (void *)GetProcAddress( user32, "UpdateLayeredWindowIndirect" );
    pGetMonitorInfoA = (void *)GetProcAddress( user32,  "GetMonitorInfoA" );
    pMonitorFromPoint = (void *)GetProcAddress( user32,  "MonitorFromPoint" );
    pGetWindowRgnBox = (void *)GetProcAddress( user32, "GetWindowRgnBox" );
    pGetGUIThreadInfo = (void *)GetProcAddress( user32, "GetGUIThreadInfo" );
    pGetProcessDefaultLayout = (void *)GetProcAddress( user32, "GetProcessDefaultLayout" );
    pSetProcessDefaultLayout = (void *)GetProcAddress( user32, "SetProcessDefaultLayout" );
    pFlashWindow = (void *)GetProcAddress( user32, "FlashWindow" );
    pFlashWindowEx = (void *)GetProcAddress( user32, "FlashWindowEx" );
    pGetLayout = (void *)GetProcAddress( gdi32, "GetLayout" );
    pSetLayout = (void *)GetProcAddress( gdi32, "SetLayout" );
    pMirrorRgn = (void *)GetProcAddress( gdi32, "MirrorRgn" );
 
    if (argc==4 && !strcmp(argv[2], "create_children"))
    {
        HWND hwnd;
 
        sscanf(argv[3], "%p", &hwnd);
        window_from_point_proc(hwnd);
        return;
    }
 
    if (argc==3 && !strcmp(argv[2], "winproc_limit"))
    {
        test_winproc_limit();
        return;
    }
 
    if (!RegisterWindowClasses()) assert(0);
 
    hwndMain = CreateWindowExA(/*WS_EX_TOOLWINDOW*/ 0, "MainWindowClass", "Main window",
                               WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
                               WS_MAXIMIZEBOX | WS_POPUP | WS_VISIBLE,
                               100, 100, 200, 200,
                               0, 0, GetModuleHandleA(NULL), NULL);
    assert( hwndMain );
 
    if(!SetForegroundWindow(hwndMain)) {
        /* workaround for foreground lock timeout */
        simulate_click(101, 101);
        ok(SetForegroundWindow(hwndMain), "SetForegroundWindow failed\n");
    }
 
    SetLastError(0xdeafbeef);
    GetWindowLongPtrW(GetDesktopWindow(), GWLP_WNDPROC);
    is_win9x = (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED);
 
    hhook = SetWindowsHookExA(WH_CBT, cbt_hook_proc, 0, GetCurrentThreadId());
    if (!hhook) win_skip( "Cannot set CBT hook, skipping some tests\n" );
 
    /* make sure that these tests are executed first */
    test_FindWindowEx();
    test_SetParent();
 
    hwndMain2 = CreateWindowExA(/*WS_EX_TOOLWINDOW*/ 0, "MainWindowClass", "Main window 2",
                                WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
                                WS_MAXIMIZEBOX | WS_POPUP,
                                100, 100, 200, 200,
                                0, 0, GetModuleHandleA(NULL), NULL);
    assert( hwndMain2 );
 
    our_pid = GetWindowThreadProcessId(hwndMain, NULL);
 
    /* Add the tests below this line */
    test_child_window_from_point();
    test_window_from_point(argv[0]);
    test_thick_child_size(hwndMain);
    test_fullscreen();
    test_hwnd_message();
    test_nonclient_area(hwndMain);
    test_params();
    test_GetWindowModuleFileName();
    test_capture_1();
    test_capture_2();
    test_capture_3(hwndMain, hwndMain2);
    test_capture_4();
    test_rtl_layout();
    test_FlashWindow();
    test_FlashWindowEx();
 
    test_CreateWindow();
    test_parent_owner();
    test_enum_thread_windows();
 
    test_mdi();
    test_icons();
    test_SetWindowPos(hwndMain, hwndMain2);
    test_SetMenu(hwndMain);
    test_SetFocus(hwndMain);
    test_SetActiveWindow(hwndMain);
    test_NCRedraw();
 
    test_children_zorder(hwndMain);
    test_popup_zorder(hwndMain2, hwndMain, WS_POPUP);
    test_popup_zorder(hwndMain2, hwndMain, 0);
    test_GetLastActivePopup();
    test_keyboard_input(hwndMain);
    test_mouse_input(hwndM

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ check_active_state

◆ check_wnd_state

◆ check_z_order

◆ COUNTOF

◆ expect_ex_style

◆ expect_gle_broken_9x

◆ expect_menu

◆ expect_style

◆ LONG_PTR

◆ nothing_todo

◆ NUMBER_OF_THICK_CHILD_TESTS

◆ parentdc_field_ok

◆ parentdc_ok

◆ parentdc_rect_ok

◆ parentdc_todo_field_ok

◆ parentdc_win_ok

◆ SET_FOREGROUND_INJECT

◆ SET_FOREGROUND_SET_1

◆ SET_FOREGROUND_SET_2

◆ SET_FOREGROUND_STEAL_1

◆ SET_FOREGROUND_STEAL_2

◆ SHOWSYSMETRIC

◆ SPI_GETDESKWALLPAPER

◆ TEST_MOUSEACTIVATE

◆ ULONG_PTR

◆ WM_SYSTIMER

Function Documentation

◆ AWR_init()

◆ BOOL()

◆ button_hook_proc()

◆ cbt_hook_proc()

◆ check_active_state_()

◆ check_dialog_style()

◆ check_error()

◆ check_parents()

◆ check_style_wnd_proc()

◆ check_window_style()

◆ check_wnd_state_()

◆ check_z_order_debug()

◆ create_tool_window()

◆ create_window_thread()

◆ create_window_tree()

◆ def_window_procA()

◆ def_window_procW()

◆ destroy_dialog_owner_proc()

◆ dump_minmax_info()

◆ dump_region()

◆ DWORD()

◆ empty_dlg_proc()

◆ empty_dlg_proc2()

◆ empty_dlg_proc3()

◆ enum_proc()

◆ enum_thread()

◆ EnumChildProc()

◆ EnumChildProc1()

◆ FixedAdjustWindowRectEx()

◆ flush_events()

◆ fullscreen_wnd_proc()

◆ get_window_attributes()

◆ gettext_msg_thread()

◆ HMONITOR()

◆ HWND()

◆ ignore_message()

◆ int()

◆ main_window_procA()

◆ main_window_procW()

◆ mdi_child_wnd_proc_1()

◆ mdi_child_wnd_proc_2()

◆ MDI_ChildGetMinMaxInfo()

◆ mdi_main_wnd_procA()

◆ mdi_RegisterWindowClasses()

◆ minmax_wnd_proc()

◆ my_httrasparent_proc()

◆ my_window_proc()

◆ nccalchelper()