win.c File Reference

#include "precomp.h"

Include dependency graph for win.c:

Go to the source code of this file.

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 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);

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);

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 __acrt_EnumSystemLocalesEx(), enum_system_locales_ex_nolock(), and 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(